mnemonica 0.9.93 → 0.9.98

package/build/api/types/compileNewModificatorFunctionBody.js

@@ -1,31 +1,41 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
+const getClassConstructor = (ConstructHandler, CreationHandler) => {
+    return class extends ConstructHandler {
+        constructor(...args) {
+            const answer = super(...args);
+            return CreationHandler.call(this, answer);
+        }
+    };
+};
+const getFunctionConstructor = (ConstructHandler, CreationHandler) => {
+    return function (...args) {
+        const answer = ConstructHandler.call(this, ...args);
+        return CreationHandler.call(this, answer);
+    };
+};
 const compileNewModificatorFunctionBody = function (FunctionName, asClass = false) {
-	const modString = asClass ?
-		`class ${FunctionName} extends ConstructHandler {
-			constructor(...args) {
-				const answer = super(...args);
-				return CreationHandler.call(this, answer);
-			}
-		}`
-		:
-		`const ${FunctionName} = function (...args) {
-			const answer = ConstructHandler.call(this, ...args);
-			return CreationHandler.call(this, answer);
-		};`;
-	return new Function('ConstructHandler', 'CreationHandler', 'SymbolConstructorName', `return function () {
-
-			${modString}
-
-			Object.defineProperty(${FunctionName}, SymbolConstructorName, {
-				get () {
-					return '${FunctionName}';
-				}
-			});
-
-			return ${FunctionName};
-
-		};
-	`);
+    return function (ConstructHandler, CreationHandler, SymbolConstructorName) {
+        return function () {
+            let ModificationBody;
+            if (asClass) {
+                ModificationBody = getClassConstructor(ConstructHandler, CreationHandler);
+            }
+            else {
+                ModificationBody = getFunctionConstructor(ConstructHandler, CreationHandler);
+            }
+            ModificationBody.prototype.constructor = ModificationBody;
+            Object.defineProperty(ModificationBody.prototype.constructor, 'name', {
+                value: FunctionName,
+                writable: false
+            });
+            Object.defineProperty(ModificationBody, SymbolConstructorName, {
+                get() {
+                    return FunctionName;
+                }
+            });
+            return ModificationBody;
+        };
+    };
 };
 exports.default = compileNewModificatorFunctionBody;

package/build/api/types/createInstanceModificator.js

@@ -1,27 +1,29 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
-function default_1 () {
-	const CreateInstanceModificator = function (ModificatorType, ModificatorTypePrototype, addProps) {
-		const existentInstance = this;
-		const Mnemosyne = Object.create(existentInstance);
-		addProps(Mnemosyne);
-		Object.defineProperty(Mnemosyne, 'constructor', {
-			get () {
-				return ModificatorType;
-			},
-			enumerable : false
-		});
-		Object.entries(ModificatorTypePrototype).forEach((entry) => {
-			const [name, value] = entry;
-			if (name !== 'constructor') {
-				(ModificatorType.prototype[name] = value);
-			}
-		});
-		ModificatorType.prototype.constructor = ModificatorType;
-		Reflect.setPrototypeOf(ModificatorType.prototype, Mnemosyne);
-		return ModificatorType;
-	};
-	return CreateInstanceModificator;
+Object.defineProperty(exports, "__esModule", { value: true });
+const obeyConstructor_1 = require("./obeyConstructor");
+function default_1() {
+    const CreateInstanceModificator = function (ModificatorType, ModificatorTypePrototype, addProps) {
+        const existentInstance = this;
+        const Mnemosyne = {};
+        Reflect.setPrototypeOf(Mnemosyne, existentInstance);
+        addProps(Mnemosyne);
+        Object.defineProperty(Mnemosyne, 'constructor', {
+            get() {
+                return ModificatorType;
+            },
+            enumerable: false
+        });
+        Object.entries(ModificatorTypePrototype).forEach((entry) => {
+            const [name, value] = entry;
+            if (name !== 'constructor') {
+                (ModificatorType.prototype[name] = value);
+            }
+        });
+        ModificatorType.prototype.constructor = ModificatorType;
+        Reflect.setPrototypeOf(ModificatorType.prototype, Mnemosyne);
+        (0, obeyConstructor_1.obey)(existentInstance, ModificatorType);
+        return ModificatorType;
+    };
+    return CreateInstanceModificator;
 }
 exports.default = default_1;
-

package/build/api/types/createInstanceModificator200XthWay.js

@@ -1,31 +1,32 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
-function default_1 () {
-	const CreateInstanceModificatorAncient200XthWay = function (ModificatorType, ModificatorTypePrototype, addProps) {
-		const existentInstance = this;
-		const TripleSchemeClosure = function () {
-			const Mnemosyne = this;
-			addProps(Mnemosyne);
-			const Inherico = function () {
-				const moreInherited = this;
-				ModificatorType.prototype = moreInherited;
-				Object.assign(ModificatorType.prototype, ModificatorTypePrototype);
-				Object.defineProperty(ModificatorType.prototype, 'constructor', {
-					get () {
-						return ModificatorType;
-					},
-					enumerable : false
-				});
-				return ModificatorType;
-			};
-			Inherico.prototype = Mnemosyne;
-			Inherico.prototype.constructor = ModificatorType;
-			return new Inherico();
-		};
-		TripleSchemeClosure.prototype = existentInstance;
-		return new TripleSchemeClosure();
-	};
-	return CreateInstanceModificatorAncient200XthWay;
+Object.defineProperty(exports, "__esModule", { value: true });
+const obeyConstructor_1 = require("./obeyConstructor");
+function default_1() {
+    const CreateInstanceModificatorAncient200XthWay = function (ModificatorType, ModificatorTypePrototype, addProps) {
+        const existentInstance = this;
+        const TripleSchemeClosure = function () {
+            const Mnemosyne = this;
+            addProps(Mnemosyne);
+            const Inherico = function () {
+                const moreInherited = this;
+                ModificatorType.prototype = moreInherited;
+                Object.assign(ModificatorType.prototype, ModificatorTypePrototype);
+                Object.defineProperty(ModificatorType.prototype, 'constructor', {
+                    get() {
+                        return ModificatorType;
+                    },
+                    enumerable: false
+                });
+                (0, obeyConstructor_1.obey)(existentInstance, ModificatorType);
+                return ModificatorType;
+            };
+            Inherico.prototype = Mnemosyne;
+            Inherico.prototype.constructor = ModificatorType;
+            return new Inherico();
+        };
+        TripleSchemeClosure.prototype = existentInstance;
+        return new TripleSchemeClosure();
+    };
+    return CreateInstanceModificatorAncient200XthWay;
 }
 exports.default = default_1;
-

package/build/api/types/index.js

@@ -1,181 +1,183 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.lookup = exports.define = void 0;
-const hop_1 = require('../../utils/hop');
-const constants_1 = require('../../constants');
+const hop_1 = require("../../utils/hop");
+const constants_1 = require("../../constants");
 const { odp, SymbolSubtypeCollection, SymbolConstructorName, SymbolConfig, TYPE_TITLE_PREFIX, MNEMOSYNE, } = constants_1.constants;
-const errors_1 = require('../../descriptors/errors');
+const errors_1 = require("../../descriptors/errors");
 const { ALREADY_DECLARED, WRONG_TYPE_DEFINITION, TYPENAME_MUST_BE_A_STRING, HANDLER_MUST_BE_A_FUNCTION, } = errors_1.ErrorsTypes;
-const hooksApi = require('../hooks');
-const TypeProxy_1 = require('./TypeProxy');
-const compileNewModificatorFunctionBody_1 = require('./compileNewModificatorFunctionBody');
-const utils_1 = require('../utils');
+const hooksApi = require("../hooks");
+const TypeProxy_1 = require("./TypeProxy");
+const compileNewModificatorFunctionBody_1 = require("./compileNewModificatorFunctionBody");
+const utils_1 = require("../utils");
 const { checkProto, getTypeChecker, CreationHandler, getTypeSplitPath, checkTypeName, isClass, } = utils_1.default;
-const errors_2 = require('../errors');
+const errors_2 = require("../errors");
 const TypeDescriptor = function (defineOrigin, types, TypeName, constructHandler, proto, config) {
-	const parentType = types[SymbolSubtypeCollection] || null;
-	const isSubType = parentType ? true : false;
-	const namespace = isSubType ? parentType.namespace : types.namespace;
-	const collection = isSubType ? parentType.collection : types[MNEMOSYNE];
-	if (types.has(TypeName)) {
-		throw new ALREADY_DECLARED;
-	}
-	checkProto(proto);
-	const subtypes = new Map();
-	const title = `${TYPE_TITLE_PREFIX}${TypeName}`;
-	config = Object.assign({}, collection[SymbolConfig], config);
-	const type = Object.assign(this, {
-		get constructHandler () {
-			return constructHandler;
-		},
-		TypeName,
-		proto,
-		isSubType,
-		subtypes,
-		parentType,
-		namespace,
-		collection,
-		title,
-		config,
-		hooks : Object.create(null)
-	});
-	errors_2.getStack.call(this, `Definition of [ ${TypeName} ] made at:`, [], defineOrigin);
-	odp(subtypes, SymbolSubtypeCollection, {
-		get () {
-			return type;
-		}
-	});
-	types.set(TypeName, new TypeProxy_1.TypeProxy(type));
-	return types.get(TypeName);
+    const parentType = types[SymbolSubtypeCollection] || null;
+    const isSubType = parentType ? true : false;
+    const namespace = isSubType ? parentType.namespace : types.namespace;
+    const collection = isSubType ? parentType.collection : types[MNEMOSYNE];
+    if (types.has(TypeName)) {
+        throw new ALREADY_DECLARED;
+    }
+    checkProto(proto);
+    const subtypes = new Map();
+    const title = `${TYPE_TITLE_PREFIX}${TypeName}`;
+    config = Object.assign({}, collection[SymbolConfig], config);
+    const type = Object.assign(this, {
+        get constructHandler() {
+            return constructHandler;
+        },
+        TypeName,
+        proto,
+        isSubType,
+        subtypes,
+        parentType,
+        namespace,
+        collection,
+        title,
+        config,
+        hooks: Object.create(null)
+    });
+    errors_2.getStack.call(this, `Definition of [ ${TypeName} ] made at:`, [], defineOrigin);
+    odp(subtypes, SymbolSubtypeCollection, {
+        get() {
+            return type;
+        }
+    });
+    types.set(TypeName, new TypeProxy_1.TypeProxy(type));
+    return types.get(TypeName);
 };
 Object.assign(TypeDescriptor.prototype, hooksApi);
 TypeDescriptor.prototype.define = function (...args) {
-	return exports.define.call(exports.define, this.subtypes, ...args);
+    return exports.define.call(exports.define, this.subtypes, ...args);
 };
 TypeDescriptor.prototype.lookup = function (...args) {
-	return exports.lookup.call(this.subtypes, ...args);
+    return exports.lookup.call(this.subtypes, ...args);
 };
 odp(TypeDescriptor.prototype, Symbol.hasInstance, {
-	get () {
-		return getTypeChecker(this.TypeName);
-	}
+    get() {
+        return getTypeChecker(this.TypeName);
+    }
 });
 const defineFromType = function (subtypes, constructHandlerGetter, config) {
-	const type = constructHandlerGetter();
-	if (typeof type !== 'function') {
-		throw new HANDLER_MUST_BE_A_FUNCTION;
-	}
-	const TypeName = type.name;
-	if (!TypeName) {
-		throw new TYPENAME_MUST_BE_A_STRING;
-	}
-	const asClass = isClass(type);
-	const makeConstructHandler = () => {
-		const constructHandler = constructHandlerGetter();
-		odp(constructHandler, SymbolConstructorName, {
-			get () {
-				return TypeName;
-			}
-		});
-		const protoDesc = Object
-			.getOwnPropertyDescriptor(constructHandler, 'prototype');
-		if (protoDesc.writable) {
-			constructHandler.prototype = {};
-		}
-		return constructHandler;
-	};
-	if (typeof config === 'object') {
-		config = Object.assign({}, config);
-		config.useOldStyle = false;
-	}
-	else {
-		config = {};
-	}
-	config.asClass = asClass;
-	return new TypeDescriptor(this, subtypes, TypeName, makeConstructHandler, type.prototype, config);
+    const type = constructHandlerGetter();
+    if (typeof type !== 'function') {
+        throw new HANDLER_MUST_BE_A_FUNCTION;
+    }
+    const TypeName = type.name;
+    if (!TypeName) {
+        throw new TYPENAME_MUST_BE_A_STRING;
+    }
+    const asClass = isClass(type);
+    const makeConstructHandler = () => {
+        const constructHandler = constructHandlerGetter();
+        odp(constructHandler, SymbolConstructorName, {
+            get() {
+                return TypeName;
+            }
+        });
+        const protoDesc = Object
+            .getOwnPropertyDescriptor(constructHandler, 'prototype');
+        if (protoDesc.writable) {
+            constructHandler.prototype = {};
+        }
+        return constructHandler;
+    };
+    if (typeof config === 'object') {
+        config = Object.assign({}, config);
+        config.useOldStyle = false;
+    }
+    else {
+        config = {};
+    }
+    config.asClass = asClass;
+    return new TypeDescriptor(this, subtypes, TypeName, makeConstructHandler, type.prototype, config);
 };
 const extractNonEnumerableProps = (_obj) => {
-	const extracted = Object.entries(Object.getOwnPropertyDescriptors(_obj)).reduce((obj, entry) => {
-		const [name, { value }] = entry;
-		odp(obj, name, {
-			value,
-			configurable : true,
-			enumerable   : true,
-			writable     : true,
-		});
-		return obj;
-	}, {});
-	return extracted;
+    const extracted = Object.entries(Object.getOwnPropertyDescriptors(_obj)).reduce((obj, entry) => {
+        const [name, { value }] = entry;
+        odp(obj, name, {
+            value,
+            configurable: true,
+            enumerable: true,
+            writable: true,
+        });
+        return obj;
+    }, {});
+    return extracted;
 };
 const defineFromFunction = function (subtypes, TypeName, constructHandler = function () { }, proto, config = {}) {
-	if (typeof constructHandler !== 'function') {
-		throw new HANDLER_MUST_BE_A_FUNCTION;
-	}
-	const asClass = isClass(constructHandler);
-	const modificatorBody = compileNewModificatorFunctionBody_1.default(TypeName, asClass);
-	const makeConstructHandler = modificatorBody(constructHandler, CreationHandler, SymbolConstructorName);
-	if (!proto) {
-		if (hop_1.hop(constructHandler, 'prototype')) {
-			proto = Object.assign({}, constructHandler.prototype);
-		}
-		else {
-			proto = {};
-		}
-	}
-	if (asClass) {
-		proto = extractNonEnumerableProps(proto);
-	}
-	if (typeof config === 'object') {
-		config = Object.assign({}, config);
-	}
-	if (typeof config === 'boolean') {
-		config = {
-			useOldStyle : config
-		};
-	}
-	config.asClass = asClass;
-	return new TypeDescriptor(this, subtypes, TypeName, makeConstructHandler, proto, config);
+    if (typeof constructHandler !== 'function') {
+        throw new HANDLER_MUST_BE_A_FUNCTION;
+    }
+    const asClass = isClass(constructHandler);
+    const modificatorBody = (0, compileNewModificatorFunctionBody_1.default)(TypeName, asClass);
+    const makeConstructHandler = modificatorBody(constructHandler, CreationHandler, SymbolConstructorName);
+    if (!proto) {
+        if ((0, hop_1.hop)(constructHandler, 'prototype')) {
+            proto = Object.assign({}, constructHandler.prototype);
+        }
+        else {
+            proto = {};
+        }
+    }
+    if (asClass) {
+        proto = extractNonEnumerableProps(proto);
+    }
+    if (typeof config === 'object') {
+        config = Object.assign({}, config);
+    }
+    if (typeof config === 'boolean') {
+        config = {
+            useOldStyle: config
+        };
+    }
+    config.asClass = asClass;
+    return new TypeDescriptor(this, subtypes, TypeName, makeConstructHandler, proto, config);
 };
-exports.define = function (subtypes, TypeOrTypeName, constructHandlerOrConfig, proto, config) {
-	if (typeof TypeOrTypeName === 'function') {
-		if (TypeOrTypeName.name) {
-			return exports.define.call(this, subtypes, TypeOrTypeName.name, TypeOrTypeName, constructHandlerOrConfig || TypeOrTypeName.prototype, config);
-		}
-		else {
-			return defineFromType.call(this, subtypes, TypeOrTypeName, constructHandlerOrConfig);
-		}
-	}
-	if (typeof TypeOrTypeName === 'string') {
-		checkTypeName(TypeOrTypeName);
-		const split = getTypeSplitPath(TypeOrTypeName);
-		const Type = exports.lookup.call(subtypes, split[0]);
-		if (!Type) {
-			if (split.length === 1) {
-				return defineFromFunction.call(this, subtypes, TypeOrTypeName, constructHandlerOrConfig, proto, config);
-			}
-			throw new WRONG_TYPE_DEFINITION(`${split[0]} definition is not yet exists`);
-		}
-		const TypeName = split.slice(1).join('.');
-		if (split.length > 1) {
-			return exports.define.call(this, Type.subtypes, TypeName, constructHandlerOrConfig, proto, config);
-		}
-		return exports.define.call(this, Type.subtypes, constructHandlerOrConfig, proto, config);
-	}
-	throw new WRONG_TYPE_DEFINITION('definition is not provided');
+const define = function (subtypes, TypeOrTypeName, constructHandlerOrConfig, proto, config) {
+    if (typeof TypeOrTypeName === 'function') {
+        if (TypeOrTypeName.name) {
+            return exports.define.call(this, subtypes, TypeOrTypeName.name, TypeOrTypeName, constructHandlerOrConfig || TypeOrTypeName.prototype, config);
+        }
+        else {
+            return defineFromType.call(this, subtypes, TypeOrTypeName, constructHandlerOrConfig);
+        }
+    }
+    if (typeof TypeOrTypeName === 'string') {
+        checkTypeName(TypeOrTypeName);
+        const split = getTypeSplitPath(TypeOrTypeName);
+        const Type = exports.lookup.call(subtypes, split[0]);
+        if (!Type) {
+            if (split.length === 1) {
+                return defineFromFunction.call(this, subtypes, TypeOrTypeName, constructHandlerOrConfig, proto, config);
+            }
+            throw new WRONG_TYPE_DEFINITION(`${split[0]} definition is not yet exists`);
+        }
+        const TypeName = split.slice(1).join('.');
+        if (split.length > 1) {
+            return exports.define.call(this, Type.subtypes, TypeName, constructHandlerOrConfig, proto, config);
+        }
+        return exports.define.call(this, Type.subtypes, constructHandlerOrConfig, proto, config);
+    }
+    throw new WRONG_TYPE_DEFINITION('definition is not provided');
 };
-exports.lookup = function (TypeNestedPath) {
-	if (typeof TypeNestedPath !== 'string') {
-		throw new WRONG_TYPE_DEFINITION('arg : type nested path must be a string');
-	}
-	if (!TypeNestedPath.length) {
-		throw new WRONG_TYPE_DEFINITION('arg : type nested path has no path');
-	}
-	const split = getTypeSplitPath(TypeNestedPath);
-	const [name] = split;
-	const type = this.get(name);
-	if (split.length === 1) {
-		return type;
-	}
-	const NextNestedPath = split.slice(1).join('.');
-	return exports.lookup.call(type.subtypes, NextNestedPath);
+exports.define = define;
+const lookup = function (TypeNestedPath) {
+    if (typeof TypeNestedPath !== 'string') {
+        throw new WRONG_TYPE_DEFINITION('arg : type nested path must be a string');
+    }
+    if (!TypeNestedPath.length) {
+        throw new WRONG_TYPE_DEFINITION('arg : type nested path has no path');
+    }
+    const split = getTypeSplitPath(TypeNestedPath);
+    const [name] = split;
+    const type = this.get(name);
+    if (split.length === 1) {
+        return type;
+    }
+    const NextNestedPath = split.slice(1).join('.');
+    return exports.lookup.call(type.subtypes, NextNestedPath);
 };
+exports.lookup = lookup;

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

@@ -0,0 +1 @@
+export declare const obey: (existentInstance: any, ModificatorType: any) => void;

package/build/api/types/obeyConstructor.js

@@ -0,0 +1,30 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.obey = void 0;
+const constants_1 = require("../../constants");
+const { SymbolUsed } = constants_1.constants;
+const errors_1 = require("../../descriptors/errors");
+const { PROTOTYPE_USED_TWICE, } = errors_1.ErrorsTypes;
+const obey = (existentInstance, ModificatorType) => {
+    let protoConstructor = ModificatorType;
+    while (protoConstructor instanceof Function) {
+        if (Object.prototype.hasOwnProperty.call(protoConstructor, SymbolUsed) && protoConstructor[SymbolUsed]) {
+            const error = new PROTOTYPE_USED_TWICE(`${protoConstructor.name}.prototype > ${ModificatorType.name}`);
+            throw error;
+        }
+        const sample = Reflect.getPrototypeOf(protoConstructor);
+        if (sample instanceof Function) {
+            protoConstructor = sample;
+        }
+        else {
+            Object.defineProperty(protoConstructor, SymbolUsed, {
+                get() {
+                    return true;
+                }
+            });
+            break;
+        }
+    }
+    Reflect.setPrototypeOf(protoConstructor, existentInstance.constructor);
+};
+exports.obey = obey;

package/build/api/utils/index.d.ts

@@ -1,17 +1,29 @@
-import { TypeModificator } from '../../types';
+export type asyncStack = {
+    __stack__?: string;
+    __type__: {
+        isSubType: boolean;
+    };
+    parent: () => asyncStack;
+};
+type parentSub = {
+    __type__: {
+        subtypes: Map<string, parentSub>;
+    };
+    __parent__: parentSub;
+};
 declare const TypesUtils: {
     isClass: (fn: CallableFunction) => boolean;
-    CreationHandler: (this: any, constructionAnswer: any) => any;
+    CreationHandler: (this: unknown, constructionAnswer: unknown) => unknown;
     getModificationConstructor: (useOldStyle: boolean) => (this: any, ModificatorType: CallableFunction, ModificatorTypePrototype: {
         [index: string]: any;
     }, addProps: CallableFunction) => any;
-    checkProto: (proto: any) => void;
-    getTypeChecker: (TypeName: string) => any;
+    checkProto: (proto: unknown) => void;
+    getTypeChecker: (TypeName: string) => unknown;
     getTypeSplitPath: (path: string) => string[];
-    getExistentAsyncStack: (existentInstance: any) => any[];
+    getExistentAsyncStack: (existentInstance: asyncStack) => unknown;
     checkTypeName: (name: string) => void;
-    findParentSubType: any;
-    makeFakeModificatorType: (TypeName: string, fakeModificator?: TypeModificator<{}>) => any;
-    reflectPrimitiveWrappers: (_thisArg: any) => any;
+    findParentSubType: (instance: parentSub, prop: string) => parentSub;
+    makeFakeModificatorType: (TypeName: string, fakeModificator?: () => void) => any;
+    reflectPrimitiveWrappers: (_thisArg: unknown) => unknown;
 };
 export default TypesUtils;