mnemonica 0.9.944 → 0.9.947

package/build/api/errors/bindedMethodErrorHandler.js

@@ -1,56 +1,56 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.bindedMethodErrorHandler = void 0;
-const constants_1 = require('../../constants');
+const constants_1 = require("../../constants");
 const { odp, } = constants_1.constants;
 const bindedMethodErrorHandler = (exceptionReason) => {
-	const { applyTo, args, method, asNew, error } = exceptionReason;
-	const reThrown = error.exceptionReason !== undefined;
-	if (reThrown) {
-		error.reasons.push(exceptionReason);
-		error.surplus.push(error);
-		return error;
-	}
-	else {
-		odp(error, 'exceptionReason', {
-			get () {
-				return exceptionReason;
-			},
-			enumerable : true
-		});
-		const reasons = [exceptionReason];
-		odp(error, 'reasons', {
-			get () {
-				return reasons;
-			},
-			enumerable : true
-		});
-		const surplus = [];
-		odp(error, 'surplus', {
-			get () {
-				return surplus;
-			},
-			enumerable : true
-		});
-	}
-	if (applyTo && applyTo.exception instanceof Function) {
-		let preparedException = error;
-		try {
-			preparedException = new applyTo.exception(error, {
-				args,
-				exceptionReasonMethod : method,
-				exceptionReasonObject : applyTo,
-				reasonsIsNew          : asNew
-			});
-		}
-		catch (additionalError) {
-			error.surplus.push(additionalError);
-			return error;
-		}
-		if (preparedException instanceof Error) {
-			return preparedException;
-		}
-	}
-	return error;
+    const { applyTo, args, method, asNew, error } = exceptionReason;
+    const reThrown = error.exceptionReason !== undefined;
+    if (reThrown) {
+        error.reasons.push(exceptionReason);
+        error.surplus.push(error);
+        return error;
+    }
+    else {
+        odp(error, 'exceptionReason', {
+            get() {
+                return exceptionReason;
+            },
+            enumerable: true
+        });
+        const reasons = [exceptionReason];
+        odp(error, 'reasons', {
+            get() {
+                return reasons;
+            },
+            enumerable: true
+        });
+        const surplus = [];
+        odp(error, 'surplus', {
+            get() {
+                return surplus;
+            },
+            enumerable: true
+        });
+    }
+    if (applyTo && applyTo.exception instanceof Function) {
+        let preparedException = error;
+        try {
+            preparedException = new applyTo.exception(error, {
+                args,
+                exceptionReasonMethod: method,
+                exceptionReasonObject: applyTo,
+                reasonsIsNew: asNew
+            });
+        }
+        catch (additionalError) {
+            error.surplus.push(additionalError);
+            return error;
+        }
+        if (preparedException instanceof Error) {
+            return preparedException;
+        }
+    }
+    return error;
 };
 exports.bindedMethodErrorHandler = bindedMethodErrorHandler;

package/build/api/errors/exceptionConstructor.js

@@ -1,110 +1,110 @@
 '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 } = constants_1.constants;
-const errors_1 = require('../../descriptors/errors');
+const errors_1 = require("../../descriptors/errors");
 const { WRONG_ARGUMENTS_USED, WRONG_INSTANCE_INVOCATION } = errors_1.ErrorsTypes;
-const errors_2 = require('../errors');
-const utils_1 = require('../../utils');
+const errors_2 = require("../errors");
+const utils_1 = require("../../utils");
 const { parse } = utils_1.utils;
-const utils_2 = require('../utils');
+const utils_2 = require("../utils");
 const { makeFakeModificatorType } = utils_2.default;
-const InstanceModificator_1 = require('../types/InstanceModificator');
+const InstanceModificator_1 = require("../types/InstanceModificator");
 const checkThrowArgs = (instance, target, error, args) => {
-	let wrongThrow;
-	if (!target) {
-		throw new WRONG_INSTANCE_INVOCATION('exception should be made with new keyword');
-	}
-	if (!(error instanceof Error)) {
-		wrongThrow = new WRONG_ARGUMENTS_USED('error must be instanceof Error');
-	}
-	if (!(wrongThrow instanceof Error)) {
-		return;
-	}
-	odp(wrongThrow, 'instance', {
-		get () {
-			return instance;
-		}
-	});
-	odp(wrongThrow, 'error', {
-		get () {
-			return error;
-		}
-	});
-	odp(wrongThrow, 'args', {
-		get () {
-			return args;
-		}
-	});
-	throw wrongThrow;
+    let wrongThrow;
+    if (!target) {
+        throw new WRONG_INSTANCE_INVOCATION('exception should be made with new keyword');
+    }
+    if (!(error instanceof Error)) {
+        wrongThrow = new WRONG_ARGUMENTS_USED('error must be instanceof Error');
+    }
+    if (!(wrongThrow instanceof Error)) {
+        return;
+    }
+    odp(wrongThrow, 'instance', {
+        get() {
+            return instance;
+        }
+    });
+    odp(wrongThrow, 'error', {
+        get() {
+            return error;
+        }
+    });
+    odp(wrongThrow, 'args', {
+        get() {
+            return args;
+        }
+    });
+    throw wrongThrow;
 };
 const exceptionConsctructHandler = function (opts) {
-	const { instance, TypeName, typeStack, args, error } = opts;
-	const exception = this;
-	odp(exception, 'args', {
-		get () {
-			return args;
-		}
-	});
-	odp(exception, 'originalError', {
-		get () {
-			return error;
-		}
-	});
-	odp(exception, 'instance', {
-		get () {
-			return instance;
-		}
-	});
-	odp(exception, 'extract', {
-		get () {
-			return () => {
-				return instance.extract();
-			};
-		}
-	});
-	odp(exception, 'parse', {
-		get () {
-			return () => {
-				return parse(instance);
-			};
-		}
-	});
-	const errorStack = exception.stack.split('\n');
-	const stack = [];
-	const title = `\n<-- lifecycle of [ ${TypeName} ] traced -->`;
-	errors_2.getStack.call(exception, title, [], prepareException);
-	stack.push(...exception.stack);
-	stack.push('<-- with the following error -->');
-	errorStack.forEach((line) => {
-		if (!stack.includes(line)) {
-			stack.push(line);
-		}
-	});
-	stack.push('\n<-- of constructor definitions stack -->');
-	stack.push(...typeStack);
-	exception.stack = (0, errors_2.cleanupStack)(stack).join('\n');
-	return exception;
+    const { instance, TypeName, typeStack, args, error } = opts;
+    const exception = this;
+    odp(exception, 'args', {
+        get() {
+            return args;
+        }
+    });
+    odp(exception, 'originalError', {
+        get() {
+            return error;
+        }
+    });
+    odp(exception, 'instance', {
+        get() {
+            return instance;
+        }
+    });
+    odp(exception, 'extract', {
+        get() {
+            return () => {
+                return instance.extract();
+            };
+        }
+    });
+    odp(exception, 'parse', {
+        get() {
+            return () => {
+                return parse(instance);
+            };
+        }
+    });
+    const errorStack = exception.stack.split('\n');
+    const stack = [];
+    const title = `\n<-- lifecycle of [ ${TypeName} ] traced -->`;
+    errors_2.getStack.call(exception, title, [], prepareException);
+    stack.push(...exception.stack);
+    stack.push('<-- with the following error -->');
+    errorStack.forEach((line) => {
+        if (!stack.includes(line)) {
+            stack.push(line);
+        }
+    });
+    stack.push('\n<-- of constructor definitions stack -->');
+    stack.push(...typeStack);
+    exception.stack = (0, errors_2.cleanupStack)(stack).join('\n');
+    return exception;
 };
 const prepareException = function (target, error, ...args) {
-	const instance = this;
-	checkThrowArgs(instance, target, error, args);
-	const { __type__, __creator__ } = instance;
-	const { stack: typeStack, TypeName } = __type__;
-	const ExceptionCreator = Object.create(__creator__);
-	ExceptionCreator.config = Object.assign({}, __creator__.config);
-	ExceptionCreator.config.blockErrors = false;
-	ExceptionCreator.existentInstance = error;
-	ExceptionCreator.ModificatorType = makeFakeModificatorType(TypeName, function () {
-		return exceptionConsctructHandler.call(this, {
-			instance,
-			TypeName,
-			typeStack,
-			args,
-			error
-		});
-	});
-	ExceptionCreator.InstanceModificator = (0, InstanceModificator_1.makeInstanceModificator)(ExceptionCreator);
-	return new ExceptionCreator.InstanceModificator();
+    const instance = this;
+    checkThrowArgs(instance, target, error, args);
+    const { __type__, __creator__ } = instance;
+    const { stack: typeStack, TypeName } = __type__;
+    const ExceptionCreator = Object.create(__creator__);
+    ExceptionCreator.config = Object.assign({}, __creator__.config);
+    ExceptionCreator.config.blockErrors = false;
+    ExceptionCreator.existentInstance = error;
+    ExceptionCreator.ModificatorType = makeFakeModificatorType(TypeName, function () {
+        return exceptionConsctructHandler.call(this, {
+            instance,
+            TypeName,
+            typeStack,
+            args,
+            error
+        });
+    });
+    ExceptionCreator.InstanceModificator = (0, InstanceModificator_1.makeInstanceModificator)(ExceptionCreator);
+    return new ExceptionCreator.InstanceModificator();
 };
 exports.default = prepareException;

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

@@ -1,6 +1,6 @@
 export declare const stackCleaners: RegExp[];
 export declare const cleanupStack: (stack: string[]) => string[];
-export declare const getStack: (this: any, title: string, stackAddition: string[], tillFunction?: CallableFunction | undefined) => any;
+export declare const getStack: (this: any, title: string, stackAddition: string[], tillFunction?: CallableFunction) => any;
 export declare class BASE_MNEMONICA_ERROR extends Error {
     constructor(message: string | undefined, additionalStack: string[]);
 }

package/build/api/errors/index.js

@@ -1,61 +1,61 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.constructError = exports.BASE_MNEMONICA_ERROR = exports.getStack = exports.cleanupStack = exports.stackCleaners = void 0;
-const constants_1 = require('../../constants');
+const constants_1 = require("../../constants");
 const { odp, SymbolConstructorName, MNEMONICA, ErrorMessages, } = constants_1.constants;
 const { BASE_ERROR_MESSAGE } = ErrorMessages;
 exports.stackCleaners = [];
 const cleanupStack = (stack) => {
-	const cleaned = stack.reduce((arr, line) => {
-		exports.stackCleaners.forEach(cleanerRegExp => {
-			if (!cleanerRegExp.test(line)) {
-				arr.push(line);
-			}
-		});
-		return arr;
-	}, []);
-	return cleaned.length ? cleaned : stack;
+    const cleaned = stack.reduce((arr, line) => {
+        exports.stackCleaners.forEach(cleanerRegExp => {
+            if (!cleanerRegExp.test(line)) {
+                arr.push(line);
+            }
+        });
+        return arr;
+    }, []);
+    return cleaned.length ? cleaned : stack;
 };
 exports.cleanupStack = cleanupStack;
 const getStack = function (title, stackAddition, tillFunction) {
-	if (Error.captureStackTrace) {
-		Error.captureStackTrace(this, tillFunction || exports.getStack);
-	}
-	else {
-		this.stack = (new Error()).stack;
-	}
-	this.stack = this.stack.split('\n').slice(1);
-	this.stack = (0, exports.cleanupStack)(this.stack);
-	this.stack.unshift(title);
-	if (Array.isArray(stackAddition) && stackAddition.length) {
-		this.stack.push(...stackAddition);
-	}
-	this.stack.push('\n');
-	return this.stack;
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, tillFunction || exports.getStack);
+    }
+    else {
+        this.stack = (new Error()).stack;
+    }
+    this.stack = this.stack.split('\n').slice(1);
+    this.stack = (0, exports.cleanupStack)(this.stack);
+    this.stack.unshift(title);
+    if (Array.isArray(stackAddition) && stackAddition.length) {
+        this.stack.push(...stackAddition);
+    }
+    this.stack.push('\n');
+    return this.stack;
 };
 exports.getStack = getStack;
 class BASE_MNEMONICA_ERROR extends Error {
-	constructor (message = BASE_ERROR_MESSAGE, additionalStack) {
-		super(message);
-		const BaseStack = this.stack;
-		odp(this, 'BaseStack', {
-			get () {
-				return BaseStack;
-			}
-		});
-		const stack = (0, exports.cleanupStack)(BaseStack.split('\n'));
-		if (additionalStack) {
-			stack.unshift(...additionalStack);
-		}
-		this.stack = stack.join('\n');
-	}
-	static get [SymbolConstructorName] () {
-		return `base of : ${MNEMONICA} : errors`;
-	}
+    constructor(message = BASE_ERROR_MESSAGE, additionalStack) {
+        super(message);
+        const BaseStack = this.stack;
+        odp(this, 'BaseStack', {
+            get() {
+                return BaseStack;
+            }
+        });
+        const stack = (0, exports.cleanupStack)(BaseStack.split('\n'));
+        if (additionalStack) {
+            stack.unshift(...additionalStack);
+        }
+        this.stack = stack.join('\n');
+    }
+    static get [SymbolConstructorName]() {
+        return `base of : ${MNEMONICA} : errors`;
+    }
 }
 exports.BASE_MNEMONICA_ERROR = BASE_MNEMONICA_ERROR;
 const constructError = (name, message) => {
-	const body = `
+    const body = `
 		class ${name} extends base {
 			constructor (addition, stack) {
 				super(addition ?
@@ -67,7 +67,7 @@ const constructError = (name, message) => {
 		};
 		return ${name};
 	`;
-	const ErrorConstructor = (new Function('base', body))(BASE_MNEMONICA_ERROR);
-	return ErrorConstructor;
+    const ErrorConstructor = (new Function('base', body))(BASE_MNEMONICA_ERROR);
+    return ErrorConstructor;
 };
 exports.constructError = constructError;

package/build/api/errors/throwModificationError.js

@@ -1,103 +1,103 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.throwModificationError = void 0;
-const constants_1 = require('../../constants');
+const constants_1 = require("../../constants");
 const { odp, SymbolReplaceGaia, } = constants_1.constants;
-const errors_1 = require('../../descriptors/errors');
+const errors_1 = require("../../descriptors/errors");
 const { BASE_MNEMONICA_ERROR } = errors_1.ErrorsTypes;
-const _1 = require('./');
-const utils_1 = require('../utils');
+const _1 = require("./");
+const utils_1 = require("../utils");
 const { makeFakeModificatorType } = utils_1.default;
-const utils_2 = require('../../utils');
+const utils_2 = require("../../utils");
 const { parse } = utils_2.utils;
-const InstanceModificator_1 = require('../types/InstanceModificator');
+const InstanceModificator_1 = require("../types/InstanceModificator");
 const throwModificationError = function (error) {
-	const self = this;
-	const { TypeName, type: { stack: typeStack }, args } = self;
-	const exceptionReason = error.exceptionReason || error;
-	if (error.exceptionReason !== undefined) {
-		error.reasons.push(error.exceptionReason);
-		error.surplus.push(error);
-		throw error;
-	}
-	odp(error, 'exceptionReason', {
-		get () {
-			return exceptionReason;
-		},
-		enumerable : true
-	});
-	const reasons = [exceptionReason];
-	odp(error, 'reasons', {
-		get () {
-			return reasons;
-		},
-		enumerable : true
-	});
-	const surplus = [];
-	odp(error, 'surplus', {
-		get () {
-			return surplus;
-		},
-		enumerable : true
-	});
-	self.ModificatorType = makeFakeModificatorType(TypeName);
-	self.InstanceModificator = (0, InstanceModificator_1.makeInstanceModificator)(self);
-	const erroredInstance = new self.InstanceModificator();
-	erroredInstance[SymbolReplaceGaia](error);
-	const stack = [];
-	if (error instanceof BASE_MNEMONICA_ERROR) {
-		stack.push(error.stack);
-	}
-	else {
-		const title = `\n<-- creation of [ ${TypeName} ] traced -->`;
-		_1.getStack.call(erroredInstance, title, [], exports.throwModificationError);
-		stack.push(...erroredInstance.stack);
-		const errorStack = error.stack.split('\n');
-		stack.push('<-- with the following error -->');
-		errorStack.forEach((line) => {
-			if (!stack.includes(line)) {
-				stack.push(line);
-			}
-		});
-		stack.push('\n<-- of constructor definitions stack -->');
-		stack.push(...typeStack);
-	}
-	erroredInstance.stack = (0, _1.cleanupStack)(stack).join('\n');
-	self.inheritedInstance = erroredInstance;
-	const results = self.invokePostHooks();
-	const { type, collection, namespace } = results;
-	if (type.has(true) || collection.has(true) || namespace.has(true)) {
-		return;
-	}
-	odp(erroredInstance, 'args', {
-		get () {
-			return args;
-		}
-	});
-	odp(erroredInstance, 'originalError', {
-		get () {
-			return error;
-		}
-	});
-	odp(erroredInstance, 'instance', {
-		get () {
-			return erroredInstance;
-		}
-	});
-	odp(erroredInstance, 'extract', {
-		get () {
-			return () => {
-				return erroredInstance.__self__.extract();
-			};
-		}
-	});
-	odp(erroredInstance, 'parse', {
-		get () {
-			return () => {
-				return parse(erroredInstance);
-			};
-		}
-	});
-	throw erroredInstance;
+    const self = this;
+    const { TypeName, type: { stack: typeStack }, args } = self;
+    const exceptionReason = error.exceptionReason || error;
+    if (error.exceptionReason !== undefined) {
+        error.reasons.push(error.exceptionReason);
+        error.surplus.push(error);
+        throw error;
+    }
+    odp(error, 'exceptionReason', {
+        get() {
+            return exceptionReason;
+        },
+        enumerable: true
+    });
+    const reasons = [exceptionReason];
+    odp(error, 'reasons', {
+        get() {
+            return reasons;
+        },
+        enumerable: true
+    });
+    const surplus = [];
+    odp(error, 'surplus', {
+        get() {
+            return surplus;
+        },
+        enumerable: true
+    });
+    self.ModificatorType = makeFakeModificatorType(TypeName);
+    self.InstanceModificator = (0, InstanceModificator_1.makeInstanceModificator)(self);
+    const erroredInstance = new self.InstanceModificator();
+    erroredInstance[SymbolReplaceGaia](error);
+    const stack = [];
+    if (error instanceof BASE_MNEMONICA_ERROR) {
+        stack.push(error.stack);
+    }
+    else {
+        const title = `\n<-- creation of [ ${TypeName} ] traced -->`;
+        _1.getStack.call(erroredInstance, title, [], exports.throwModificationError);
+        stack.push(...erroredInstance.stack);
+        const errorStack = error.stack.split('\n');
+        stack.push('<-- with the following error -->');
+        errorStack.forEach((line) => {
+            if (!stack.includes(line)) {
+                stack.push(line);
+            }
+        });
+        stack.push('\n<-- of constructor definitions stack -->');
+        stack.push(...typeStack);
+    }
+    erroredInstance.stack = (0, _1.cleanupStack)(stack).join('\n');
+    self.inheritedInstance = erroredInstance;
+    const results = self.invokePostHooks();
+    const { type, collection, namespace } = results;
+    if (type.has(true) || collection.has(true) || namespace.has(true)) {
+        return;
+    }
+    odp(erroredInstance, 'args', {
+        get() {
+            return args;
+        }
+    });
+    odp(erroredInstance, 'originalError', {
+        get() {
+            return error;
+        }
+    });
+    odp(erroredInstance, 'instance', {
+        get() {
+            return erroredInstance;
+        }
+    });
+    odp(erroredInstance, 'extract', {
+        get() {
+            return () => {
+                return erroredInstance.__self__.extract();
+            };
+        }
+    });
+    odp(erroredInstance, 'parse', {
+        get() {
+            return () => {
+                return parse(erroredInstance);
+            };
+        }
+    });
+    throw erroredInstance;
 };
 exports.throwModificationError = throwModificationError;