mnemonica 0.9.94 → 0.9.98

package/build/api/utils/index.js

@@ -1,154 +1,154 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
-const constants_1 = require('../../constants');
-const errors_1 = require('../../descriptors/errors');
-const utils_1 = require('../../utils');
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const errors_1 = require("../../descriptors/errors");
+const utils_1 = require("../../utils");
 const { odp, SymbolConstructorName, MNEMONICA, MNEMOSYNE, GAIA, URANUS } = constants_1.constants;
 const { WRONG_TYPE_DEFINITION, } = errors_1.ErrorsTypes;
 const { collectConstructors } = utils_1.utils;
 const CreationHandler = function (constructionAnswer) {
-	if (constructionAnswer instanceof Object) {
-		return constructionAnswer;
-	}
-	return this;
+    if (constructionAnswer instanceof Object) {
+        return constructionAnswer;
+    }
+    return this;
 };
-const compileNewModificatorFunctionBody_1 = require('../types/compileNewModificatorFunctionBody');
-const createInstanceModificator200XthWay_1 = require('../types/createInstanceModificator200XthWay');
-const createInstanceModificator_1 = require('../types/createInstanceModificator');
+const compileNewModificatorFunctionBody_1 = require("../types/compileNewModificatorFunctionBody");
+const createInstanceModificator200XthWay_1 = require("../types/createInstanceModificator200XthWay");
+const createInstanceModificator_1 = require("../types/createInstanceModificator");
 const getModificationConstructor = (useOldStyle) => {
-	return (useOldStyle ? createInstanceModificator200XthWay_1.default : createInstanceModificator_1.default)();
+    return (useOldStyle ? createInstanceModificator200XthWay_1.default : createInstanceModificator_1.default)();
 };
 const checkProto = (proto) => {
-	if (!(proto instanceof Object)) {
-		throw new WRONG_TYPE_DEFINITION('expect prototype to be an object');
-	}
+    if (!(proto instanceof Object)) {
+        throw new WRONG_TYPE_DEFINITION('expect prototype to be an object');
+    }
 };
 const getTypeChecker = (TypeName) => {
-	const seeker = (instance) => {
-		if (typeof instance !== 'object') {
-			return false;
-		}
-		if (!instance.constructor) {
-			return false;
-		}
-		if (Reflect.getPrototypeOf(instance).constructor.name === 'Promise') {
-			return instance[SymbolConstructorName] === TypeName;
-		}
-		const constructors = collectConstructors(instance);
-		return constructors[TypeName] || false;
-	};
-	return seeker;
+    const seeker = (instance) => {
+        if (typeof instance !== 'object') {
+            return false;
+        }
+        if (!instance.constructor) {
+            return false;
+        }
+        if (Reflect.getPrototypeOf(instance).constructor.name === 'Promise') {
+            return instance[SymbolConstructorName] === TypeName;
+        }
+        const constructors = collectConstructors(instance);
+        return constructors[TypeName] || false;
+    };
+    return seeker;
 };
 const getTypeSplitPath = (path) => {
-	const split = path
-		.replace(/\n|\t| /g, '')
-		.replace(/\[(\w+)\]/g, '.$1')
-		.replace(/^\./, '')
-		.split(/\.|\/|:/);
-	return split;
+    const split = path
+        .replace(/\n|\t| /g, '')
+        .replace(/\[(\w+)\]/g, '.$1')
+        .replace(/^\./, '')
+        .split(/\.|\/|:/);
+    return split;
 };
 const getExistentAsyncStack = (existentInstance) => {
-	const stack = [];
-	let proto = existentInstance;
-	while (proto) {
-		if (!proto.__stack__) {
-			break;
-		}
-		const pstack = proto
-			.__stack__
-			.split('\n')
-			.reduce((arr, line) => {
-				if (line.length) {
-					arr.push(line);
-				}
-				return arr;
-			}, []);
-		proto = proto.parent();
-		if (proto && proto.__type__) {
-			if (proto.__type__.isSubType) {
-				stack.push(...pstack.slice(0, 1));
-			}
-			else {
-				stack.push(...pstack);
-			}
-		}
-		else {
-			stack.push(...pstack);
-			break;
-		}
-	}
-	return stack;
+    const stack = [];
+    let proto = existentInstance;
+    while (proto) {
+        if (!proto.__stack__) {
+            break;
+        }
+        const pstack = proto
+            .__stack__
+            .split('\n')
+            .reduce((arr, line) => {
+            if (line.length) {
+                arr.push(line);
+            }
+            return arr;
+        }, []);
+        proto = proto.parent();
+        if (proto && proto.__type__) {
+            if (proto.__type__.isSubType) {
+                stack.push(...pstack.slice(0, 1));
+            }
+            else {
+                stack.push(...pstack);
+            }
+        }
+        else {
+            stack.push(...pstack);
+            break;
+        }
+    }
+    return stack;
 };
 const forbiddenNames = [MNEMONICA, MNEMOSYNE, GAIA, URANUS];
 const checkTypeName = (name) => {
-	if (!name.length) {
-		throw new WRONG_TYPE_DEFINITION('TypeName must not be empty');
-	}
-	if (name[0] !== name[0].toUpperCase()) {
-		throw new WRONG_TYPE_DEFINITION('TypeName should start with Uppercase Letter');
-	}
-	if (forbiddenNames.includes(name)) {
-		throw new WRONG_TYPE_DEFINITION('TypeName of reserved keyword');
-	}
+    if (!name.length) {
+        throw new WRONG_TYPE_DEFINITION('TypeName must not be empty');
+    }
+    if (name[0] !== name[0].toUpperCase()) {
+        throw new WRONG_TYPE_DEFINITION('TypeName should start with Uppercase Letter');
+    }
+    if (forbiddenNames.includes(name)) {
+        throw new WRONG_TYPE_DEFINITION('TypeName of reserved keyword');
+    }
 };
 const findParentSubType = (instance, prop) => {
-	let subtype = null;
-	if (instance.__type__.subtypes.has(prop)) {
-		subtype = instance.__type__.subtypes.get(prop);
-		return subtype;
-	}
-	return findParentSubType(instance.__parent__, prop);
+    let subtype = null;
+    if (instance.__type__.subtypes.has(prop)) {
+        subtype = instance.__type__.subtypes.get(prop);
+        return subtype;
+    }
+    return findParentSubType(instance.__parent__, prop);
 };
 const isClass = (fn) => {
-	if (typeof fn.prototype !== 'object') {
-		return false;
-	}
-	if (fn.prototype.constructor !== fn) {
-		return false;
-	}
-	return Reflect.getOwnPropertyDescriptor(fn, 'prototype').writable === false;
+    if (typeof fn.prototype !== 'object') {
+        return false;
+    }
+    if (fn.prototype.constructor !== fn) {
+        return false;
+    }
+    return Reflect.getOwnPropertyDescriptor(fn, 'prototype').writable === false;
 };
 const makeFakeModificatorType = (TypeName, fakeModificator = function () { }) => {
-	const modificatorBody = compileNewModificatorFunctionBody_1.default(TypeName);
-	const modificatorType = modificatorBody(fakeModificator, CreationHandler, SymbolConstructorName);
-	return modificatorType();
+    const modificatorBody = (0, compileNewModificatorFunctionBody_1.default)(TypeName);
+    const modificatorType = modificatorBody(fakeModificator, CreationHandler, SymbolConstructorName);
+    return modificatorType();
 };
 const reflectPrimitiveWrappers = (_thisArg) => {
-	let thisArg = _thisArg;
-	if (_thisArg === null) {
-		thisArg = Object.create(null);
-		odp(thisArg, Symbol.toPrimitive, {
-			get () {
-				return () => {
-					return _thisArg;
-				};
-			}
-		});
-	}
-	if (_thisArg instanceof Number ||
+    let thisArg = _thisArg;
+    if (_thisArg === null) {
+        thisArg = Object.create(null);
+        odp(thisArg, Symbol.toPrimitive, {
+            get() {
+                return () => {
+                    return _thisArg;
+                };
+            }
+        });
+    }
+    if (_thisArg instanceof Number ||
         _thisArg instanceof Boolean ||
         _thisArg instanceof String) {
-		odp(thisArg, Symbol.toPrimitive, {
-			get () {
-				return () => {
-					return _thisArg.valueOf();
-				};
-			}
-		});
-	}
-	return thisArg;
+        odp(thisArg, Symbol.toPrimitive, {
+            get() {
+                return () => {
+                    return _thisArg.valueOf();
+                };
+            }
+        });
+    }
+    return thisArg;
 };
 const TypesUtils = {
-	isClass,
-	CreationHandler,
-	getModificationConstructor,
-	checkProto,
-	getTypeChecker,
-	getTypeSplitPath,
-	getExistentAsyncStack,
-	checkTypeName,
-	findParentSubType,
-	makeFakeModificatorType,
-	reflectPrimitiveWrappers
+    isClass,
+    CreationHandler,
+    getModificationConstructor,
+    checkProto,
+    getTypeChecker,
+    getTypeSplitPath,
+    getExistentAsyncStack,
+    checkTypeName,
+    findParentSubType,
+    makeFakeModificatorType,
+    reflectPrimitiveWrappers
 };
 exports.default = TypesUtils;

package/build/constants/index.js

@@ -1,5 +1,5 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.constants = void 0;
 const MNEMONICA = 'Mnemonica';
 const MNEMOSYNE = 'Mnemosyne';
@@ -15,66 +15,66 @@ const SymbolConfig = Symbol('Mnemonica Config Data');
 const SymbolUsed = Symbol('.prototype used twice');
 const TYPE_TITLE_PREFIX = 'modificator of : ';
 const ErrorMessages = {
-	BASE_ERROR_MESSAGE         : 'UNPREDICTABLE BEHAVIOUR',
-	TYPENAME_MUST_BE_A_STRING  : 'typename must be a string',
-	HANDLER_MUST_BE_A_FUNCTION : 'handler must be a function',
-	WRONG_TYPE_DEFINITION      : 'wrong type definition',
-	WRONG_INSTANCE_INVOCATION  : 'wrong instance invocation',
-	WRONG_MODIFICATION_PATTERN : 'wrong modification pattern',
-	ALREADY_DECLARED           : 'this type has already been declared',
-	WRONG_ARGUMENTS_USED       : 'wrong arguments : should use proper invocation',
-	WRONG_HOOK_TYPE            : 'this hook type does not exist',
-	MISSING_HOOK_CALLBACK      : 'hook definition requires callback',
-	MISSING_CALLBACK_ARGUMENT  : 'callback is required argument',
-	FLOW_CHECKER_REDEFINITION  : 'attempt to re-define flow checker callback',
-	NAMESPACE_DOES_NOT_EXIST   : 'namespace does not exits',
-	ASSOCIATION_EXISTS         : 'association is already made',
-	OPTIONS_ERROR              : 'options must be an object or a string',
-	WRONG_STACK_CLEANER        : 'wrong stack cleaner instanceof',
-	PROTOTYPE_USED_TWICE       : '.prototype used twice',
+    BASE_ERROR_MESSAGE: 'UNPREDICTABLE BEHAVIOUR',
+    TYPENAME_MUST_BE_A_STRING: 'typename must be a string',
+    HANDLER_MUST_BE_A_FUNCTION: 'handler must be a function',
+    WRONG_TYPE_DEFINITION: 'wrong type definition',
+    WRONG_INSTANCE_INVOCATION: 'wrong instance invocation',
+    WRONG_MODIFICATION_PATTERN: 'wrong modification pattern',
+    ALREADY_DECLARED: 'this type has already been declared',
+    WRONG_ARGUMENTS_USED: 'wrong arguments : should use proper invocation',
+    WRONG_HOOK_TYPE: 'this hook type does not exist',
+    MISSING_HOOK_CALLBACK: 'hook definition requires callback',
+    MISSING_CALLBACK_ARGUMENT: 'callback is required argument',
+    FLOW_CHECKER_REDEFINITION: 'attempt to re-define flow checker callback',
+    NAMESPACE_DOES_NOT_EXIST: 'namespace does not exits',
+    ASSOCIATION_EXISTS: 'association is already made',
+    OPTIONS_ERROR: 'options must be an object or a string',
+    WRONG_STACK_CLEANER: 'wrong stack cleaner instanceof',
+    PROTOTYPE_USED_TWICE: '.prototype used twice',
 };
 exports.constants = {
-	get 'SymbolSubtypeCollection' () {
-		return SymbolSubtypeCollection;
-	},
-	get 'SymbolConstructorName' () {
-		return SymbolConstructorName;
-	},
-	get 'SymbolGaia' () {
-		return SymbolGaia;
-	},
-	get 'SymbolReplaceGaia' () {
-		return SymbolReplaceGaia;
-	},
-	get 'SymbolDefaultNamespace' () {
-		return SymbolDefaultNamespace;
-	},
-	get 'SymbolDefaultTypesCollection' () {
-		return SymbolDefaultTypesCollection;
-	},
-	get 'SymbolConfig' () {
-		return SymbolConfig;
-	},
-	get 'SymbolUsed' () {
-		return SymbolUsed;
-	},
-	get 'MNEMONICA' () {
-		return MNEMONICA;
-	},
-	get 'MNEMOSYNE' () {
-		return MNEMOSYNE;
-	},
-	get 'GAIA' () {
-		return GAIA;
-	},
-	get 'URANUS' () {
-		return URANUS;
-	},
-	get 'odp' () {
-		return (o, p, attributes) => {
-			return Object.defineProperty(o, p, attributes);
-		};
-	},
-	TYPE_TITLE_PREFIX,
-	ErrorMessages,
+    get 'SymbolSubtypeCollection'() {
+        return SymbolSubtypeCollection;
+    },
+    get 'SymbolConstructorName'() {
+        return SymbolConstructorName;
+    },
+    get 'SymbolGaia'() {
+        return SymbolGaia;
+    },
+    get 'SymbolReplaceGaia'() {
+        return SymbolReplaceGaia;
+    },
+    get 'SymbolDefaultNamespace'() {
+        return SymbolDefaultNamespace;
+    },
+    get 'SymbolDefaultTypesCollection'() {
+        return SymbolDefaultTypesCollection;
+    },
+    get 'SymbolConfig'() {
+        return SymbolConfig;
+    },
+    get 'SymbolUsed'() {
+        return SymbolUsed;
+    },
+    get 'MNEMONICA'() {
+        return MNEMONICA;
+    },
+    get 'MNEMOSYNE'() {
+        return MNEMOSYNE;
+    },
+    get 'GAIA'() {
+        return GAIA;
+    },
+    get 'URANUS'() {
+        return URANUS;
+    },
+    get 'odp'() {
+        return (o, p, attributes) => {
+            return Object.defineProperty(o, p, attributes);
+        };
+    },
+    TYPE_TITLE_PREFIX,
+    ErrorMessages,
 };

package/build/descriptors/errors/index.js

@@ -1,14 +1,14 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorsTypes = void 0;
-const constants_1 = require('../../constants');
-const errors_1 = require('../../api/errors');
+const constants_1 = require("../../constants");
+const errors_1 = require("../../api/errors");
 const { ErrorMessages, } = constants_1.constants;
 exports.ErrorsTypes = {
-	BASE_MNEMONICA_ERROR : errors_1.BASE_MNEMONICA_ERROR
+    BASE_MNEMONICA_ERROR: errors_1.BASE_MNEMONICA_ERROR
 };
 Object.entries(ErrorMessages).forEach(entry => {
-	const [ErrorConstructorName, message] = entry;
-	const ErrorConstructor = errors_1.constructError(ErrorConstructorName, message);
-	exports.ErrorsTypes[ErrorConstructorName] = ErrorConstructor;
+    const [ErrorConstructorName, message] = entry;
+    const ErrorConstructor = (0, errors_1.constructError)(ErrorConstructorName, message);
+    exports.ErrorsTypes[ErrorConstructorName] = ErrorConstructor;
 });

package/build/descriptors/index.js

@@ -1,7 +1,7 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.descriptors = void 0;
-const errors_1 = require('./errors');
-const namespaces_1 = require('./namespaces');
-const types_1 = require('./types');
-exports.descriptors = Object.assign(Object.assign(Object.assign({}, namespaces_1.namespaces), types_1.types), { ErrorsTypes : errors_1.ErrorsTypes });
+const errors_1 = require("./errors");
+const namespaces_1 = require("./namespaces");
+const types_1 = require("./types");
+exports.descriptors = Object.assign(Object.assign(Object.assign({}, namespaces_1.namespaces), types_1.types), { ErrorsTypes: errors_1.ErrorsTypes });

package/build/descriptors/namespaces/index.js

@@ -1,92 +1,92 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.namespaces = void 0;
-const constants_1 = require('../../constants');
+const constants_1 = require("../../constants");
 const { odp, MNEMONICA, SymbolDefaultNamespace, SymbolConfig, } = constants_1.constants;
-const errors_1 = require('../../descriptors/errors');
+const errors_1 = require("../../descriptors/errors");
 const { OPTIONS_ERROR, } = errors_1.ErrorsTypes;
-const hooksAPI = require('../../api/hooks');
-const __1 = require('../');
+const hooksAPI = require("../../api/hooks");
+const __1 = require("../");
 const defaultOptions = {
-	useOldStyle : false,
-	strictChain : true,
-	blockErrors : true,
-	submitStack : false,
-	awaitReturn : true,
-	bindedProto : true,
+    useOldStyle: false,
+    strictChain: true,
+    blockErrors: true,
+    submitStack: false,
+    awaitReturn: true,
+    bindedProto: true,
 };
 const namespaceStorage = new Map();
 const Namespace = function (name, config) {
-	if (typeof config === 'string') {
-		config = {
-			description : config
-		};
-	}
-	if (!(config instanceof Object)) {
-		throw new OPTIONS_ERROR;
-	}
-	const typesCollections = new Map();
-	config = Object.assign({}, defaultOptions, config);
-	odp(this, SymbolConfig, {
-		get () {
-			return config;
-		}
-	});
-	odp(this, 'name', {
-		get () {
-			return name;
-		},
-		enumerable : true
-	});
-	odp(this, 'typesCollections', {
-		get () {
-			return typesCollections;
-		},
-		enumerable : true
-	});
-	const hooks = Object.create(null);
-	odp(this, 'hooks', {
-		get () {
-			return hooks;
-		}
-	});
-	namespaceStorage.set(name, this);
+    if (typeof config === 'string') {
+        config = {
+            description: config
+        };
+    }
+    if (!(config instanceof Object)) {
+        throw new OPTIONS_ERROR;
+    }
+    const typesCollections = new Map();
+    config = Object.assign({}, defaultOptions, config);
+    odp(this, SymbolConfig, {
+        get() {
+            return config;
+        }
+    });
+    odp(this, 'name', {
+        get() {
+            return name;
+        },
+        enumerable: true
+    });
+    odp(this, 'typesCollections', {
+        get() {
+            return typesCollections;
+        },
+        enumerable: true
+    });
+    const hooks = Object.create(null);
+    odp(this, 'hooks', {
+        get() {
+            return hooks;
+        }
+    });
+    namespaceStorage.set(name, this);
 };
-Namespace.prototype = Object.assign({ createTypesCollection (association, config) {
-	const { createTypesCollection } = __1.descriptors;
-	return createTypesCollection(this, association, config);
-} }, hooksAPI);
+Namespace.prototype = Object.assign({ createTypesCollection(association, config) {
+        const { createTypesCollection } = __1.descriptors;
+        return createTypesCollection(this, association, config);
+    } }, hooksAPI);
 const DEFAULT_NAMESPACE = new Namespace(SymbolDefaultNamespace, {
-	description : `default ${MNEMONICA} namespace`
+    description: `default ${MNEMONICA} namespace`
 });
 exports.namespaces = Object.create(null);
 odp(exports.namespaces, 'createNamespace', {
-	get () {
-		return (name, config = {}) => {
-			return new Namespace(name, config);
-		};
-	},
-	enumerable : true
+    get() {
+        return (name, config = {}) => {
+            return new Namespace(name, config);
+        };
+    },
+    enumerable: true
 });
 odp(exports.namespaces, 'namespaces', {
-	get () {
-		return namespaceStorage;
-	},
-	enumerable : true
+    get() {
+        return namespaceStorage;
+    },
+    enumerable: true
 });
 odp(exports.namespaces, 'defaultNamespace', {
-	get () {
-		return DEFAULT_NAMESPACE;
-	},
-	enumerable : true
+    get() {
+        return DEFAULT_NAMESPACE;
+    },
+    enumerable: true
 });
 odp(exports.namespaces, SymbolDefaultNamespace, {
-	get () {
-		return DEFAULT_NAMESPACE;
-	}
+    get() {
+        return DEFAULT_NAMESPACE;
+    }
 });
 odp(exports.namespaces, 'defaultOptionsKeys', {
-	get () {
-		return Object.keys(defaultOptions);
-	}
+    get() {
+        return Object.keys(defaultOptions);
+    }
 });