mnemonica 0.9.93 → 0.9.98

package/README.md

@@ -10,10 +10,8 @@ abstract technique that aids information retention : instance inheritance system
 
 # shortcuts
 
-* ?. : state : **mad science**
 * ?. : type : **asynchronous monad descriptor** => this
 * ?. : prod ready : **we wonder about**
-* ?. : typescript : **yes, some, starting from 0.9.77**
 * ?. : example : **git clone && npm run example**
 
 ---
@@ -28,17 +26,6 @@ abstract technique that aids information retention : instance inheritance system
 
 ---
 
-# TypeScript note
-
-If you are TypeScript user we have good news for you:
-* there is more than one way to annotate the code
-* we provide support with some limitations
-* and you can help to do better
-
-Please visit [Mnemonica TypeScript](https://github.com/wentout/mnemonica/blob/master/TypeScript.md) page for explanations.
-
----
-
 
 # core concept
 
@@ -49,6 +36,13 @@ This lib might help to create some sort of order or sequence or precedence of ho
 * [Dead Simple type checker for JavaScript](https://dev.to/wentout/dead-simple-type-checker-for-javascript-4l40)
 
 
+## TypeScript note
+
+**define** function now fully supports TypeScript definitions
+
+for more easy types writing nested~sub constructors might be applied using just direct apply, call or bind functions
+
+
 ## Factory of Constructors
 
 As we discrovered from that article, we need some tooling, giving us the best experience with Prototype Chain Inheritance pattern. First of all it must be reproducible and maintainable. And from the first point we have to define some sort of Factory Constructor for start crafting our Instances, it might look like so:
@@ -645,6 +639,39 @@ usingReactAsProto.render("just works", root);
 
 ```
 
+
+# call, apply & bind ( existent, ItsNestedType, ...args)
+
+mostly for TypeScript purpose you may do this
+
+```js
+const SomeType = define('SomeType', function () {
+	// ...
+});
+
+
+const SomeSubType = SomeType
+	.define('SomeSubType', function (...args) {
+		// ...
+	});
+
+const someInstance = new SomeType;
+
+const someSubInstance = call(
+	someInstance, SomeSubType, ...args);
+
+// or for array of args
+const someSubInstance = apply(
+	someInstance, SomeSubType, args);
+
+// or for delayed construction
+const someSubInstanceConstructor = 
+	bind( someInstance, SomeSubType );
+
+const someSubInstance = someSubInstanceConstructor(...args);
+
+```
+
 # Asynchronous Constructors
 First of all you should understand what you wish to are doing!
 Then you should understand what you wish. And only after doing so you might use this technic:

package/build/api/errors/bindedMethodErrorHandler.js

@@ -1,55 +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;
-exports.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 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;
 };
+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 = 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 = 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,59 +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 = [];
-exports.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 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;
 };
-exports.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 = 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.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;
 };
+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 = 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;
-exports.constructError = (name, message) => {
-	const body = `
+const constructError = (name, message) => {
+    const body = `
 		class ${name} extends base {
 			constructor (addition, stack) {
 				super(addition ?
@@ -65,6 +67,7 @@ exports.constructError = (name, message) => {
 		};
 		return ${name};
 	`;
-	const ErrorConstructor = (new Function('base', body))(BASE_MNEMONICA_ERROR);
-	return ErrorConstructor;
+    const NamedErrorConstructor = (new Function('base', body))(BASE_MNEMONICA_ERROR);
+    return NamedErrorConstructor;
 };
+exports.constructError = constructError;