mnemonica 1.0.1 → 1.0.6

package/src/utils/collectConstructors.ts

@@ -9,17 +9,19 @@ const {
 } = constants;
 
 const getAdditor = (constructors: string[] | { [index: string]: boolean }) => {
-	return Array.isArray(constructors) ?
+	const result = Array.isArray(constructors) ?
 		(name: string) => {
 			constructors.push(name);
 		} : (name: string) => {
 			constructors[ name ] = true;
 		};
+	return result;
 
 };
 
 const getAccumulator = (asSequence: boolean) => {
-	return asSequence ? [] : {};
+	const result = asSequence ? [] : {};
+	return result;
 };
 
 export const collectConstructors = (self: object, asSequence = false) => {

package/src/utils/exception.ts

@@ -0,0 +1,16 @@
+'use strict';
+
+import exceptionConstructor from '../api/errors/exceptionConstructor';
+
+export const exception = function (instance: object, error: Error, ...args: unknown[]) {
+
+	const target = new.target;
+	const exceptionResult = exceptionConstructor.call(
+		instance,
+		target,
+		error,
+		...args
+	);
+	return exceptionResult;
+
+};

package/src/utils/extract.ts

@@ -3,9 +3,11 @@
 import { ErrorsTypes } from '../descriptors/errors';
 const { WRONG_INSTANCE_INVOCATION } = ErrorsTypes;
 
+import type { Extracted } from '../types';
+
 // import { hop } from './hop';
 
-export const extract = ( instance: object ) => {
+export const extract = <T extends object>( instance: T ): Extracted<T> => {
 
 	// at this situation this check is enough
 	if ( instance !== Object( instance ) ) {
@@ -25,6 +27,7 @@ export const extract = ( instance: object ) => {
 		extracted[ name ] = ( instance as Record<string, unknown> )[ name ];
 	}
 
-	return extracted;
+	const result = extracted as Extracted<T>;
+	return result;
 
 };

package/src/utils/fork.ts

@@ -0,0 +1,57 @@
+'use strict';
+
+import {
+	getProps, Props 
+} from '../api/types/Props';
+import { InstanceCreator } from '../api/types/InstanceCreator';
+import TypesUtils from '../api/utils/index';
+
+const { reflectPrimitiveWrappers } = TypesUtils;
+
+export const fork = <T extends object>(instance: T): (this: object, ...forkArgs: unknown[]) => T => {
+
+	const props = getProps(instance) as Props;
+
+	const {
+		__type__: type,
+		__collection__: collection,
+		__parent__: existentInstance,
+		__args__,
+		__self__,
+	} = props;
+
+	const {
+		isSubType,
+		TypeName
+	} = type;
+
+	const result = 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
+			);
+		}
+
+		const forkResult = forked as T;
+		return forkResult;
+
+	};
+	return result;
+
+};

package/src/utils/index.ts

@@ -1,11 +1,18 @@
 'use strict';
 
-import type { WrappableMethod } from '../types';
+import type {
+	WrappableMethod,
+	UtilsCollection
+} from '../types';
 
 import { collectConstructors } from './collectConstructors';
 import { extract } from './extract';
 import { parent } from './parent';
 import { pick } from './pick';
+import { sibling } from './sibling';
+import { exception } from './exception';
+import { fork } from './fork';
+import { clone } from './clone';
 import { toJSON } from './toJSON';
 import { parse } from './parse';
 import { merge } from './merge';
@@ -16,29 +23,41 @@ const utilsUnWrapped = {
 	pick,
 
 	parent,
+	sibling,
+	exception,
+	fork,
+	clone,
 
 	toJSON,
 
 	parse,
 	merge,
 
-	get collectConstructors () {
-		return collectConstructors;
-	},
+	collectConstructors,
 
 };
 
 const wrapThis = ( method: WrappableMethod ) => {
-	return function ( this: object, instance: object | undefined, ...args: unknown[] ) {
-		const result = method(
-			instance !== undefined ? instance : this,
-			...args 
-		);
-		return result;
+	const result = function ( this: object, instance: object | undefined, ...args: unknown[] ) {
+		const instanceContext = instance !== undefined ? instance : this;
+		let wrapResult: unknown;
+		if ( new.target ) {
+			wrapResult = new (method as unknown as new (...a: unknown[]) => unknown)(
+				instanceContext,
+				...args
+			);
+		} else {
+			wrapResult = method(
+				instanceContext,
+				...args 
+			);
+		}
+		return wrapResult;
 	};
+	return result;
 };
 
-export const utils: { [ index: string ]: CallableFunction } = {
+export const utils = {
 
 	...Object.entries( utilsUnWrapped )
 		.reduce(
@@ -47,9 +66,9 @@ export const utils: { [ index: string ]: CallableFunction } = {
 				methods[ name ] = wrapThis( fn );
 				return methods;
 			},
-			{} 
+			{}
 		),
 
-};
+} as UtilsCollection;
 
 export { defineStackCleaner } from './defineStackCleaner';

package/src/utils/merge.ts

@@ -2,8 +2,18 @@
 
 import { ErrorsTypes } from '../descriptors/errors';
 const { WRONG_ARGUMENTS_USED } = ErrorsTypes;
+import { fork } from './fork';
+import { getProps } from '../api/types/Props';
+import type {
+	Merge,
+	InstanceResult,
+} from '../types';
 
-export const merge = ( a: object, b: object, ...args: unknown[] ): object => {
+export const merge = <A extends object, B extends object>(
+	a: A,
+	b: B,
+	...args: unknown[]
+): InstanceResult<Merge<B, A>> => {
 
 	// at this situation this check is enough
 	if ( a !== Object( a ) ) {
@@ -15,15 +25,17 @@ export const merge = ( a: object, b: object, ...args: unknown[] ): object => {
 		throw new WRONG_ARGUMENTS_USED( 'B should be an object' );
 	}
 
-	const { fork } = a as { fork?: (this: object, ...forkArgs: unknown[]) => unknown };
-	if ( typeof fork !== 'function' ) {
-		throw new WRONG_ARGUMENTS_USED( 'A should have A.fork()' );
+	const props = getProps(a);
+	if (props === undefined) {
+		throw new WRONG_ARGUMENTS_USED('A should be a mnemonica instance');
 	}
 
-	const aa = fork.call(
+	const forked = fork(a);
+	const aa = forked.call(
 		b,
 		...args 
 	);
-	return aa as object;
+	const result = aa as InstanceResult<Merge<B, A>>;
+	return result;
 
 };

package/src/utils/parent.ts

@@ -10,7 +10,7 @@ import {
 // seek for firts parent instance
 // of instance prototype chain
 // with constructors of path
-export const parent = ( instance: object, path?: string ): unknown => {
+export const parent = <T extends object>( instance: T, path?: string ): object | undefined => {
 
 	// at this situation this check is enough
 	if ( instance !== Object( instance ) ) {
@@ -33,10 +33,8 @@ export const parent = ( instance: object, path?: string ): unknown => {
 
 	// seek throuh parent instances
 	// about the fist constructor with this name
-	return name === path ?
-		p : parent(
- p as object,
- path 
-		);
+	const result = name === path ?
+		p : parent( p as object, path );
+	return result;
 
 };

package/src/utils/parse.ts

@@ -14,8 +14,9 @@ const {
 // } = constants;
 
 import { extract } from './extract';
+import type { Parsed } from '../types';
 
-export const parse = ( self: object ) => {
+export const parse = <T extends object>( self: T ): Parsed<T> => {
 
 	if ( !self || !( self as { constructor?: CallableFunction } ).constructor ) {
 		throw new WRONG_MODIFICATION_PATTERN;
@@ -47,7 +48,7 @@ export const parse = ( self: object ) => {
 
 	const { name } = protoConstructor;
 
-	const props = extract( { ...self } as Record<string, unknown> );
+	const props = extract( { ...self } as T );
 	// props.constructor = undefined;
 	delete ( props as { constructor?: unknown } ).constructor;
 
@@ -57,7 +58,7 @@ export const parse = ( self: object ) => {
 	) as Record<string, unknown> );
 	delete ( joint as { constructor?: unknown } ).constructor;
 
-	const parent = protoProto;
+	const parent = protoProto as object | undefined;
 	// TODO: deep parse
 	// let parent;
 	// if ( protoProto[ SymbolConstructorName ] === MNEMONICA ) {
@@ -66,7 +67,7 @@ export const parse = ( self: object ) => {
 	// 	parent = Reflect.getPrototypeOf( protoProto );
 	// }
 
-	const result = {
+	const result: Parsed<T> = {
 
 		name,
 

package/src/utils/pick.ts

@@ -3,7 +3,15 @@
 import { ErrorsTypes } from '../descriptors/errors';
 const { WRONG_INSTANCE_INVOCATION } = ErrorsTypes;
 
-export const pick = ( instance: object, ...args: (string | string[])[] ) => {
+export function pick <T extends object, K extends keyof T> (
+	instance: T,
+	...args: (K | K[])[]
+): { [P in K]: T[P] } & {};
+export function pick <T extends object> (
+	instance: T,
+	...args: (string | string[])[]
+): Record<string, unknown>;
+export function pick ( instance: object, ...args: (string | string[])[] ) {
 
 	// at this situation this check is enough
 	if ( instance !== Object( instance ) ) {
@@ -33,4 +41,4 @@ export const pick = ( instance: object, ...args: (string | string[])[] ) => {
 
 	return picked;
 
-};
+}

package/src/utils/sibling.ts

@@ -0,0 +1,33 @@
+'use strict';
+
+import {
+	getProps,
+	Props
+} from '../api/types/Props';
+
+export const sibling = (instance: object): unknown => {
+
+	const siblings = (SiblingTypeName: string) => {
+		const props = getProps(instance) as Props;
+		const { __collection__: collection, } = props;
+		const answer = collection[ SiblingTypeName ];
+		return answer;
+	};
+
+	const result = new Proxy(
+		siblings,
+		{
+			get (_, prop: string) {
+				const proxyResult = siblings(prop);
+				return proxyResult;
+			},
+			apply (_, __, args,) {
+				const proxyResult = siblings(args[ 0 ]);
+				return proxyResult;
+			}
+		}
+	);
+
+	return result;
+
+};

package/src/utils/toJSON.ts

@@ -1,10 +1,10 @@
 'use strict';
 
 import { extract } from './extract';
-export const toJSON = ( instance: object ) => {
+export const toJSON = <T extends object>( instance: T ) => {
 
 	const extracted = extract( instance );
-	return Object.entries( extracted ).reduce(
+	const result = Object.entries( extracted ).reduce(
 		( o: string, entry: [ string, unknown ] ) => {
 
 			const [ name, _value ] = entry;
@@ -40,5 +40,6 @@ export const toJSON = ( instance: object ) => {
 			/,$/,
 			'}' 
 		);
+	return result;
 
 };