module.exports = PrimitiveMap = function (/*iterable, serialize*/) {
var iterable = arguments[0], serialize = arguments[1], self;
if (!(this instanceof PrimitiveMap)) throw new TypeError('Constructor requires \'new\'');
if (isNative && setPrototypeOf && (Map !== MapPolyfill)) {
self = setPrototypeOf(new Map(), getPrototypeOf(this));
} else {
self = this;
}
if (iterable != null) iterator(iterable);
if (serialize !== undefined) {
callable(serialize);
defineProperty(self, '_serialize', d('', serialize));
}
defineProperties(self, {
__mapKeysData__: d('c', create(null)),
__mapValuesData__: d('c', create(null)),
__size__: d('w', 0)
});
if (!iterable) return self;
forOf(iterable, function (value) {
var key = validValue(value)[0], sKey = self._serialize(key);
if (sKey == null) throw new TypeError(key + " cannot be serialized");
value = value[1];
if (hasOwnProperty.call(self.__mapKeysData__, sKey)) {
if (self.__mapValuesData__[sKey] === value) return;
} else {
++self.__size__;
}
self.__mapKeysData__[sKey] = key;
self.__mapValuesData__[sKey] = value;
});
return self;
};
module.exports = function (t, a) {
var db = new Database(), Type = t(db), obj = Object(Type(342));
setPrototypeOf(obj, Type.prototype);
a(obj.toString(), '342HP');
a.throws(function () { Type(-34); }, 'NUMBER_TOO_SMALL', "Out of range");
};
module.exports = Multiple = function (obj, pSKey) {
return defineProperties(setPrototypeOf(new Set(), Multiple.prototype), {
object: d('', obj),
dbId: d('', obj.__id__ + '/' + pSKey),
__pSKey__: d('', pSKey),
__setData__: d('', obj._getMultipleItems_(pSKey))
});
};
ReverseMap = module.exports = function (obj, sKey) {
var desc, self = setPrototypeOf(new Map(), ReverseMap.prototype);
defineProperty(self, '__descriptor__', d('',
desc = obj._getOwnDescriptor_(sKey)));
desc = desc.__descriptors__.reverse;
if (desc && (desc._value_ !== undefined)) obj._serialize_(desc._value_);
self._includeObjBranch_(obj, sKey, null, true);
return self;
};
Observable = function (/*iterable, comparator*/) {
var comparator = arguments[1], set;
if (!(this instanceof Observable)) throw new TypeError('Constructor requires \'new\'');
set = new Constructor(arguments[0], arguments[1]);
if (setPrototypeOf) setPrototypeOf(set, getPrototypeOf(this));
else mixin(set, getPrototypeOf(this));
if (!set.__comparator__) defineProperty(set, '__comparator__', d('', comparator));
return set;
};
validate: d(function (value) {
if (!isRegExp(value)) {
try {
value = RegExp(value);
} catch (e) {
throw new DbjsError(value + " is invalid regular expression", 'INVALID_REGEXP');
}
}
return setPrototypeOf(value, this.prototype);
}),
normalize: d(function (value) {
if (!isRegExp(value)) {
try {
value = RegExp(value);
} catch (e) {
return null;
}
}
return setPrototypeOf(value, this.prototype);
}),
path.reverse().forEach(function (name) {
if (!context.hasOwnProperty(name)) {
defineProperty(context, name, d('cew', {}));
if (dbjsObj[name]) {
setPrototypeOf(context[name], dbjsObj[name]);
dbjsObj = dbjsObj[name];
}
}
context = context[name];
});
obj.__descendants__._plainForEach_(function (obj) {
var desc, oldProto;
if (obj.hasOwnProperty('__descriptors__') &&
hasOwnProperty.call(obj.__descriptors__, sKey)) {
desc = obj.__descriptors__[sKey];
oldProto = getPrototypeOf(desc);
setPrototypeOf(desc, proto);
oldProto.__descendants__._delete(desc);
proto._descendants_._add(desc);
return;
}
inject(obj, proto, base);
});
module.exports = SetsSet = function (multiSet, iterable) {
var sets, set;
if (!(this instanceof SetsSet)) throw new TypeError('Constructor requires \'new\'');
if (iterable != null) {
iterator(iterable);
sets = [];
forOf(iterable, function (value) {
sets.push(validObservableSet(value));
});
}
set = new Set(sets);
if (setPrototypeOf) setPrototypeOf(set, getPrototypeOf(this));
else mixin(set, getPrototypeOf(this));
defineProperty(set, '__master__', d('', multiSet));
return set;
};
module.exports = WeakMapPoly = function (/*iterable*/) {
var iterable = arguments[0], self;
if (!(this instanceof WeakMapPoly)) throw new TypeError('Constructor requires \'new\'');
if (isNative && setPrototypeOf) self = setPrototypeOf(new WeakMap(), getPrototypeOf(this));
else self = this;
if (iterable != null) {
if (!isArray(iterable)) iterable = getIterator(iterable);
}
defineProperty(self, '__weakMapData__', d('c', '$weakMap$' + randomUniq()));
if (!iterable) return self;
forOf(iterable, function (val) {
value(val);
self.set(val[0], val[1]);
});
return self;
};
Instances = module.exports = function (Type) {
var sets = new Set(), onAdd, onDelete, onChange, self;
onAdd = function (prototype) {
sets.add(prototype._descendants_.filter(filter));
prototype._descendants_.on('change', onChange);
prototype._descendants_.forEach(onAdd);
};
onDelete = function (prototype) {
sets.delete(prototype._descendants_.filter(filter));
prototype._descendants_.off('change', onChange);
prototype._descendants_.forEach(onDelete);
};
onChange = function (event) {
var type = event.type, obj;
if (type === 'add') {
obj = event.value;
if (obj.master.constructor === obj.master.constructor.prototype) onAdd(obj);
return;
}
if (type === 'delete') {
obj = event.value;
if (obj.master.constructor === obj.master.constructor.prototype) onDelete(obj);
return;
}
if (event.type === 'batch') {
if (event.added) {
event.added.forEach(function (obj) {
if (obj.master.constructor === obj.master.constructor.prototype) onAdd(obj);
});
}
if (event.deleted) {
event.deleted.forEach(function (obj) {
if (obj.master.constructor === obj.master.constructor.prototype) onAdd(obj);
});
}
return;
}
console.log("Errorneous event:", event);
throw new Error("Unsupported event: " + event.type);
};
onAdd(Type.prototype);
self = setPrototypeOf(new MultiSet(sets, serialize), Instances.prototype);
defineProperty(self, 'dbId', d(Type.__id__));
sets = self.sets;
return self;
};
forEach(getInputValue.call(this), function (value, keyPath) {
var names = tokenize(keyPath.slice()), propName = names.pop(), name
, obj = mock, dbjsObj = this.observable.object.master;
names.shift(); // clear object id
while ((name = names.shift())) {
if (!obj.hasOwnProperty(name)) {
defineProperty(obj, name, d('cew', {}));
if (dbjsObj[name]) {
setPrototypeOf(obj[name], dbjsObj[name]);
defineProperty(obj[name], 'owner', d('cew', obj));
defineProperty(obj[name], 'master', d('cew', mock));
dbjsObj = dbjsObj[name];
}
}
obj = obj[name];
}
defineProperty(obj, propName, d('cew', value));
defineProperty(obj, '_' + propName, d('cew', value));
}, this);
inputValue: d.gs(function () {
var mock = setPrototypeOf({}, this.observable.object.master), context = mock
, path, current, dbjsObj;
forEach(getInputValue.call(this), function (value, keyPath) {
var names = tokenize(keyPath.slice()), propName = names.pop(), name
, obj = mock, dbjsObj = this.observable.object.master;
names.shift(); // clear object id
while ((name = names.shift())) {
if (!obj.hasOwnProperty(name)) {
defineProperty(obj, name, d('cew', {}));
if (dbjsObj[name]) {
setPrototypeOf(obj[name], dbjsObj[name]);
defineProperty(obj[name], 'owner', d('cew', obj));
defineProperty(obj[name], 'master', d('cew', mock));
dbjsObj = dbjsObj[name];
}
}
obj = obj[name];
}
defineProperty(obj, propName, d('cew', value));
defineProperty(obj, '_' + propName, d('cew', value));
}, this);
if (this.observable.object !== this.observable.object.master) {
path = [];
current = this.observable.object;
while (current && (current !== this.observable.object.master)) {
path.push(current.key);
current = current.owner;
}
dbjsObj = this.observable.object.master;
path.reverse().forEach(function (name) {
if (!context.hasOwnProperty(name)) {
defineProperty(context, name, d('cew', {}));
if (dbjsObj[name]) {
setPrototypeOf(context[name], dbjsObj[name]);
dbjsObj = dbjsObj[name];
}
}
context = context[name];
});
}
return this.getValue.call(context, observeMock);
}, noop)
module.exports = MapPoly = function (/*iterable*/) {
var iterable = arguments[0], keys, values, self;
if (!(this instanceof MapPoly)) throw new TypeError('Constructor requires \'new\'');
if (isNative && setPrototypeOf && (Map !== MapPoly)) {
self = setPrototypeOf(new Map(), getPrototypeOf(this));
} else {
self = this;
}
if (iterable != null) iterator(iterable);
defineProperties(self, {
__mapKeysData__: d('c', keys = []),
__mapValuesData__: d('c', values = [])
});
if (!iterable) return self;
forOf(iterable, function (value) {
var key = validValue(value)[0];
value = value[1];
if (eIndexOf.call(keys, key) !== -1) return;
keys.push(key);
values.push(value);
}, self);
return self;
};
Extensions = module.exports = function (Type) {
var sets = new Set(), onAdd, onDelete, onChange, self;
onAdd = function (Constructor) {
sets.add(Constructor._descendants_);
Constructor._descendants_.on('change', onChange);
Constructor._descendants_.forEach(onAdd);
};
onDelete = function (Constructor) {
sets.delete(Constructor._descendants_);
Constructor._descendants_.off('change', onChange);
Constructor._descendants_.forEach(onDelete);
};
onChange = function (event) {
var type = event.type;
if (type === 'add') {
onAdd(event.value);
return;
}
if (type === 'delete') {
onDelete(event.value);
return;
}
if (event.type === 'batch') {
if (event.added) event.added.forEach(onAdd);
if (event.deleted) event.deleted.forEach(onDelete);
return;
}
console.log("Errorneous event:", event);
throw new Error("Unsupported event: " + event.type);
};
onAdd(Type);
self = setPrototypeOf(new MultiSet(sets, serialize), Extensions.prototype);
defineProperty(self, 'dbId', d(Type.__id__));
sets = self.sets;
return self;
};
isTruthy = function (sKey) {
var item = this[sKey];
if (!item.hasOwnProperty('_value_')) return false;
return item._value_;
};
module.exports = Multiple = function (obj, pSKey) {
return defineProperties(setPrototypeOf(new Set(), Multiple.prototype), {
object: d('', obj),
dbId: d('', obj.__id__ + '/' + pSKey),
__pSKey__: d('', pSKey),
__setData__: d('', obj._getMultipleItems_(pSKey))
});
};
setPrototypeOf(Multiple, Set);
Multiple.prototype = create(Set.prototype, assign({
constructor: d(Multiple),
dbKind: d('multiple'),
_serialize: d(serialize),
add: d(function (key) {
var obj = this.object;
key = obj._validateMultipleAdd_(this.__pSKey__, key);
obj._multipleAdd_(this.__pSKey__, key, serialize(key));
return this;
}),
clear: d(function () {
this.object.database._postponed += 1;
this._validateClear_().forEach(function (sKey) {
var item = this.__setData__[sKey];
}
if (type === 'delete') {
onDelete(event.value);
return;
}
if (event.type === 'batch') {
if (event.added) event.added.forEach(onAdd);
if (event.deleted) event.deleted.forEach(onDelete);
return;
}
console.log("Errorneous event:", event);
throw new Error("Unsupported event: " + event.type);
};
onAdd(Type);
self = setPrototypeOf(new MultiSet(sets, serialize), Extensions.prototype);
defineProperty(self, 'dbId', d(Type.__id__));
sets = self.sets;
return self;
};
setPrototypeOf(Extensions, MultiSet);
Extensions.prototype = Object.create(MultiSet.prototype, {
constructor: d(Extensions),
dbKind: d('extensions'),
first: d.gs(setGetFirst),
last: d.gs(setGetLast),
copy: d(setCopy),
every: d(setEvery),
some: d(setSome)
});
, defineProperties = Object.defineProperties, keys = Object.keys
, unBind = Iterator.prototype._unBind
, PrimitiveSetIterator;
PrimitiveSetIterator = module.exports = function( set, kind ) {
if( !(this instanceof PrimitiveSetIterator) ) {
return new PrimitiveSetIterator( set, kind );
}
Iterator.call( this, keys( set.__setData__ ), set );
kind = (!kind || !contains.call( kind, 'key+value' )) ? 'value' : 'key+value';
defineProperties( this, {
__kind__: d( '', kind ),
__data__: d( 'w', set.__setData__ )
} );
};
if( setPrototypeOf ) setPrototypeOf( PrimitiveSetIterator, Iterator );
PrimitiveSetIterator.prototype = Object.create( Iterator.prototype, assign( {
constructor: d( PrimitiveSetIterator ),
_resolve: d( function( i ) {
var value = this.__data__[this.__list__[i]];
return (this.__kind__ === 'value') ? value : [value, value];
} ),
_unBind: d( function() {
this.__data__ = null;
unBind.call( this );
} ),
toString: d( function() {
return '[object Set Iterator]';
} )
}, autoBind( {
'use strict';
var setPrototypeOf = require("es5-ext/object/set-prototype-of"),
d = require("d"),
Iterator = require("../index"),
validIterable = require("../valid-iterable"),
push = Array.prototype.push,
defineProperties = Object.defineProperties,
IteratorChain;
IteratorChain = function(iterators) {
defineProperties(this, {
__iterators__: d('', iterators),
__current__: d('w', iterators.shift())
});
};
if (setPrototypeOf)
setPrototypeOf(IteratorChain, Iterator);
IteratorChain.prototype = Object.create(Iterator.prototype, {
constructor: d(IteratorChain),
next: d(function() {
var result;
if (!this.__current__)
return {
done: true,
value: undefined
};
result = this.__current__.next();
while (result.done) {
this.__current__ = this.__iterators__.shift();
if (!this.__current__)
return {
done: true,
if (isNative && setPrototypeOf) self = setPrototypeOf(new WeakMap(), getPrototypeOf(this));
else self = this;
if (iterable != null) {
if (!isArray(iterable)) iterable = getIterator(iterable);
}
defineProperty(self, '__weakMapData__', d('c', '$weakMap$' + randomUniq()));
if (!iterable) return self;
forOf(iterable, function (val) {
value(val);
self.set(val[0], val[1]);
});
return self;
};
if (isNative) {
if (setPrototypeOf) setPrototypeOf(WeakMapPoly, WeakMap);
WeakMapPoly.prototype = Object.create(WeakMap.prototype, {
constructor: d(WeakMapPoly)
});
}
Object.defineProperties(WeakMapPoly.prototype, {
delete: d(function (key) {
if (hasOwnProperty.call(object(key), this.__weakMapData__)) {
delete key[this.__weakMapData__];
return true;
}
return false;
}),
get: d(function (key) {
if (hasOwnProperty.call(object(key), this.__weakMapData__)) {
module.exports = function (t, a) {
var db = new Database(), Type = t(db), obj = Object(Type(23));
setPrototypeOf(obj, Type.prototype);
a(obj.toString(), '23m²');
};
var setPrototypeOf = require("es5-ext/object/set-prototype-of")
, contains = require("es5-ext/string/#/contains")
, d = require("d")
, Symbol = require("es6-symbol")
, Iterator = require("./");
var defineProperty = Object.defineProperty, ArrayIterator;
ArrayIterator = module.exports = function (arr, kind) {
if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
Iterator.call(this, arr);
if (!kind) kind = "value";
else if (contains.call(kind, "key+value")) kind = "key+value";
else if (contains.call(kind, "key")) kind = "key";
else kind = "value";
defineProperty(this, "__kind__", d("", kind));
};
if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
// Internal %ArrayIteratorPrototype% doesn't expose its constructor
delete ArrayIterator.prototype.constructor;
ArrayIterator.prototype = Object.create(Iterator.prototype, {
_resolve: d(function (i) {
if (this.__kind__ === "value") return this.__list__[i];
if (this.__kind__ === "key+value") return [i, this.__list__[i]];
return i;
})
});
defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));
Constructor._descendants_.off('change', onChange);
Constructor._descendants_.forEach(onDelete);
};
onChange = function (event) {
var type = event.type;
if (type === 'add') {
onAdd(event.value);
return;
}
if (type === 'delete') {
onDelete(event.value);
return;
}
if (event.type === 'batch') {
if (event.added) event.added.forEach(onAdd);
if (event.deleted) event.deleted.forEach(onDelete);
return;
}
console.log("Errorneous event:", event);
throw new Error("Unsupported event: " + event.type);
};
onAdd(Type);
MultiSet.call(this, sets, serialize);
sets = this.sets;
};
setPrototypeOf(Instances, MultiSet);
Instances.prototype = Object.create(MultiSet.prototype, {
constructor: d(Instances)
});
, contains = require( 'es5-ext/string/#/contains' )
, d = require( 'd' )
, Iterator = require( 'es6-iterator' )
, toStringTagSymbol = require( 'es6-symbol' ).toStringTag
, defineProperty = Object.defineProperty
, SetIterator;
SetIterator = module.exports = function( set, kind ) {
if( !(this instanceof SetIterator) ) return new SetIterator( set, kind );
Iterator.call( this, set.__setData__, set );
if( !kind ) kind = 'value';
else if( contains.call( kind, 'key+value' ) ) kind = 'key+value';
else kind = 'value';
defineProperty( this, '__kind__', d( '', kind ) );
};
if( setPrototypeOf ) setPrototypeOf( SetIterator, Iterator );
SetIterator.prototype = Object.create( Iterator.prototype, {
constructor: d( SetIterator ),
_resolve: d( function( i ) {
if( this.__kind__ === 'value' ) return this.__list__[i];
return [this.__list__[i], this.__list__[i]];
} ),
toString: d( function() {
return '[object Set Iterator]';
} )
} );
defineProperty( SetIterator.prototype, toStringTagSymbol,
d( 'c', 'Set Iterator' ) );
'use strict';
var setPrototypeOf = require('es5-ext/object/set-prototype-of')
, d = require('d')
, ObjectsSet = require('./objects-set')
, TypeAssignmentsSet;
module.exports = TypeAssignmentsSet = function () {
return setPrototypeOf(new ObjectsSet(), TypeAssignmentsSet.prototype);
};
setPrototypeOf(TypeAssignmentsSet, ObjectsSet);
TypeAssignmentsSet.prototype = Object.create(ObjectsSet.prototype, {
constructor: d(TypeAssignmentsSet),
dbKind: d('typeAssigments')
});
module.exports = TypeAssignmentsSet = function () {
return setPrototypeOf(new ObjectsSet(), TypeAssignmentsSet.prototype);
};
'use strict';
var setPrototypeOf = require('es5-ext/object/set-prototype-of')
, d = require('d')
, ObservableArray = require('observable-array/create-read-only')(
require('observable-array')
)
, unshift = Array.prototype.unshift
, History;
History = module.exports = function (length) {
return ObservableArray.call(this);
};
setPrototypeOf(History, ObservableArray);
History.prototype = Object.create(ObservableArray.prototype, {
constructor: d(History),
_add_: d(function (event) {
var previous = this[0], index, l, other;
if (previous) {
if (previous.stamp > event.stamp) {
// Outdated event, add to history if applicable and quit
l = this.length;
index = 1;
while ((index < l) && (this[index].stamp > event.stamp)) ++index;
if (index === l) {
this._set(index, event);
return;
}
var setPrototypeOf = require('es5-ext/object/set-prototype-of')
, d = require('d')
, Iterator = require('./')
, defineProperty = Object.defineProperty
, StringIterator;
StringIterator = module.exports = function (str) {
if (!(this instanceof StringIterator)) return new StringIterator(str);
str = String(str);
Iterator.call(this, str);
defineProperty(this, '__length__', d('', str.length));
};
if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
StringIterator.prototype = Object.create(Iterator.prototype, {
constructor: d(StringIterator),
_next: d(function () {
if (!this.__list__) return;
if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
this._unBind();
}),
_resolve: d(function (i) {
var char = this.__list__[i], code;
if (this.__nextIndex__ === this.__length__) return char;
code = char.charCodeAt(0);
if ((code >= 0xD800) && (code <= 0xDBFF)) return char + this.__list__[this.__nextIndex__++];
return char;
}),
if (!iterable) return self;
forOf(iterable, function (value) {
var key = validValue(value)[0], sKey = self._serialize(key);
if (sKey == null) throw new TypeError(key + " cannot be serialized");
value = value[1];
if (hasOwnProperty.call(self.__mapKeysData__, sKey)) {
if (self.__mapValuesData__[sKey] === value) return;
} else {
++self.__size__;
}
self.__mapKeysData__[sKey] = key;
self.__mapValuesData__[sKey] = value;
});
return self;
};
if (setPrototypeOf) setPrototypeOf(PrimitiveMap, MapPolyfill);
PrimitiveMap.prototype = create(MapPolyfill.prototype, {
constructor: d(PrimitiveMap),
_serialize: d(function (value) {
if (value && (typeof value.toString !== 'function')) return null;
return String(value);
}),
clear: d(function () {
if (!this.__size__) return;
clear(this.__mapKeysData__);
clear(this.__mapValuesData__);
this.__size__ = 0;
this.emit('_clear');
}),
delete: d(function (key) {