From 18a81daee6c92c3c3a18084c966236e580be476d Mon Sep 17 00:00:00 2001 From: Kevin Phillips Date: Thu, 22 Jun 2017 22:08:25 -0500 Subject: [PATCH] 3.2.0 --- dist/amd/can-simple-map.js | 100 ++++++++++++++++ dist/cjs/can-simple-map.js | 98 ++++++++++++++++ dist/global/can-simple-map.js | 215 ++++++++++++++++++++++++++++++++++ 3 files changed, 413 insertions(+) create mode 100644 dist/amd/can-simple-map.js create mode 100644 dist/cjs/can-simple-map.js create mode 100644 dist/global/can-simple-map.js diff --git a/dist/amd/can-simple-map.js b/dist/amd/can-simple-map.js new file mode 100644 index 0000000..2cf6423 --- /dev/null +++ b/dist/amd/can-simple-map.js @@ -0,0 +1,100 @@ +/*can-simple-map@3.2.0-pre.8#can-simple-map*/ +define(function (require, exports, module) { + var Construct = require('can-construct'); + var canEvent = require('can-event'); + var canBatch = require('can-event/batch'); + var assign = require('can-util/js/assign'); + var each = require('can-util/js/each'); + var types = require('can-types'); + var Observation = require('can-observation'); + var canSymbol = require('can-symbol'); + var canReflect = require('can-reflect'); + var singleReference = require('can-util/js/single-reference'); + var SimpleMap = Construct.extend({ + setup: function (initialData) { + this._data = {}; + this.attr(initialData); + }, + attr: function (prop, value) { + var self = this; + if (arguments.length === 0) { + Observation.add(this, '__keys'); + var data = {}; + each(this._data, function (value, prop) { + Observation.add(this, prop); + data[prop] = value; + }, this); + return data; + } else if (arguments.length > 1) { + var had = this._data.hasOwnProperty(prop); + var old = this._data[prop]; + this._data[prop] = value; + canBatch.start(); + if (!had) { + canEvent.dispatch.call(this, '__keys', []); + } + canEvent.dispatch.call(this, prop, [ + value, + old + ]); + canBatch.stop(); + } else if (typeof prop === 'object') { + canReflect.eachKey(prop, function (value, key) { + self.attr(key, value); + }); + } else { + if (prop !== 'constructor') { + Observation.add(this, prop); + return this._data[prop]; + } + return this.constructor; + } + }, + serialize: function () { + var serialized = {}; + Observation.add(this, '__keys'); + each(this._data, function (data, prop) { + Observation.add(this, prop); + serialized[prop] = data && typeof data.serialize === 'function' ? data.serialize() : data; + }, this); + return serialized; + }, + get: function () { + return this.attr.apply(this, arguments); + }, + set: function () { + return this.attr.apply(this, arguments); + } + }); + assign(SimpleMap.prototype, canEvent); + if (!types.DefaultMap) { + types.DefaultMap = SimpleMap; + } + SimpleMap.prototype[canSymbol.for('can.onKeyValue')] = function (key, handler) { + var translationHandler = function (ev, newValue, oldValue) { + handler.call(this, newValue, oldValue); + }; + singleReference.set(handler, this, translationHandler, key); + this.addEventListener(key, translationHandler); + }; + SimpleMap.prototype[canSymbol.for('can.offKeyValue')] = function (key, handler) { + this.removeEventListener(key, singleReference.getAndDelete(handler, this, key)); + }; + SimpleMap.prototype[canSymbol.for('can.isMapLike')] = true; + SimpleMap.prototype[canSymbol.for('can.isListLike')] = false; + SimpleMap.prototype[canSymbol.for('can.isValueLike')] = false; + SimpleMap.prototype[canSymbol.for('can.getKeyValue')] = SimpleMap.prototype.get; + SimpleMap.prototype[canSymbol.for('can.setKeyValue')] = SimpleMap.prototype.set; + SimpleMap.prototype[canSymbol.for('can.getValue')] = SimpleMap.prototype.get; + SimpleMap.prototype[canSymbol.for('can.setValue')] = SimpleMap.prototype.set; + SimpleMap.prototype[canSymbol.for('can.deleteKeyValue')] = function (prop) { + return this.attr(prop, undefined); + }; + SimpleMap.prototype[canSymbol.for('can.keyHasDependencies')] = function (key) { + return false; + }; + SimpleMap.prototype[canSymbol.for('can.getKeyDependencies')] = function (key) { + return undefined; + }; + module.exports = SimpleMap; +}); \ No newline at end of file diff --git a/dist/cjs/can-simple-map.js b/dist/cjs/can-simple-map.js new file mode 100644 index 0000000..34b5bf3 --- /dev/null +++ b/dist/cjs/can-simple-map.js @@ -0,0 +1,98 @@ +/*can-simple-map@3.2.0-pre.8#can-simple-map*/ +var Construct = require('can-construct'); +var canEvent = require('can-event'); +var canBatch = require('can-event/batch/batch'); +var assign = require('can-util/js/assign/assign'); +var each = require('can-util/js/each/each'); +var types = require('can-types'); +var Observation = require('can-observation'); +var canSymbol = require('can-symbol'); +var canReflect = require('can-reflect'); +var singleReference = require('can-util/js/single-reference/single-reference'); +var SimpleMap = Construct.extend({ + setup: function (initialData) { + this._data = {}; + this.attr(initialData); + }, + attr: function (prop, value) { + var self = this; + if (arguments.length === 0) { + Observation.add(this, '__keys'); + var data = {}; + each(this._data, function (value, prop) { + Observation.add(this, prop); + data[prop] = value; + }, this); + return data; + } else if (arguments.length > 1) { + var had = this._data.hasOwnProperty(prop); + var old = this._data[prop]; + this._data[prop] = value; + canBatch.start(); + if (!had) { + canEvent.dispatch.call(this, '__keys', []); + } + canEvent.dispatch.call(this, prop, [ + value, + old + ]); + canBatch.stop(); + } else if (typeof prop === 'object') { + canReflect.eachKey(prop, function (value, key) { + self.attr(key, value); + }); + } else { + if (prop !== 'constructor') { + Observation.add(this, prop); + return this._data[prop]; + } + return this.constructor; + } + }, + serialize: function () { + var serialized = {}; + Observation.add(this, '__keys'); + each(this._data, function (data, prop) { + Observation.add(this, prop); + serialized[prop] = data && typeof data.serialize === 'function' ? data.serialize() : data; + }, this); + return serialized; + }, + get: function () { + return this.attr.apply(this, arguments); + }, + set: function () { + return this.attr.apply(this, arguments); + } +}); +assign(SimpleMap.prototype, canEvent); +if (!types.DefaultMap) { + types.DefaultMap = SimpleMap; +} +SimpleMap.prototype[canSymbol.for('can.onKeyValue')] = function (key, handler) { + var translationHandler = function (ev, newValue, oldValue) { + handler.call(this, newValue, oldValue); + }; + singleReference.set(handler, this, translationHandler, key); + this.addEventListener(key, translationHandler); +}; +SimpleMap.prototype[canSymbol.for('can.offKeyValue')] = function (key, handler) { + this.removeEventListener(key, singleReference.getAndDelete(handler, this, key)); +}; +SimpleMap.prototype[canSymbol.for('can.isMapLike')] = true; +SimpleMap.prototype[canSymbol.for('can.isListLike')] = false; +SimpleMap.prototype[canSymbol.for('can.isValueLike')] = false; +SimpleMap.prototype[canSymbol.for('can.getKeyValue')] = SimpleMap.prototype.get; +SimpleMap.prototype[canSymbol.for('can.setKeyValue')] = SimpleMap.prototype.set; +SimpleMap.prototype[canSymbol.for('can.getValue')] = SimpleMap.prototype.get; +SimpleMap.prototype[canSymbol.for('can.setValue')] = SimpleMap.prototype.set; +SimpleMap.prototype[canSymbol.for('can.deleteKeyValue')] = function (prop) { + return this.attr(prop, undefined); +}; +SimpleMap.prototype[canSymbol.for('can.keyHasDependencies')] = function (key) { + return false; +}; +SimpleMap.prototype[canSymbol.for('can.getKeyDependencies')] = function (key) { + return undefined; +}; +module.exports = SimpleMap; \ No newline at end of file diff --git a/dist/global/can-simple-map.js b/dist/global/can-simple-map.js new file mode 100644 index 0000000..ddcc476 --- /dev/null +++ b/dist/global/can-simple-map.js @@ -0,0 +1,215 @@ +/*[global-shim-start]*/ +(function(exports, global, doEval){ // jshint ignore:line + var origDefine = global.define; + + var get = function(name){ + var parts = name.split("."), + cur = global, + i; + for(i = 0 ; i < parts.length; i++){ + if(!cur) { + break; + } + cur = cur[parts[i]]; + } + return cur; + }; + var set = function(name, val){ + var parts = name.split("."), + cur = global, + i, part, next; + for(i = 0; i < parts.length - 1; i++) { + part = parts[i]; + next = cur[part]; + if(!next) { + next = cur[part] = {}; + } + cur = next; + } + part = parts[parts.length - 1]; + cur[part] = val; + }; + var useDefault = function(mod){ + if(!mod || !mod.__esModule) return false; + var esProps = { __esModule: true, "default": true }; + for(var p in mod) { + if(!esProps[p]) return false; + } + return true; + }; + var modules = (global.define && global.define.modules) || + (global._define && global._define.modules) || {}; + var ourDefine = global.define = function(moduleName, deps, callback){ + var module; + if(typeof deps === "function") { + callback = deps; + deps = []; + } + var args = [], + i; + for(i =0; i < deps.length; i++) { + args.push( exports[deps[i]] ? get(exports[deps[i]]) : ( modules[deps[i]] || get(deps[i]) ) ); + } + // CJS has no dependencies but 3 callback arguments + if(!deps.length && callback.length) { + module = { exports: {} }; + var require = function(name) { + return exports[name] ? get(exports[name]) : modules[name]; + }; + args.push(require, module.exports, module); + } + // Babel uses the exports and module object. + else if(!args[0] && deps[0] === "exports") { + module = { exports: {} }; + args[0] = module.exports; + if(deps[1] === "module") { + args[1] = module; + } + } else if(!args[0] && deps[0] === "module") { + args[0] = { id: moduleName }; + } + + global.define = origDefine; + var result = callback ? callback.apply(null, args) : undefined; + global.define = ourDefine; + + // Favor CJS module.exports over the return value + result = module && module.exports ? module.exports : result; + modules[moduleName] = result; + + // Set global exports + var globalExport = exports[moduleName]; + if(globalExport && !get(globalExport)) { + if(useDefault(result)) { + result = result["default"]; + } + set(globalExport, result); + } + }; + global.define.orig = origDefine; + global.define.modules = modules; + global.define.amd = true; + ourDefine("@loader", [], function(){ + // shim for @@global-helpers + var noop = function(){}; + return { + get: function(){ + return { prepareGlobal: noop, retrieveGlobal: noop }; + }, + global: global, + __exec: function(__load){ + doEval(__load.source, global); + } + }; + }); +} +)({},window,function(__$source__, __$global__) { // jshint ignore:line + eval("(function() { " + __$source__ + " \n }).call(__$global__);"); +} +) +/*can-simple-map@3.2.0-pre.8#can-simple-map*/ +define('can-simple-map', function (require, exports, module) { + var Construct = require('can-construct'); + var canEvent = require('can-event'); + var canBatch = require('can-event/batch/batch'); + var assign = require('can-util/js/assign/assign'); + var each = require('can-util/js/each/each'); + var types = require('can-types'); + var Observation = require('can-observation'); + var canSymbol = require('can-symbol'); + var canReflect = require('can-reflect'); + var singleReference = require('can-util/js/single-reference/single-reference'); + var SimpleMap = Construct.extend({ + setup: function (initialData) { + this._data = {}; + this.attr(initialData); + }, + attr: function (prop, value) { + var self = this; + if (arguments.length === 0) { + Observation.add(this, '__keys'); + var data = {}; + each(this._data, function (value, prop) { + Observation.add(this, prop); + data[prop] = value; + }, this); + return data; + } else if (arguments.length > 1) { + var had = this._data.hasOwnProperty(prop); + var old = this._data[prop]; + this._data[prop] = value; + canBatch.start(); + if (!had) { + canEvent.dispatch.call(this, '__keys', []); + } + canEvent.dispatch.call(this, prop, [ + value, + old + ]); + canBatch.stop(); + } else if (typeof prop === 'object') { + canReflect.eachKey(prop, function (value, key) { + self.attr(key, value); + }); + } else { + if (prop !== 'constructor') { + Observation.add(this, prop); + return this._data[prop]; + } + return this.constructor; + } + }, + serialize: function () { + var serialized = {}; + Observation.add(this, '__keys'); + each(this._data, function (data, prop) { + Observation.add(this, prop); + serialized[prop] = data && typeof data.serialize === 'function' ? data.serialize() : data; + }, this); + return serialized; + }, + get: function () { + return this.attr.apply(this, arguments); + }, + set: function () { + return this.attr.apply(this, arguments); + } + }); + assign(SimpleMap.prototype, canEvent); + if (!types.DefaultMap) { + types.DefaultMap = SimpleMap; + } + SimpleMap.prototype[canSymbol.for('can.onKeyValue')] = function (key, handler) { + var translationHandler = function (ev, newValue, oldValue) { + handler.call(this, newValue, oldValue); + }; + singleReference.set(handler, this, translationHandler, key); + this.addEventListener(key, translationHandler); + }; + SimpleMap.prototype[canSymbol.for('can.offKeyValue')] = function (key, handler) { + this.removeEventListener(key, singleReference.getAndDelete(handler, this, key)); + }; + SimpleMap.prototype[canSymbol.for('can.isMapLike')] = true; + SimpleMap.prototype[canSymbol.for('can.isListLike')] = false; + SimpleMap.prototype[canSymbol.for('can.isValueLike')] = false; + SimpleMap.prototype[canSymbol.for('can.getKeyValue')] = SimpleMap.prototype.get; + SimpleMap.prototype[canSymbol.for('can.setKeyValue')] = SimpleMap.prototype.set; + SimpleMap.prototype[canSymbol.for('can.getValue')] = SimpleMap.prototype.get; + SimpleMap.prototype[canSymbol.for('can.setValue')] = SimpleMap.prototype.set; + SimpleMap.prototype[canSymbol.for('can.deleteKeyValue')] = function (prop) { + return this.attr(prop, undefined); + }; + SimpleMap.prototype[canSymbol.for('can.keyHasDependencies')] = function (key) { + return false; + }; + SimpleMap.prototype[canSymbol.for('can.getKeyDependencies')] = function (key) { + return undefined; + }; + module.exports = SimpleMap; +}); +/*[global-shim-end]*/ +(function(){ // jshint ignore:line + window._define = window.define; + window.define = window.define.orig; +} +)(); \ No newline at end of file