mnemonica 0.9.953 → 0.9.955

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/types/InstanceCreator.d.ts

@@ -1,6 +1,6 @@
 import { ConstructorFunction } from '../../types';
 export declare const InstanceCreator: ConstructorFunction<{
-    getExistentAsyncStack: (existentInstance: any) => any[];
+    getExistentAsyncStack: (existentInstance: import("../utils").asyncStack) => unknown;
     postProcessing: (this: any, continuationOf: any) => void;
     bindMethod: (this: any, instance: any, methodName: string, MethodItself: any) => void;
     bindProtoMethods: (this: any) => void;

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

@@ -1,17 +1,29 @@
-import { TypeModificator } from '../../types';
+export type asyncStack = {
+    __stack__?: string;
+    __type__: {
+        isSubType: boolean;
+    };
+    parent: () => asyncStack;
+};
+type parentSub = {
+    __type__: {
+        subtypes: Map<string, parentSub>;
+    };
+    __parent__: parentSub;
+};
 declare const TypesUtils: {
     isClass: (fn: CallableFunction) => boolean;
-    CreationHandler: (this: any, constructionAnswer: any) => any;
+    CreationHandler: (this: unknown, constructionAnswer: unknown) => unknown;
     getModificationConstructor: (useOldStyle: boolean) => (this: any, ModificatorType: CallableFunction, ModificatorTypePrototype: {
         [index: string]: any;
     }, addProps: CallableFunction) => any;
-    checkProto: (proto: any) => void;
-    getTypeChecker: (TypeName: string) => any;
+    checkProto: (proto: unknown) => void;
+    getTypeChecker: (TypeName: string) => unknown;
     getTypeSplitPath: (path: string) => string[];
-    getExistentAsyncStack: (existentInstance: any) => any[];
+    getExistentAsyncStack: (existentInstance: asyncStack) => unknown;
     checkTypeName: (name: string) => void;
-    findParentSubType: any;
-    makeFakeModificatorType: (TypeName: string, fakeModificator?: TypeModificator<object>) => any;
-    reflectPrimitiveWrappers: (_thisArg: any) => any;
+    findParentSubType: (instance: parentSub, prop: string) => parentSub;
+    makeFakeModificatorType: (TypeName: string, fakeModificator?: () => void) => any;
+    reflectPrimitiveWrappers: (_thisArg: unknown) => unknown;
 };
 export default TypesUtils;

package/build/index.d.ts

@@ -1,20 +1,22 @@
-import { ITypeClass, TypeLookup, IDEF } from './types';
+import { TypeLookup, IDEF } from './types';
 export type { IDEF } from './types';
 export declare const defaultTypes: any;
 type Proto<P, T> = Pick<P, Exclude<keyof P, keyof T>> & T;
-interface IDefinitor<P, IN extends string> {
-    <T, M extends Proto<P, T>, S extends Record<IN, new () => unknown> & M>(this: unknown, TypeName: IN, constructHandler: IDEF<T>, proto?: P, config?: object): {
-        new (): {
-            [key in keyof S]: S[key];
-        };
-        define: IDefinitor<M, IN>;
+type RN = Record<string | symbol, unknown>;
+type SN = Record<string | symbol, new () => unknown>;
+interface IDefinitorInstance<N extends RN, S> {
+    new (): {
+        [key in keyof S]: S[key];
     };
+    define: IDefinitor<N, string>;
 }
-export declare const define: <T, P extends object, N extends Proto<P, T>, ID extends string, S extends Record<ID, new () => unknown> & N>(this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: P | undefined, config?: {}) => {
+interface IDefinitor<P extends RN, SubTypeName extends string> {
+    <PP extends RN, T extends RN, M extends Proto<P, Proto<PP, T>>, S extends SN & M>(this: unknown, TypeName: SubTypeName, constructHandler: IDEF<T>, proto?: PP, config?: object): IDefinitorInstance<M, S>;
+}
+export declare const define: <T extends RN, P extends RN, N extends Proto<P, T>, SubTypeName extends string, NC extends SN, S extends NC & N, R extends {
     new (): { [key in keyof S]: S[key]; };
-    define: IDefinitor<N, ID>;
-};
-export declare const tsdefine: <T>(this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
+    define: IDefinitor<N, SubTypeName>;
+}>(this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: P | undefined, config?: {}) => R;
 export declare const lookup: TypeLookup;
 export declare const mnemonica: {
     [index: string]: unknown;
@@ -24,3 +26,12 @@ export declare const defaultCollection: any;
 export declare const errors: any;
 export { utils } from './utils';
 export { defineStackCleaner } from './utils';
+export declare function apply<E extends RN, T extends RN, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, args: unknown[]): {
+    [key in keyof S]: S[key];
+};
+export declare function call<E extends RN, T extends RN, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, ...args: unknown[]): {
+    [key in keyof S]: S[key];
+};
+export declare function bind<E extends RN, T extends RN, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>): (...args: unknown[]) => {
+    [key in keyof S]: S[key];
+};

package/build/index.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.defaultNamespace = exports.namespaces = exports.createNamespace = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.URANUS = exports.GAIA = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolDefaultNamespace = exports.SymbolReplaceGaia = exports.SymbolGaia = exports.SymbolConstructorName = exports.SymbolSubtypeCollection = exports.mnemonica = exports.lookup = exports.tsdefine = exports.define = exports.defaultTypes = void 0;
+exports.bind = exports.call = exports.apply = exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.defaultNamespace = exports.namespaces = exports.createNamespace = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.URANUS = exports.GAIA = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolDefaultNamespace = exports.SymbolReplaceGaia = exports.SymbolGaia = exports.SymbolConstructorName = exports.SymbolSubtypeCollection = exports.mnemonica = exports.lookup = exports.define = exports.defaultTypes = void 0;
 const constants_1 = require("./constants");
 const { odp } = constants_1.constants;
 const errorsApi = require("./api/errors");
@@ -14,10 +14,6 @@ const define = function (TypeName, constructHandler, proto, config = {}) {
     return types.define(TypeName, constructHandler, proto, config);
 };
 exports.define = define;
-const tsdefine = function (TypeName, constructHandler, proto, config) {
-    return exports.defaultTypes.define(TypeName, constructHandler, proto, config);
-};
-exports.tsdefine = tsdefine;
 exports.lookup = function (TypeNestedPath) {
     const types = checkThis(this) ? exports.defaultTypes : this || exports.defaultTypes;
     return types.lookup(TypeNestedPath);
@@ -40,3 +36,20 @@ var utils_1 = require("./utils");
 Object.defineProperty(exports, "utils", { enumerable: true, get: function () { return utils_1.utils; } });
 var utils_2 = require("./utils");
 Object.defineProperty(exports, "defineStackCleaner", { enumerable: true, get: function () { return utils_2.defineStackCleaner; } });
+function apply(entity, Constructor, args) {
+    const result = Constructor.apply(entity, args);
+    return result;
+}
+exports.apply = apply;
+function call(entity, Constructor, ...args) {
+    const result = Constructor.call(entity, ...args);
+    return result;
+}
+exports.call = call;
+function bind(entity, Constructor) {
+    return (...args) => {
+        const result = Constructor.call(entity, ...args);
+        return result;
+    };
+}
+exports.bind = bind;

package/build/types/index.d.ts

@@ -1,9 +1,14 @@
+type RN = Record<string | symbol, unknown>;
+export type IDEF<T extends RN> = {
+    new (): T;
+} | {
+    (this: T): void;
+};
 export interface ConstructorFunction<ConstructorInstance extends object> {
     new (...args: unknown[]): ConstructorInstance;
     (this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;
     prototype: ConstructorInstance;
 }
-export type TypeModificator<T extends object> = (...args: unknown[]) => ConstructorFunction<T>;
 export type TypeLookup = (this: Map<string, unknown>, TypeNestedPath: string) => TypeClass;
 export type TypeClass = {
     new (...args: unknown[]): unknown;
@@ -12,16 +17,12 @@ export type TypeClass = {
     registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => unknown;
 };
 export type TypeAbsorber = (this: unknown, TypeName: string, constructHandler: CallableFunction, proto?: object, config?: object) => TypeClass;
-export type IDEF<T> = {
-    new (): T;
-} | {
-    (this: T): void;
-};
-export type ITypeAbsorber<T> = (this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
-export interface ITypeClass<T> {
+export type ITypeAbsorber<T extends RN> = (this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
+export interface ITypeClass<T extends RN> {
     new (...args: unknown[]): T;
     (this: T, ...args: unknown[]): T;
     define: ITypeAbsorber<T>;
     lookup: TypeLookup;
     registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => unknown;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mnemonica",
-	"version": "0.9.953",
+	"version": "0.9.955",
 	"description": "abstract technique that aids information retention : instance inheritance system",
 	"type": "commonjs",
 	"main": "./build/index.js",
@@ -63,25 +63,25 @@
 	},
 	"homepage": "https://github.com/wentout/mnemonica#readme",
 	"devDependencies": {
-		"@types/jest": "^29.5.3",
-		"@types/node": "^18.17.4",
+		"@types/jest": "^29.5.7",
+		"@types/node": "^18.18.8",
 		"@typescript-eslint/eslint-plugin": "^5.62.0",
 		"@typescript-eslint/parser": "^5.62.0",
-		"chai": "^4.3.7",
-		"eslint": "^8.46.0",
-		"eslint-plugin-import": "^2.28.0",
-		"eslint-plugin-mocha": "^10.1.0",
+		"chai": "^4.3.10",
+		"eslint": "^8.52.0",
+		"eslint-plugin-import": "^2.29.0",
+		"eslint-plugin-mocha": "^10.2.0",
 		"eslint-plugin-no-arrow-this": "^1.2.0",
 		"husky": "^8.0.3",
-		"jest": "^29.6.2",
+		"jest": "^29.7.0",
 		"json5": "^2.2.3",
-		"lint-staged": "^13.2.3",
+		"lint-staged": "^13.3.0",
 		"mocha": "^10.2.0",
 		"mocha-lcov-reporter": "^1.3.0",
 		"nyc": "^15.1.0",
 		"ts-jest": "^29.1.1",
-		"typescript": "^5.1.6",
-		"yaml": "^2.3.1"
+		"typescript": "^5.2.2",
+		"yaml": "^2.3.4"
 	},
 	"engines": {
 		"node": ">=14"