mnemonica 0.9.943 → 0.9.945

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/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;

package/build/api/types/compileNewModificatorFunctionBody.js

@@ -1,32 +1,41 @@
 'use strict';
 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 dt = `${Date.now()}_${`${Math.random()}`.split('.')[1]}`;
-	const modString = asClass ?
-		`class ${FunctionName} extends ConstructHandler_${dt} {
-			constructor(...args) {
-				const answer = super(...args);
-				return CreationHandler_${dt}.call(this, answer);
+	return function (ConstructHandler, CreationHandler, SymbolConstructorName) {
+		return function () {
+			let ModificationBody;
+			if (asClass) {
+				ModificationBody = getClassConstructor(ConstructHandler, CreationHandler);
 			}
-		}`
-		:
-		`const ${FunctionName} = function (...args) {
-			const answer = ConstructHandler_${dt}.call(this, ...args);
-			return CreationHandler_${dt}.call(this, answer);
-		};`;
-	return new Function(`ConstructHandler_${dt}`, `CreationHandler_${dt}`, 'SymbolConstructorName', `return function () {
-
-			${modString}
-
-			Object.defineProperty(${FunctionName}, SymbolConstructorName, {
+			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 FunctionName;
 				}
 			});
-
-			return ${FunctionName};
-
+			return ModificationBody;
 		};
-	`);
+	};
 };
 exports.default = compileNewModificatorFunctionBody;

package/build/index.d.ts

@@ -2,7 +2,7 @@ import { TypeAbsorber, ITypeClass, TypeLookup, IDEF } from './types';
 export type { IDEF } from './types';
 export declare const defaultTypes: any;
 export declare const define: TypeAbsorber;
-export declare const tsdefine: <T>(this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object | undefined, config?: object | undefined) => ITypeClass<T>;
+export declare const tsdefine: <T>(this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
 export declare const lookup: TypeLookup;
 export declare const mnemonica: {
     [index: string]: unknown;

package/build/types/index.d.ts

@@ -3,21 +3,21 @@ export interface ConstructorFunction<ConstructorInstance extends object> {
     (this: ConstructorInstance, ...args: any[]): ConstructorInstance;
     prototype: ConstructorInstance;
 }
-export declare type TypeModificator<T extends object> = (...args: any[]) => ConstructorFunction<T>;
-export declare type TypeLookup = (this: Map<string, any>, TypeNestedPath: string) => TypeClass;
-export declare type TypeClass = {
+export type TypeModificator<T extends object> = (...args: any[]) => ConstructorFunction<T>;
+export type TypeLookup = (this: Map<string, any>, TypeNestedPath: string) => TypeClass;
+export type TypeClass = {
     new (...args: any[]): any;
     define: TypeAbsorber;
     lookup: TypeLookup;
     registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => any;
 };
-export declare type TypeAbsorber = (this: any, TypeName: string, constructHandler: CallableFunction, proto?: object, config?: object) => TypeClass;
-export declare type IDEF<T> = {
+export type TypeAbsorber = (this: any, TypeName: string, constructHandler: CallableFunction, proto?: object, config?: object) => TypeClass;
+export type IDEF<T> = {
     new (...args: any[]): T;
     (this: T, ...args: any[]): T;
     prototype?: ThisType<T>;
 };
-export declare type ITypeAbsorber<T> = (this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
+export type ITypeAbsorber<T> = (this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
 export interface ITypeClass<T> {
     new (...args: any[]): T;
     (this: T, ...args: any[]): T;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mnemonica",
-	"version": "0.9.943",
+	"version": "0.9.945",
 	"description": "abstract technique that aids information retention : instance inheritance system",
 	"type": "commonjs",
 	"main": "./build/index.js",