mnemonica 1.0.1 → 1.0.6

package/src/api/types/Mnemosyne.ts

@@ -1,6 +1,9 @@
 'use strict';
 
-import { _Internal_TC_ } from '../../types';
+import {
+	_Internal_TC_,
+	TypeDef
+} from '../../types';
 
 interface SubtypeEntry {
 	TypeName: string;
@@ -21,148 +24,31 @@ const {
 	reflectPrimitiveWrappers
 } = TypesUtils;
 
-import { extract } from '../../utils/extract';
-import { parent } from '../../utils/parent';
-import { pick } from '../../utils/pick';
-
-import exceptionConstructor from '../errors/exceptionConstructor';
-
 import { InstanceCreator } from './InstanceCreator';
 
 import {
-	_getProps, Props 
+	_getProps, Props
 } from './Props';
 
 const getDefaultPrototype = () => {
-	return Object.create(null);
+	const result = Object.create(null);
+	return result;
 };
 
 // const InstanceRoots = new WeakMap;
 
-const MnemonicaProtoProps = {
-
-	extract () {
-		return function (this: object) {
-			const result = extract(this);
-			return result;
-		};
-	},
-
-	pick () {
-		return function (this: object, ...args: (string | string[])[]) {
-			const result = pick(
-				this,
-				...args
-			);
-			return result;
-		};
-	},
-
-	parent () {
-		return function (this: object, constructorLookupPath: string) {
-			const result = parent(
-				this,
-				constructorLookupPath
-			);
-			return result;
-		};
-	},
-
-	clone (this: { fork: () => object }) {
-		return this.fork();
-	},
-
-	fork (this: object) {
-
-		const props = _getProps(this) as Props;
-
-		const {
-			__type__: type,
-			__collection__: collection,
-			__parent__: existentInstance,
-			__args__,
-			__self__,
-		} = props;
-
-		const {
-			isSubType,
-			TypeName
-		} = type;
-
-		// 'function', cause might be called with 'new'
-		 
-		return function (this: object, ...forkArgs: unknown[]) {
-
-			let forked;
-			const Constructor = isSubType ?
-				existentInstance :
-				collection;
-
-			const args = forkArgs.length ? forkArgs : __args__;
-
-
-			if (this === __self__) {
-				 
-				// @ts-expect-error  this is definitely a constructor
-				forked = new (Constructor[ TypeName ])(...args);
-			} else {
-				// fork.call ? let's do it !
-				forked = new InstanceCreator(
-					type,
-					reflectPrimitiveWrappers(this),
-					args
-				);
-			}
-
-			return forked;
-
-		};
-	},
-
-	[ SymbolConstructorName ] () {
-		return MNEMONICA;
-	},
-
-	exception () {
-		 
-		const self = this;
-		return function (error: Error, ...args: unknown[]) {
-			const target = new.target;
-			return exceptionConstructor.call(
-				self,
-				target,
-				error,
-				...args
-			);
-		};
-	},
-
-	sibling () {
-		 
-		const siblings = (SiblingTypeName: string) => {
-
-			const props = _getProps(this) as Props;
-			const { __collection__: collection, } = props;
-			const sibling: unknown = collection[ SiblingTypeName ];
-			return sibling;
-		};
-
-		return new Proxy(
-			siblings,
-			{
-				get (_, prop: string) {
-					const result = siblings(prop);
-					return result;
-				},
-				apply (_, __, args,) {
-					const result = siblings(args[ 0 ]);
-					return result;
-				}
-			}
-		);
-	}
-
-};
+// Names that used to be auto-injected instance methods. They must still be
+// treated as static/reserved names so the Mnemosyne proxy does not try to
+// construct a subtype when one of them is accessed.
+const mnemonicaInstanceMethodNames = [
+	'extract',
+	'pick',
+	'parent',
+	'clone',
+	'fork',
+	'exception',
+	'sibling',
+];
 
 const staticProps = [
 
@@ -186,7 +72,7 @@ const staticProps = [
 	'showDiff',
 
 ]
-	.concat(Object.keys(MnemonicaProtoProps))
+	.concat(mnemonicaInstanceMethodNames)
 	.concat(Object.getOwnPropertyNames(Object.prototype))
 	.concat(Object.getOwnPropertyNames(Function.prototype))
 	.reduce(
@@ -200,52 +86,31 @@ const staticProps = [
 // tslint:disable-next-line: only-arrow-functions
 const makeSubTypeProxy = function (subtype: SubtypeEntry, inheritedInstance: unknown) {
 
-	const subtypeProxy = new Proxy(
-		InstanceCreator,
-		{
-
-			get (Target, _prop) {
-
-				if (_prop === Symbol.hasInstance) {
-					const result = getTypeChecker(subtype.TypeName);
-					return result;
-				}
-
-				return Reflect.get(
-					Target,
-					_prop
-				);
-
-			},
-
-			construct (Target, _args) {
-				return new Target(
-					subtype,
-					inheritedInstance,
-					_args
-				);
-			},
-
-			apply (Target, thisArg, _args) {
-
-				if (thisArg === undefined) {
-					thisArg = inheritedInstance;
-				}
-
-				const existentInstance = reflectPrimitiveWrappers(thisArg);
-
-				const entity = new Target(
-					subtype,
-					existentInstance,
-					_args
-				);
-				return entity;
-			},
-
+	const SubTypeProxy = function (this: unknown, ..._args: unknown[]) {
+		if (new.target) {
+			const instanceResult = new InstanceCreator(
+				subtype as TypeDef,
+				inheritedInstance as object,
+				_args
+			);
+			return instanceResult;
 		}
-	);
+		const thisArg = this === undefined ? inheritedInstance : this;
+		const existentInstance = reflectPrimitiveWrappers(thisArg);
+		const instance = new InstanceCreator(
+			subtype as TypeDef,
+			existentInstance as object,
+			_args
+		);
+		return instance;
+	};
 
-	return subtypeProxy;
+	const typeChecker = getTypeChecker(subtype.TypeName);
+	Object.defineProperty(SubTypeProxy, Symbol.hasInstance, {
+		value : typeChecker
+	});
+
+	return SubTypeProxy;
 };
 
 const prepareSubtypeForConstruction = function (subtypeName: string, inheritedInstance: unknown) {
@@ -270,14 +135,15 @@ const prepareSubtypeForConstruction = function (subtypeName: string, inheritedIn
 		strictChain ?
 			undefined :
 			findSubTypeFromParent(
-inheritedInstance as object,
-subtypeName
+				inheritedInstance as object,
+				subtypeName
 			);
 
-	return subtype ? makeSubTypeProxy(
+	const result = subtype ? makeSubTypeProxy(
 		subtype,
 		inheritedInstance
 	) : undefined;
+	return result;
 };
 
 const mnemosyneProxyHandlerGet = (target: object, prop: string, receiver: unknown) => {
@@ -316,11 +182,12 @@ const mnemosyneProxyHandlerGet = (target: object, prop: string, receiver: unknow
 		prop,
 		receiver
 	);
-	return subtype || result;
+	const subTypeResult = subtype || result;
+	return subTypeResult;
 };
 
-export const Mnemosyne = function (this: object, mnemonica: object, exposeInstanceMethods: boolean) {
-	 
+export const Mnemosyne = function (this: object, mnemonica: object) {
+
 	const instance = this;
 
 	// because we must instantiate new chain for root
@@ -336,8 +203,8 @@ export const Mnemosyne = function (this: object, mnemonica: object, exposeInstan
 				}
 			}
 		);
-	} as _Internal_TC_<typeof MnemonicaProtoProps>;
-	
+	} as _Internal_TC_<object>;
+
 	// this throws an error
 	Object.setPrototypeOf(
 		Mnemonica.prototype,
@@ -346,38 +213,15 @@ export const Mnemosyne = function (this: object, mnemonica: object, exposeInstan
 	// while this just returns false, silently ... unfortunately
 	// Reflect.setPrototypeOf(Mnemonica.prototype, mnemonica);
 
-	// Only add MnemonicaProtoProps methods if exposeInstanceMethods is true
-	if (exposeInstanceMethods) {
-		Object.entries(MnemonicaProtoProps).forEach(([ name, method ]: [string, unknown]) => {
-			odp(
-				Mnemonica.prototype,
-				name,
-				{
-					get () {
-					 
-						// @ts-expect-error there is a proxy and next line is callable
-						return method.call(this);
-					}
-				}
-			);
-		});
-
-		Object.getOwnPropertySymbols(MnemonicaProtoProps).forEach((symbol: symbol) => {
-			odp(
-				Mnemonica.prototype,
-				symbol,
-				{
-					get () {
-						const symbolMethod = Reflect.get(
-							MnemonicaProtoProps,
-							symbol
-						);
-						return symbolMethod.call(this);
-					}
-				}
-			);
-		});
-	}
+	odp(
+		Mnemonica.prototype,
+		SymbolConstructorName,
+		{
+			get () {
+				return MNEMONICA;
+			}
+		}
+	);
 
 	// instance of self Constructor type
 	odp(
@@ -401,21 +245,18 @@ export const Mnemosyne = function (this: object, mnemonica: object, exposeInstan
 
 } as _Internal_TC_<object>;
 
-const createMnemosyne = function (Uranus: unknown, exposeInstanceMethods: boolean) {
-// const createMnemosyne = function (Uranus: unknown, typeProxy: unknown) {
-// 	if (typeof Uranus === 'undefined') {
-// 		const { __type__: type, Uranus: _uranus } = typeProxy;
-// 		console.log(type, _uranus);
-// 		// eslint-disable-next-line no-debugger
-// 		debugger;
-// 		throw new Error('createMnemosyne Uranus is not defined for typeProxy.');
-// 	}
+const createMnemosyne = function (Uranus: unknown) {
+	// const createMnemosyne = function (Uranus: unknown, typeProxy: unknown) {
+	// 	if (typeof Uranus === 'undefined') {
+	// 		const { __type__: type, Uranus: _uranus } = typeProxy;
+	// 		console.log(type, _uranus);
+	// 		// eslint-disable-next-line no-debugger
+	// 		debugger;
+	// 		throw new Error('createMnemosyne Uranus is not defined for typeProxy.');
+	// 	}
 
 	const uranus = reflectPrimitiveWrappers(Uranus);
-	const mnemosyne = new Mnemosyne(
-		uranus,
-		exposeInstanceMethods
-	);
+	const mnemosyne = new Mnemosyne(uranus);
 	const mnemosyneProxy = new Proxy(
 		mnemosyne,
 		{

package/src/api/types/Props.ts

@@ -113,7 +113,8 @@ export const _addProps = function (this: InstanceCreatorContext): void {
 			'__stack__',
 			{
 				get () {
-					return stack!.join('\n');
+					const result = stack!.join('\n');
+					return result;
 				}
 			}
 		);
@@ -215,7 +216,8 @@ export const getProps = (instance: object): PropsType | undefined => {
 				answer,
 				descriptors
 			);
-			return answer as PropsType;
+			const result = answer as PropsType;
+			return result;
 		} else {
 			return props;
 		}

package/src/api/types/TypeProxy.ts

@@ -85,13 +85,15 @@ TypeProxy.prototype.get = function (this: TypeProxyInstance, target: _Internal_T
 
 	// SomeType.SomeSubType
 	if (type.subtypes.has(prop)) {
-		return type.subtypes.get(prop);
+		const subtypeResult = type.subtypes.get(prop);
+		return subtypeResult;
 	}
 
-	return Reflect.get(
+	const reflectResult = Reflect.get(
 		target,
 		prop
 	);
+	return reflectResult;
 
 };
 
@@ -137,7 +139,8 @@ const subTypeApply = (
 			cstr,
 			cfg
 		);
-		return defineResult as unknown as T;
+		const result = defineResult as unknown as T;
+		return result;
 	};
 	return decorator;
 };
@@ -196,14 +199,7 @@ TypeProxy.prototype.construct = function (this: TypeProxyInstance, _target: unkn
 	// then we should rely on that somehow
 	const uranus = type.isSubType ? getDefaultPrototype() : Uranus;
 
-	// Get exposeInstanceMethods from type config, defaulting to false
-	const config = type.config as { exposeInstanceMethods?: boolean } | undefined;
-	const exposeInstanceMethods = config!.exposeInstanceMethods as unknown as boolean;
-
-	const mnemosyneProxy = createMnemosyne(
-		uranus,
-		exposeInstanceMethods
-	);
+	const mnemosyneProxy = createMnemosyne(uranus);
 	const instance = new InstanceCreator(
 		type,
 		mnemosyneProxy,

package/src/api/types/compileNewModificatorFunctionBody.ts

@@ -51,18 +51,20 @@ const getClassConstructor = (
 	ConstructHandler: ClassConstructHandler,
 	CreationHandler: CreationHandler,
 ) => {
-	return class extends ConstructHandler {
+	const result = class extends ConstructHandler {
 		// oxlint-disable-next-line constructor-super
 		constructor ( ...args: unknown[] ) {
 			const answer = super( ...args );
 			// debugger;
-			const result = CreationHandler.call(
+			const creationResult = CreationHandler.call(
 				this,
 				answer 
 			);
-			return result as object;
+			const castResult = creationResult as object;
+			return castResult;
 		}
 	};
+	return result;
 };
 
 const getFunctionConstructor = (
@@ -79,7 +81,7 @@ const getFunctionConstructor = (
 		) &&
 		(ConstructHandler.prototype.constructor == ConstructHandler);
 
-	return function ( this: object, ...args: unknown[] ) {
+	const funcResult = function ( this: object, ...args: unknown[] ) {
 		let answer;
 		// if (!new.target) {
 		// 	debugger;
@@ -103,17 +105,18 @@ const getFunctionConstructor = (
 		);
 		return result;
 	};
+	return funcResult;
 };
 
 type ModificationBody = new (...args: unknown[]) => object;
 
 const compileNewModificatorFunctionBody = function ( FunctionName: string, asClass = false ) {
-	return function (
+	const outerResult = function (
 		ConstructHandler: ConstructHandler,
 		CreationHandler: CreationHandler,
 		SymbolConstructorName: symbol
 	): () => ModificationBody {
-		return function (): ModificationBody {
+		const innerResult = function (): ModificationBody {
 			let ModificationBody: ModificationBody;
 			if ( asClass ) {
 				ModificationBody = getClassConstructor(
@@ -151,9 +154,12 @@ const compileNewModificatorFunctionBody = function ( FunctionName: string, asCla
 			// Object.freeze( ModificationBody.prototype.constructor );
 			// Object.freeze( ModificationBody.prototype );
 			// Object.freeze( ModificationBody );
-			return ModificationBody;
+			const result = ModificationBody;
+			return result;
 		};
+		return innerResult;
 	};
+	return outerResult;
 };
 
 export default compileNewModificatorFunctionBody;

package/src/api/types/index.ts

@@ -182,7 +182,8 @@ const TypeDescriptor = function (
 
 	// types.set( TypeName, new TypeProxy( type ) );
 
-	return types.get(TypeName);
+	const result = types.get(TypeName);
+	return result;
 
 } as unknown as _Internal_TC_<TypeDescriptorInstance>;
 
@@ -197,23 +198,25 @@ TypeDescriptor.prototype.define = function (
 	constructHandlerOrConfig?: CallableFunction | object,
 	config?: object
 ) {
-	return define.call(
+	const result = define.call(
 		define,
 		this.subtypes as TypesMap,
 		TypeOrTypeName,
 		constructHandlerOrConfig,
 		config
 	);
+	return result;
 };
 
 TypeDescriptor.prototype.lookup = function (
 	this: TypeDescriptorInstance,
 	TypeNestedPath: string
 ) {
-	return lookup.call(
+	const result = lookup.call(
 this.subtypes as TypesMap,
 TypeNestedPath
 	);
+	return result;
 };
 
 odp(
@@ -297,8 +300,9 @@ const isLazyGetter = function (handler: ConstructHandler | LazyTypeGetter): bool
 		// Probe: try to call as a lazy getter. If it succeeds and returns a named
 		// function, it's a lazy getter. Otherwise (throws or returns non-function),
 		// it's a direct handler. The cast is the probe — runtime decides which it is.
-		const result = (handler as LazyTypeGetter)();
-		return result instanceof Function && result.name.length > 0;
+		const lazyResult = (handler as LazyTypeGetter)();
+		const result = lazyResult instanceof Function && lazyResult.name.length > 0;
+		return result;
 	} catch {
 		return false;
 	}
@@ -346,7 +350,7 @@ const createFromDirectHandler = function (
 		(typeof handler.prototype === 'object')
 	) ? handler.prototype : getDefaultPrototype();
 
-	return new TypeDescriptor(
+	const result = new TypeDescriptor(
 		defineOrigin,
 		target,
 		name,
@@ -354,6 +358,7 @@ const createFromDirectHandler = function (
 		proto,
 		config
 	) as unknown as TypeClass;
+	return result;
 };
 
 const createFromLazyGetter = function (
@@ -406,7 +411,7 @@ const createFromLazyGetter = function (
 
 	config.asClass = asClass;
 
-	return new TypeDescriptor(
+	const result = new TypeDescriptor(
 		defineOrigin,
 		target,
 		TypeName,
@@ -414,6 +419,7 @@ const createFromLazyGetter = function (
 		type.prototype,
 		config
 	) as unknown as TypeClass;
+	return result;
 };
 
 // ============================================================
@@ -545,10 +551,11 @@ export const lookup = function (
 	if (!type) {
 		return undefined;
 	}
-	return lookup.call(
+	const result = lookup.call(
 type.subtypes as unknown as TypesMap,
 NextNestedPath
 	);
+	return result;
 
 };
 

package/src/api/utils/index.ts

@@ -2,7 +2,7 @@
 
 import { constants } from '../../constants';
 import { ErrorsTypes } from '../../descriptors/errors';
-import { utils } from '../../utils';
+import { collectConstructors } from '../../utils/collectConstructors';
 
 const {
 	odp,
@@ -13,8 +13,6 @@ const {
 
 const { WRONG_TYPE_DEFINITION, } = ErrorsTypes;
 
-const { collectConstructors } = utils;
-
 import {
 	_getProps, Props 
 } from '../types/Props';
@@ -51,15 +49,14 @@ const getTypeChecker = (TypeName: string) => {
 			// if ( instance instanceof Promise ) {
 			 
 			// @ts-expect-error I'm too lazy for that
-			return instance[ SymbolConstructorName ] === TypeName;
+			const checkResult = instance[ SymbolConstructorName ] === TypeName;
+			return checkResult;
 		}
 
-		const constructors: {
-			string: new () => unknown
-		} = collectConstructors(instance);
+		const constructors = collectConstructors(instance) as Record<string, new () => unknown>;
 		 
-		// @ts-expect-error I'm too lazy for that
-		return constructors[ TypeName ] || false;
+		const constructorResult = constructors[ TypeName ] || false;
+		return constructorResult;
 
 	};
 	return seeker;
@@ -204,7 +201,8 @@ const findSubTypeFromParent = (instance: parentSub | object | undefined, subType
 const isClass = (fn: ConstructHandler) => {
 	
 	const str = String(fn);
-	return str.indexOf('class ') === 0;
+	const result = str.indexOf('class ') === 0;
+	return result;
 
 	/*
 
@@ -253,7 +251,8 @@ const makeErrorModificatorType = (
 	);
 
 	const result = modificatorType();
-	return result as MnemonicaConstructor;
+	const constructorResult = result as MnemonicaConstructor;
+	return constructorResult;
 
 };
 
@@ -269,9 +268,10 @@ const reflectPrimitiveWrappers = (_thisArg: unknown) => {
 			Symbol.toPrimitive,
 			{
 				get () {
-					return () => {
+					const result = () => {
 						return _thisArg;
 					};
+					return result;
 				}
 			}
 		);
@@ -287,9 +287,11 @@ const reflectPrimitiveWrappers = (_thisArg: unknown) => {
 			Symbol.toPrimitive,
 			{
 				get () {
-					return () => {
-						return (_thisArg as String | Number | Boolean).valueOf();
+					const result = () => {
+						const valueResult = (_thisArg as String | Number | Boolean).valueOf();
+						return valueResult;
 					};
+					return result;
 				}
 			}
 		);