mnemonica 0.9.93 → 0.9.98

package/build/api/types/Mnemosyne.js

@@ -1,122 +1,138 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
-const constants_1 = require('../../constants');
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
 const { odp, SymbolConstructorName, SymbolGaia, SymbolReplaceGaia, MNEMONICA, GAIA, URANUS } = constants_1.constants;
-const utils_1 = require('../utils');
+const utils_1 = require("../utils");
 const { getTypeChecker, reflectPrimitiveWrappers } = utils_1.default;
-const extract_1 = require('../../utils/extract');
-const parent_1 = require('../../utils/parent');
-const pick_1 = require('../../utils/pick');
-const exceptionConstructor_1 = require('../errors/exceptionConstructor');
-const InstanceCreator_1 = require('./InstanceCreator');
+const extract_1 = require("../../utils/extract");
+const parent_1 = require("../../utils/parent");
+const pick_1 = require("../../utils/pick");
+const exceptionConstructor_1 = require("../errors/exceptionConstructor");
+const InstanceCreator_1 = require("./InstanceCreator");
 const Gaia = function (Uranus) {
-	const gaiaProto = Uranus ? Uranus : this;
-	const GaiaConstructor = function () { };
-	GaiaConstructor.prototype = Object.create(gaiaProto);
-	const gaia = new GaiaConstructor;
-	odp(gaia, MNEMONICA, {
-		get () {
-			return !Uranus ? GAIA : URANUS;
-		}
-	});
-	return gaia;
+    const gaiaProto = Uranus ? Uranus : this;
+    const GaiaConstructor = function () { };
+    GaiaConstructor.prototype = Object.create(gaiaProto);
+    const gaia = new GaiaConstructor;
+    odp(gaia, MNEMONICA, {
+        get() {
+            return !Uranus ? GAIA : URANUS;
+        }
+    });
+    return gaia;
 };
 const MnemonicaProtoProps = {
-	extract () {
-		return function () {
-			return extract_1.extract(this);
-		};
-	},
-	pick () {
-		return function (...args) {
-			return pick_1.pick(this, ...args);
-		};
-	},
-	parent () {
-		return function (constructorLookupPath) {
-			return parent_1.parent(this, constructorLookupPath);
-		};
-	},
-	clone () {
-		return this.fork();
-	},
-	fork () {
-		const { __type__: type, __collection__: collection, __parent__: existentInstance, __args__, __self__ } = this;
-		const { isSubType, TypeName } = type;
-		return function (...forkArgs) {
-			let forked;
-			const Constructor = isSubType ?
-				existentInstance :
-				collection;
-			const args = forkArgs.length ? forkArgs : __args__;
-			if (this === __self__) {
-				forked = new (Constructor[TypeName])(...args);
-			}
-			else {
-				forked = new InstanceCreator_1.InstanceCreator(type, reflectPrimitiveWrappers(this), args);
-			}
-			return forked;
-		};
-	},
-	[SymbolReplaceGaia] () {
-		return function (uranus) {
-			Reflect.setPrototypeOf(Reflect.getPrototypeOf(this[SymbolGaia]), uranus);
-		};
-	},
-	[SymbolConstructorName] () {
-		return MNEMONICA;
-	},
-	exception () {
-		const me = this;
-		return function (error, ...args) {
-			const target = new.target;
-			return exceptionConstructor_1.default.call(me, target, error, ...args);
-		};
-	}
+    extract() {
+        return function () {
+            return (0, extract_1.extract)(this);
+        };
+    },
+    pick() {
+        return function (...args) {
+            return (0, pick_1.pick)(this, ...args);
+        };
+    },
+    parent() {
+        return function (constructorLookupPath) {
+            return (0, parent_1.parent)(this, constructorLookupPath);
+        };
+    },
+    clone() {
+        return this.fork();
+    },
+    fork() {
+        const { __type__: type, __collection__: collection, __parent__: existentInstance, __args__, __self__ } = this;
+        const { isSubType, TypeName } = type;
+        return function (...forkArgs) {
+            let forked;
+            const Constructor = isSubType ?
+                existentInstance :
+                collection;
+            const args = forkArgs.length ? forkArgs : __args__;
+            if (this === __self__) {
+                forked = new (Constructor[TypeName])(...args);
+            }
+            else {
+                forked = new InstanceCreator_1.InstanceCreator(type, reflectPrimitiveWrappers(this), args);
+            }
+            return forked;
+        };
+    },
+    [SymbolReplaceGaia]() {
+        return function (uranus) {
+            Reflect.setPrototypeOf(Reflect.getPrototypeOf(this[SymbolGaia]), uranus);
+        };
+    },
+    [SymbolConstructorName]() {
+        return MNEMONICA;
+    },
+    exception() {
+        const self = this;
+        return function (error, ...args) {
+            const target = new.target;
+            return exceptionConstructor_1.default.call(self, target, error, ...args);
+        };
+    },
+    sibling() {
+        const self = this;
+        const siblings = (SiblingTypeName) => {
+            const { __collection__: collection, } = self;
+            const sibling = collection[SiblingTypeName];
+            return sibling;
+        };
+        return new Proxy(siblings, {
+            get(_, prop) {
+                return siblings(prop);
+            },
+            apply(_, __, args) {
+                return siblings(args[0]);
+            }
+        });
+    }
 };
 const Mnemosyne = function (namespace, gaia) {
-	const Mnemonica = function () {
-		odp(this, SymbolConstructorName, {
-			get () {
-				return namespace.name;
-			}
-		});
-	};
-	const mnemonica = Reflect.getPrototypeOf(gaia);
-	Reflect.setPrototypeOf(Mnemonica.prototype, mnemonica);
-	Mnemonica.prototype.constructor = Mnemonica;
-	Object.entries(MnemonicaProtoProps).forEach(([name, method]) => {
-		odp(Mnemonica.prototype, name, {
-			get () {
-				return method.call(this);
-			}
-		});
-	});
-	Object.getOwnPropertySymbols(MnemonicaProtoProps).forEach((symbol) => {
-		odp(Mnemonica.prototype, symbol, {
-			get () {
-				const symbolMethod = Reflect.get(MnemonicaProtoProps, symbol);
-				return symbolMethod.call(this);
-			}
-		});
-	});
-	odp(Mnemonica.prototype, Symbol.hasInstance, {
-		get () {
-			return getTypeChecker(this.constructor.name);
-		}
-	});
-	odp(Mnemonica.prototype, SymbolGaia, {
-		get () {
-			return gaia;
-		}
-	});
-	const proto = new Mnemonica();
-	Reflect.setPrototypeOf(this, proto);
+    const Mnemonica = function () {
+        odp(this, SymbolConstructorName, {
+            get() {
+                return namespace.name;
+            }
+        });
+    };
+    const mnemonica = Reflect.getPrototypeOf(gaia);
+    Reflect.setPrototypeOf(Mnemonica.prototype, mnemonica);
+    Mnemonica.prototype.constructor = Mnemonica;
+    Object.entries(MnemonicaProtoProps).forEach(([name, method]) => {
+        odp(Mnemonica.prototype, name, {
+            get() {
+                return method.call(this);
+            }
+        });
+    });
+    Object.getOwnPropertySymbols(MnemonicaProtoProps).forEach((symbol) => {
+        odp(Mnemonica.prototype, symbol, {
+            get() {
+                const symbolMethod = Reflect.get(MnemonicaProtoProps, symbol);
+                return symbolMethod.call(this);
+            }
+        });
+    });
+    odp(Mnemonica.prototype, Symbol.hasInstance, {
+        get() {
+            return getTypeChecker(this.constructor.name);
+        }
+    });
+    odp(Mnemonica.prototype, SymbolGaia, {
+        get() {
+            return gaia;
+        }
+    });
+    const proto = new Mnemonica();
+    Reflect.setPrototypeOf(this, proto);
 };
 exports.default = {
-	Gaia,
-	Mnemosyne,
-	get MnemosynePrototypeKeys () {
-		return Object.keys(MnemonicaProtoProps);
-	}
+    Gaia,
+    Mnemosyne,
+    get MnemosynePrototypeKeys() {
+        return Object.keys(MnemonicaProtoProps);
+    }
 };

package/build/api/types/TypeProxy.js

@@ -1,156 +1,156 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeProxy = void 0;
-const constants_1 = require('../../constants');
+const constants_1 = require("../../constants");
 const { SymbolGaia, } = constants_1.constants;
-const hop_1 = require('../../utils/hop');
-const errors_1 = require('../../descriptors/errors');
+const hop_1 = require("../../utils/hop");
+const errors_1 = require("../../descriptors/errors");
 const { WRONG_TYPE_DEFINITION, } = errors_1.ErrorsTypes;
-const utils_1 = require('../utils');
+const utils_1 = require("../utils");
 const { checkProto, getTypeChecker, findParentSubType, reflectPrimitiveWrappers, } = utils_1.default;
-const Mnemosyne_1 = require('./Mnemosyne');
+const Mnemosyne_1 = require("./Mnemosyne");
 const { Gaia, Mnemosyne, MnemosynePrototypeKeys } = Mnemosyne_1.default;
-const InstanceCreator_1 = require('./InstanceCreator');
+const InstanceCreator_1 = require("./InstanceCreator");
 exports.TypeProxy = function (__type__, Uranus) {
-	Object.assign(this, {
-		__type__,
-		Uranus
-	});
-	const typeProxy = new Proxy(InstanceCreator_1.InstanceCreator, this);
-	return typeProxy;
+    Object.assign(this, {
+        __type__,
+        Uranus
+    });
+    const typeProxy = new Proxy(InstanceCreator_1.InstanceCreator, this);
+    return typeProxy;
 };
 exports.TypeProxy.prototype.get = function (target, prop) {
-	const { __type__: type } = this;
-	if (prop === 'prototype') {
-		return type.proto;
-	}
-	const propDeclaration = type[prop];
-	if (propDeclaration) {
-		return propDeclaration;
-	}
-	if (hop_1.hop(type, prop)) {
-		return propDeclaration;
-	}
-	if (type.subtypes.has(prop)) {
-		return type.subtypes.get(prop);
-	}
-	return Reflect.get(target, prop);
+    const { __type__: type } = this;
+    if (prop === 'prototype') {
+        return type.proto;
+    }
+    const propDeclaration = type[prop];
+    if (propDeclaration) {
+        return propDeclaration;
+    }
+    if ((0, hop_1.hop)(type, prop)) {
+        return propDeclaration;
+    }
+    if (type.subtypes.has(prop)) {
+        return type.subtypes.get(prop);
+    }
+    return Reflect.get(target, prop);
 };
 exports.TypeProxy.prototype.set = function (__, name, value) {
-	const { __type__: type } = this;
-	if (name === 'prototype') {
-		checkProto(value);
-		type.proto = value;
-		return true;
-	}
-	if (typeof name !== 'string' || !name.length) {
-		throw new WRONG_TYPE_DEFINITION('should use non empty string as TypeName');
-	}
-	if (typeof value !== 'function') {
-		throw new WRONG_TYPE_DEFINITION('should use function for type definition');
-	}
-	const TypeName = name;
-	const Constructor = value;
-	type.define(TypeName, Constructor);
-	return true;
+    const { __type__: type } = this;
+    if (name === 'prototype') {
+        checkProto(value);
+        type.proto = value;
+        return true;
+    }
+    if (typeof name !== 'string' || !name.length) {
+        throw new WRONG_TYPE_DEFINITION('should use non empty string as TypeName');
+    }
+    if (typeof value !== 'function') {
+        throw new WRONG_TYPE_DEFINITION('should use function for type definition');
+    }
+    const TypeName = name;
+    const Constructor = value;
+    type.define(TypeName, Constructor);
+    return true;
 };
 exports.TypeProxy.prototype.apply = function (__, Uranus, args) {
-	const type = this.__type__;
-	let instance = null;
-	if (Uranus) {
-		const InstanceCreatorProxy = new exports.TypeProxy(type, Uranus);
-		instance = new InstanceCreatorProxy(...args);
-	}
-	else {
-		instance = this.construct(null, args);
-	}
-	return instance;
+    const type = this.__type__;
+    let instance = null;
+    if (Uranus) {
+        const InstanceCreatorProxy = new exports.TypeProxy(type, Uranus);
+        instance = new InstanceCreatorProxy(...args);
+    }
+    else {
+        instance = this.construct(null, args);
+    }
+    return instance;
 };
 const makeSubTypeProxy = function (subtype, inheritedInstance) {
-	const subtypeProxy = new Proxy(InstanceCreator_1.InstanceCreator, {
-		get (Target, _prop) {
-			if (_prop === Symbol.hasInstance) {
-				return getTypeChecker(subtype.TypeName);
-			}
-			return Reflect.get(Target, _prop);
-		},
-		construct (Target, _args) {
-			return new Target(subtype, inheritedInstance, _args);
-		},
-		apply (Target, thisArg = inheritedInstance, _args) {
-			let existentInstance = reflectPrimitiveWrappers(thisArg);
-			if (!existentInstance[SymbolGaia]) {
-				const gaia = new Mnemosyne(subtype.namespace, new Gaia(existentInstance));
-				existentInstance = new Proxy(gaia, {
-					get : gaiaProxyHandlerGet
-				});
-			}
-			const entity = new Target(subtype, existentInstance, _args);
-			return entity;
-		},
-	});
-	return subtypeProxy;
+    const subtypeProxy = new Proxy(InstanceCreator_1.InstanceCreator, {
+        get(Target, _prop) {
+            if (_prop === Symbol.hasInstance) {
+                return getTypeChecker(subtype.TypeName);
+            }
+            return Reflect.get(Target, _prop);
+        },
+        construct(Target, _args) {
+            return new Target(subtype, inheritedInstance, _args);
+        },
+        apply(Target, thisArg = inheritedInstance, _args) {
+            let existentInstance = reflectPrimitiveWrappers(thisArg);
+            if (!existentInstance[SymbolGaia]) {
+                const gaia = new Mnemosyne(subtype.namespace, new Gaia(existentInstance));
+                existentInstance = new Proxy(gaia, {
+                    get: gaiaProxyHandlerGet
+                });
+            }
+            const entity = new Target(subtype, existentInstance, _args);
+            return entity;
+        },
+    });
+    return subtypeProxy;
 };
 const MnemonicaInstanceProps = [
-	'__proto_proto__',
-	'__type__',
-	'__self__',
-	'__args__',
-	'__parent__',
-	'__subtypes__',
-	'__stack__',
-	'__collection__',
-	'__namespace__',
-	'__timestamp__',
-	'__creator__'
+    '__proto_proto__',
+    '__type__',
+    '__self__',
+    '__args__',
+    '__parent__',
+    '__subtypes__',
+    '__stack__',
+    '__collection__',
+    '__namespace__',
+    '__timestamp__',
+    '__creator__'
 ].concat(MnemosynePrototypeKeys);
 const staticProps = [
-	'constructor',
-	'prototype',
-	'then',
-	'stack',
-	'message',
-	'domain',
-	'on',
-	'once',
-	'off',
-	'inspect',
-	'showDiff',
+    'constructor',
+    'prototype',
+    'then',
+    'stack',
+    'message',
+    'domain',
+    'on',
+    'once',
+    'off',
+    'inspect',
+    'showDiff',
 ]
-	.concat(MnemonicaInstanceProps)
-	.concat(Object.getOwnPropertyNames(Object.prototype))
-	.concat(Object.getOwnPropertyNames(Function.prototype))
-	.reduce((obj, key) => {
-		obj[key] = true;
-		return obj;
-	}, Object.create(null));
+    .concat(MnemonicaInstanceProps)
+    .concat(Object.getOwnPropertyNames(Object.prototype))
+    .concat(Object.getOwnPropertyNames(Function.prototype))
+    .reduce((obj, key) => {
+    obj[key] = true;
+    return obj;
+}, Object.create(null));
 const gaiaProxyHandlerGet = (target, prop, receiver) => {
-	const result = Reflect.get(target, prop, receiver);
-	if (result !== undefined) {
-		return result;
-	}
-	if (typeof prop === 'symbol') {
-		return result;
-	}
-	if (staticProps[prop]) {
-		return result;
-	}
-	const instance = Reflect.getPrototypeOf(receiver);
-	const { __type__: { config: { strictChain }, subtypes }, } = instance;
-	const subtype = subtypes.has(prop) ?
-		subtypes.get(prop) :
-		strictChain ?
-			undefined :
-			findParentSubType(instance, prop);
-	return subtype ? makeSubTypeProxy(subtype, receiver) : result;
+    const result = Reflect.get(target, prop, receiver);
+    if (result !== undefined) {
+        return result;
+    }
+    if (typeof prop === 'symbol') {
+        return result;
+    }
+    if (staticProps[prop]) {
+        return result;
+    }
+    const instance = Reflect.getPrototypeOf(receiver);
+    const { __type__: { config: { strictChain }, subtypes }, } = instance;
+    const subtype = subtypes.has(prop) ?
+        subtypes.get(prop) :
+        strictChain ?
+            undefined :
+            findParentSubType(instance, prop);
+    return subtype ? makeSubTypeProxy(subtype, receiver) : result;
 };
 exports.TypeProxy.prototype.construct = function (__, args) {
-	const { __type__: type, Uranus } = this;
-	const uranus = reflectPrimitiveWrappers(Uranus);
-	const gaia = new Mnemosyne(type.namespace, new Gaia(uranus));
-	const gaiaProxy = new Proxy(gaia, {
-		get : gaiaProxyHandlerGet
-	});
-	const instance = new InstanceCreator_1.InstanceCreator(type, gaiaProxy, args);
-	return instance;
+    const { __type__: type, Uranus } = this;
+    const uranus = reflectPrimitiveWrappers(Uranus);
+    const gaia = new Mnemosyne(type.namespace, new Gaia(uranus));
+    const gaiaProxy = new Proxy(gaia, {
+        get: gaiaProxyHandlerGet
+    });
+    const instance = new InstanceCreator_1.InstanceCreator(type, gaiaProxy, args);
+    return instance;
 };

package/build/api/types/addProps.d.ts

@@ -0,0 +1 @@
+export declare const addProps: (this: any) => any;

package/build/api/types/addProps.js

@@ -0,0 +1,68 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProps = void 0;
+const constants_1 = require("../../constants");
+const { odp, } = constants_1.constants;
+const addProps = function () {
+    const self = this;
+    const { type, existentInstance, args, config: { submitStack }, __proto_proto__: proto } = self;
+    const { namespace, collection, subtypes, } = type;
+    odp(proto, '__proto_proto__', {
+        get() {
+            return proto;
+        }
+    });
+    odp(proto, '__args__', {
+        get() {
+            return args;
+        }
+    });
+    odp(proto, '__collection__', {
+        get() {
+            return collection;
+        }
+    });
+    odp(proto, '__namespace__', {
+        get() {
+            return namespace;
+        }
+    });
+    odp(proto, '__subtypes__', {
+        get() {
+            return subtypes;
+        }
+    });
+    odp(proto, '__type__', {
+        get() {
+            return type;
+        }
+    });
+    odp(proto, '__parent__', {
+        get() {
+            return existentInstance;
+        }
+    });
+    if (submitStack) {
+        const { stack } = this;
+        odp(proto, '__stack__', {
+            get() {
+                return stack.join('\n');
+            }
+        });
+    }
+    odp(proto, '__creator__', {
+        get() {
+            return self;
+        }
+    });
+    const timestamp = Date.now();
+    odp(proto, '__timestamp__', {
+        get() {
+            return timestamp;
+        }
+    });
+};
+exports.addProps = addProps;
+module.exports = {
+    addProps: exports.addProps
+};

package/build/api/types/compileNewModificatorFunctionBody.d.ts

@@ -1,2 +1,2 @@
-declare const compileNewModificatorFunctionBody: (FunctionName: string, asClass?: boolean) => Function;
+declare const compileNewModificatorFunctionBody: (FunctionName: string, asClass?: boolean) => (ConstructHandler: any, CreationHandler: any, SymbolConstructorName: symbol) => any;
 export default compileNewModificatorFunctionBody;