mnemonica 0.9.9977 → 0.9.99778

package/README.md

@@ -815,8 +815,372 @@ defaultTypes[SymbolConfig].blockErrors = false;
 
 ```
 
+---
+
+# API Reference
+
+## Core Functions
+
+### `define(typeName, constructHandler, config?)`
+Defines a new type constructor. Returns a TypeClass that can be used to create instances.
+
+### `lookup(typeNestedPath)`
+Looks up a type by its nested path (e.g., `'SomeType.SomeNestedType'`).
+
+### `apply(entity, Constructor, args?)`
+Applies a constructor to an entity with the given arguments array.
+
+### `call(entity, Constructor, ...args)`
+Calls a constructor on an entity with spread arguments.
+
+### `bind(entity, Constructor)`
+Binds a constructor to an entity, returning a function that can be called later.
+
+### `registerHook(Constructor, hookType, callback)`
+Registers a hook for a specific constructor.
+
+## Type Management
+
+### `defaultTypes`
+The default types collection. All types defined with the top-level `define()` function are stored here.
+
+### `createTypesCollection()`
+Creates a new isolated types collection.
+
+```js
+const myCollection = createTypesCollection();
+const MyType = myCollection.define('MyType', function() {});
+```
+
+### `getProps(instance)` / `setProps(instance, values)`
+Get or set internal properties of an instance.
+
+```js
+const { getProps, setProps } = require('mnemonica');
+const props = getProps(instance);
+console.log(props.__type__, props.__args__);
+```
+
+## Instance Methods
+
+All mnemonica instances have the following methods:
+
+### `.extract()`
+Extracts all inherited properties into a single flat object.
+
+### `.pick(...keys)` / `.pick([keys])`
+Picks specific properties from the instance and its inheritance chain.
+
+```js
+const picked = instance.pick('email', 'password');
+// or
+const picked = instance.pick(['email', 'password']);
+```
+
+### `.parent(constructorName?)`
+Gets the parent instance. If `constructorName` is provided, walks up the chain to find that specific parent.
+
+```js
+const immediateParent = instance.parent();
+const specificParent = instance.parent('UserType');
+```
+
+### `.clone`
+Property that returns a cloned instance (same as `.fork()` with no arguments).
+
+### `.fork(...args)`
+Creates a forked instance from the same parent, optionally with different arguments.
+
+```js
+const forked = instance.fork(); // same args
+const forkedWithNewArgs = instance.fork('new', 'args');
+```
+
+### `.fork.call(thisArg, ...args)` / `.fork.apply(thisArg, args)`
+Forks with a different `this` context (useful for DAG construction).
+
+```js
+const dagInstance = instanceA.fork.call(instanceB, 'args');
+```
+
+### `.exception(error, ...args)`
+Creates an exception instance from the current instance. Useful for typed errors.
+
+```js
+const error = someInstance.exception(new Error('Something went wrong'));
+throw error;
+```
+
+### `.sibling(typeName)` / `.sibling.TypeName`
+Access sibling types from the same collection.
+
+```js
+const siblingType = instance.sibling('OtherType');
+const siblingInstance = new siblingType();
+// or
+const sibling = instance.sibling.OtherType;
+```
+
+## Utils
+
+### `utils.extract(instance)`
+Standalone extract function.
+
+### `utils.pick(instance, ...keys)`
+Standalone pick function.
+
+### `utils.parent(instance, constructorName?)`
+Standalone parent function.
+
+### `utils.parse(instance)`
+Parses an instance structure, returning detailed information about:
+- `name`: constructor name
+- `props`: extracted properties
+- `self`: the instance itself
+- `proto`: prototype object
+- `joint`: prototype properties
+- `parent`: parent prototype
+
+```js
+const { utils: { parse } } = require('mnemonica');
+const parsed = parse(instance);
+```
+
+### `utils.merge(A, B, ...args)`
+Merges two instances using fork semantics.
+
+```js
+const merged = merge(instanceA, instanceB, 'args');
+```
+
+### `utils.toJSON(instance)`
+Serializes an instance to JSON.
+
+```js
+const json = utils.toJSON(instance);
+```
+
+### `utils.collectConstructors(instance, flat?)`
+Collects all constructors in the instance's prototype chain.
+
+```js
+const constructors = utils.collectConstructors(instance, true);
+```
+
+## Instance Properties (via getProps)
+
+All instances have non-enumerable internal properties accessible via `getProps()`:
+
+| Property | Description |
+|----------|-------------|
+| `.__args__` | Arguments used for instance creation |
+| `.__type__` | Type definition object |
+| `.__parent__` | Parent instance reference |
+| `.__subtypes__` | Map of available subtypes |
+| `.__collection__` | Types collection where type was defined |
+| `.__stack__` | Stack trace (if `submitStack: true` in config) |
+| `.__creator__` | Instance creator reference |
+| `.__timestamp__` | Creation timestamp (ms since epoch) |
+| `.__self__` | Self reference to the instance |
+
+## Hooks
+
+### Hook Types
+
+- `'preCreation'` - Called before instance creation
+- `'postCreation'` - Called after instance creation
+- `'creationError'` - Called when instance creation throws an error
+
+### `type.registerHook(hookType, callback)`
+Register a hook on a specific type.
+
+```js
+MyType.registerHook('preCreation', (hookData) => {
+	console.log('Creating:', hookData.TypeName);
+});
+```
+
+### `collection.registerHook(hookType, callback)`
+Register a hook on a types collection.
+
+```js
+defaultTypes.registerHook('postCreation', (hookData) => {
+	console.log('Created:', hookData.inheritedInstance.constructor.name);
+});
+```
+
+### `collection.registerFlowChecker(callback)`
+Register a flow checker that runs before hooks.
+
+```js
+defaultTypes.registerFlowChecker((opts) => {
+	// Perform validation or logging
+	console.log('Flow check:', opts.TypeName);
+});
+```
+
+### Hook Data Structure
+
+```js
+{
+	TypeName: string,              // Constructor name
+	argumentsOfTypeModificator: [], // Arguments passed
+	instanceUsedForInheritance: {}, // Parent instance
+	inheritedInstance: {}          // Newly created instance (postCreation only)
+}
+```
+
+## Error Handling
+
+### `errors` Object
+
+All mnemonica errors are accessible via the `errors` export:
+
+```js
+const { errors } = require('mnemonica');
+
+// Available error types:
+errors.BASE_MNEMONICA_ERROR
+errors.WRONG_TYPE_DEFINITION
+errors.WRONG_INSTANCE_INVOCATION
+errors.WRONG_MODIFICATION_PATTERN
+errors.ALREADY_DECLARED
+errors.TYPENAME_MUST_BE_A_STRING
+errors.HANDLER_MUST_BE_A_FUNCTION
+errors.WRONG_ARGUMENTS_USED
+errors.WRONG_HOOK_TYPE
+errors.MISSING_HOOK_CALLBACK
+errors.MISSING_CALLBACK_ARGUMENT
+errors.FLOW_CHECKER_REDEFINITION
+errors.OPTIONS_ERROR
+errors.WRONG_STACK_CLEANER
+```
+
+### Exception Instances
+
+When you create an exception using `instance.exception()`, the resulting error has special properties:
+
+```js
+const error = instance.exception(new Error('Original error'));
+
+// Properties:
+error.originalError    // The original error
+error.exceptionReason  // { methodName, ... }
+error.BaseStack        // Base stack trace
+error.parse()          // Parse the exception structure
+error.extract()        // Extract properties from the exception
+```
+
+## Symbols
+
+Mnemonica exports the following symbols:
+
+```js
+const {
+	SymbolParentType,           // Parent type symbol
+	SymbolConstructorName,      // Constructor name symbol
+	SymbolDefaultTypesCollection, // Default collection symbol
+	SymbolConfig                 // Config symbol
+} = require('mnemonica');
+```
+
+## TypeScript Types
+
+The following types are exported for TypeScript users:
+
+```typescript
+import {
+	IDEF,                    // Constructor function type
+	ConstructorFunction,     // Constructor with prototype
+	TypeLookup,              // Lookup function type
+	TypeClass,               // Type class interface
+	TypeAbsorber,            // Type absorber type
+	ITypeClass,              // Typed class interface
+	IDefinitorInstance,      // Definitor instance type
+	hooksTypes,              // 'preCreation' | 'postCreation' | 'creationError'
+	hooksOpts,               // Hook options type
+	hook,                    // Hook callback type
+	constructorOptions       // Configuration options type
+} from 'mnemonica';
+```
+
+## Decorator API
+
+The `decorate` function provides TypeScript decorator support:
+
+### Basic Usage
+
+```typescript
+import { decorate } from 'mnemonica';
+
+@decorate()
+class MyClass {
+	field: number;
+	constructor() {
+		this.field = 123;
+	}
+}
+
+const instance = new MyClass();
+```
+
+### With Configuration
+
+```typescript
+@decorate({ strictChain: false, blockErrors: true })
+class MyClass {
+	// ...
+}
+```
+
+### Nested Decoration
+
+```typescript
+@decorate()
+class ParentClass {
+	// ...
+}
+
+@decorate(ParentClass, { strictChain: false })
+class ChildClass {
+	// ...
+}
+
+const parent = new ParentClass();
+const child = apply(parent, ChildClass);
+```
+
+### Decorator as Function
+
+Decorated classes can be used as decorators themselves:
+
+```typescript
+@decorate()
+class Base {
+	// ...
+}
+
+@Base()  // Use Base as a decorator
+class Extended {
+	// ...
+}
+
+const base = new Base();
+const extended = apply(base, Extended);
+```
+
+## Configuration Options Reference
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `strictChain` | `boolean` | `true` | Only allow sub-instances from current type, not up-nested |
+| `blockErrors` | `boolean` | `true` | Disallow instance construction if error in prototype chain |
+| `submitStack` | `boolean` | `false` | Collect stack trace as `__stack__` property |
+| `awaitReturn` | `boolean` | `true` | Ensure `await new Constructor()` returns value |
+| `ModificationConstructor` | `Function` | internal | Custom modification constructor |
+| `asClass` | `boolean` | auto | Force class mode (auto-detected by default) |
 
-# finally
+## finally
 
 So, now you can craft as much types as you wish, combine them, re-define them and spend much more time playing with them:
 

package/build/api/types/TypeProxy.js

@@ -52,18 +52,28 @@ exports.TypeProxy.prototype.set = function (__, name, value) {
     type.define(TypeName, Constructor);
     return true;
 };
-exports.TypeProxy.prototype.apply = function (__, Uranus, args) {
+const subTypeApply = (parentType, config, ...args) => {
+    const decorator = function (cstr) {
+        const { name } = cstr;
+        return parentType.define(name, cstr, config, ...args);
+    };
+    return decorator;
+};
+const primaryTypeApply = function (__, Uranus, args) {
     const type = this.__type__;
-    let instance = null;
-    if (Uranus) {
-        const InstanceCreatorProxy = new exports.TypeProxy(type, Uranus);
-        instance = new InstanceCreatorProxy(...args);
-    }
-    else {
-        instance = this.construct(null, args);
+    if (Uranus === undefined) {
+        const decorator = subTypeApply(type, args[0]);
+        return decorator;
     }
+    const InstanceCreatorProxy = new exports.TypeProxy(type, Uranus);
+    const instance = new InstanceCreatorProxy(...args);
     return instance;
 };
+Object.defineProperty(exports.TypeProxy.prototype, 'apply', {
+    get() {
+        return primaryTypeApply;
+    }
+});
 exports.TypeProxy.prototype.construct = function (__, args) {
     const { __type__: type, Uranus } = this;
     const uranus = type.isSubType ? getDefaultPrototype() : Uranus;
@@ -71,4 +81,4 @@ exports.TypeProxy.prototype.construct = function (__, args) {
     const instance = new InstanceCreator_1.InstanceCreator(type, mnemosyneProxy, args);
     return instance;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TypeProxy.js","sourceRoot":"","sources":["../../../src/api/types/TypeProxy.ts"],"names":[],"mappings":"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","sourcesContent":["\n'use strict';\n\nimport { constructorOptions, ConstructorFunction } from '../../types';\n\nimport TypesUtils from '../utils';\nconst {\n\tcheckProto,\n} = TypesUtils;\n\nimport { hop } from '../../utils/hop';\n\nimport { ErrorsTypes } from '../../descriptors/errors';\nconst {\n\tWRONG_TYPE_DEFINITION,\n} = ErrorsTypes;\n\nimport mnemosynes from './Mnemosyne';\nconst { createMnemosyne, getDefaultPrototype } = mnemosynes;\n\nimport { InstanceCreator } from './InstanceCreator';\n\nimport { /* _getProps, Props, */ TypeDef } from './Props';\n\nexport const TypeProxy = function (__type__: any, Uranus: unknown) {\n\tObject.assign(this, {\n\t\t__type__,\n\t\tUranus\n\t});\n\tconst typeProxy = new Proxy(InstanceCreator, this);\n\treturn typeProxy;\n} as ConstructorFunction<any>;\n\nTypeProxy.prototype.get = function (target: any, prop: keyof TypeDef) {\n\n\t// const props = _getProps(this) as Props;\n\n\tconst {\n\t\t__type__: type\n\t} = this;\n\n\t// prototype of proxy\n\t// const instance = Reflect.getPrototypeOf(receiver);\n\n\tif (prop === 'prototype') {\n\t\treturn type.proto;\n\t}\n\n\tconst propDeclaration = type[ prop ];\n\tif (propDeclaration) {\n\t\treturn propDeclaration;\n\t}\n\n\t// used for existent props with value\n\t// undefined || null || false\n\tif (hop(type, prop)) {\n\t\treturn propDeclaration;\n\t}\n\n\t// SomeType.SomeSubType\n\tif (type.subtypes.has(prop)) {\n\t\treturn type.subtypes.get(prop);\n\t}\n\n\treturn Reflect.get(target, prop);\n\n};\n\nTypeProxy.prototype.set = function (__: any, name: string, value: any) {\n\n\tconst {\n\t\t__type__: type\n\t} = this;\n\n\t// is about setting a prototype to Type\n\tif (name === 'prototype') {\n\t\tcheckProto(value);\n\t\tObject.assign(type.proto, value);\n\t\treturn true;\n\t}\n\n\tif (typeof name !== 'string' || !name.length) {\n\t\tthrow new WRONG_TYPE_DEFINITION('should use non empty string as TypeName');\n\t}\n\n\tif (typeof value !== 'function') {\n\t\tthrow new WRONG_TYPE_DEFINITION('should use function for type definition');\n\t}\n\n\tconst TypeName = name;\n\tconst Constructor = value;\n\n\ttype.define(TypeName, Constructor);\n\treturn true;\n\n};\n\n\n// share decorator from primary type\nconst subTypeApply = (\n\tparentType: unknown,\n\tconfig?: constructorOptions,\n\t...args: unknown[]\n) => {\n\t// const decorator = function <T extends { new (): unknown }>(cstr: T, s?: ClassDecoratorContext<T>): T {\n\tconst decorator = function <T extends { new (): unknown }>(cstr: T): T {\n\t\t// const name = typeof s === 'object' ? s.name : cstr.constructor.name;\n\t\tconst { name } = cstr;\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\treturn parentType.define(name, cstr, config, ...args) as unknown as T;\n\t};\n\treturn decorator;\n};\n\n// replace instance prototype\nconst primaryTypeApply = function (\n\tthis: InstanceType<typeof TypeProxy>,\n\t// proxy target\n\t__: unknown,\n\tUranus: unknown,\n\targs: [constructorOptions, ...unknown[]],\n) {\n\tconst type = this.__type__;\n\t// case of decorator like usage\n\tif (Uranus === undefined) {\n\t\t// so instead of\n\t\t// instance = this.construct(null, args);\n\t\t// we will return decorator\n\t\tconst decorator = subTypeApply(type, args[ 0 ]);\n\t\treturn decorator;\n\t}\n\n\t// this is the scenario, when we .call or .apply or .bind\n\t// our PrimaryType whick is === instance of current TypeProxy\n\tconst InstanceCreatorProxy = new TypeProxy(type, Uranus);\n\tconst instance = new InstanceCreatorProxy(...args);\n\treturn instance;\n};\n\nObject.defineProperty(TypeProxy.prototype, 'apply', {\n\tget () {\n\t\t// const type = this.__type__;\n\t\treturn primaryTypeApply;\n\t\t// const answer = !type.isSubType ? primaryTypeApply : \n\t\t// \t(__: unknown, ___: unknown, config?: constructorOptions, ...args: unknown[]) => {\n\t\t// \t\treturn subTypeApply(type, config, ...args);\n\t\t// \t};\n\t\t// return answer;\n\t}\n});\n\n\n// this always is initial type creation ...\n// so no way to invoke this otherwise than direct type call\nTypeProxy.prototype.construct = function (__: unknown, args: unknown[]) {\n\n\t// new.target id equal with target here\n\n\tconst {\n\t\t__type__: type,\n\t\tUranus\n\t} = this;\n\n\t// so this is a direct Sub-Type invocation\n\t// having no existentInstance created earlier\n\t// then we should rely on that somehow\n\tconst uranus = type.isSubType ? getDefaultPrototype() : Uranus;\n\n\t// \"this\" argument may be passed for tracking why something happened\n\t// but uncomment it there in createMnemosyne if needed\n\t// const mnemosyneProxy = createMnemosyne(uranus, this);\n\tconst mnemosyneProxy = createMnemosyne(uranus);\n\tconst instance = new InstanceCreator(type, mnemosyneProxy, args);\n\n\t// const instance = new InstanceCreator(type, null, args);\n\treturn instance;\n\n};\n"]}

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

@@ -5,7 +5,7 @@ export type asyncStack = {
     };
     parent: () => asyncStack;
 };
-type parentSub = {
+export type parentSub = {
     __type__: {
         subtypes: Map<string, parentSub>;
     };
@@ -21,7 +21,7 @@ declare const TypesUtils: {
     getTypeSplitPath: (path: string) => string[];
     getExistentAsyncStack: (existentInstance: asyncStack) => unknown;
     checkTypeName: (name: string) => void;
-    findSubTypeFromParent: (instance: parentSub, subType: string) => parentSub | undefined;
+    findSubTypeFromParent: (instance: parentSub, subType: string) => parentSub | null;
     makeFakeModificatorType: (TypeName: string, fakeModificator?: () => void) => any;
     reflectPrimitiveWrappers: (_thisArg: unknown) => unknown;
 };

package/build/api/utils/index.js

@@ -89,11 +89,16 @@ const checkTypeName = (name) => {
 const findSubTypeFromParent = (instance, subType) => {
     let subtype = null;
     const props = (0, Props_1._getProps)(instance);
-    if (props.__type__.subtypes.has(subType)) {
-        subtype = props.__type__.subtypes.get(subType);
-        return subtype;
+    if (props) {
+        if (props.__type__.subtypes.has(subType)) {
+            const _subtype = props.__type__.subtypes.get(subType);
+            subtype = _subtype;
+        }
+        else {
+            subtype = findSubTypeFromParent(props.__parent__, subType);
+        }
     }
-    return findSubTypeFromParent(props.__parent__, subType);
+    return subtype;
 };
 const isClass = (fn) => {
     const str = String(fn);
@@ -142,4 +147,4 @@ const TypesUtils = {
     reflectPrimitiveWrappers,
 };
 exports.default = TypesUtils;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/utils/index.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport { constants } from '../../constants';\nimport { ErrorsTypes } from '../../descriptors/errors';\nimport { utils } from '../../utils';\n\nconst {\n\todp,\n\tSymbolConstructorName,\n\tMNEMONICA,\n\tMNEMOSYNE,\n} = constants;\n\nconst {\n\tWRONG_TYPE_DEFINITION,\n} = ErrorsTypes;\n\nconst {\n\tcollectConstructors\n} = utils;\n\nimport { _getProps, Props } from '../types/Props';\n\nconst CreationHandler = function (this: object & { constructor: NewableFunction }, constructionAnswer: unknown) {\n\t// standard says :\n\t// if constructor returns something\n\t// then this is a toy\n\t// we have to play with\n\t// respectively\n\t// so we will not follow the rule\n\t// if (constructionAnswer instanceof types[TypeName]) {\n\t// and instead follow the line below\n\n\t// but if it is not an instace of Object ... so ...\n\t// if ( constructionAnswer instanceof Object )\n\t// if (constructionAnswer instanceof this.constructor)\n\t// will fall the on post processing\n\treturn constructionAnswer;\n\n\t// TODO: this check was not covered with tests\n\t// if (this instanceof Promise) {\n\t// \treturn this;\n\t// }\n};\n\nimport compileNewModificatorFunctionBody from '../types/compileNewModificatorFunctionBody';\n\nconst checkProto = (proto: unknown) => {\n\tif (!(proto instanceof Object)) {\n\t\tthrow new WRONG_TYPE_DEFINITION('expect prototype to be an object');\n\t}\n};\n\nconst getTypeChecker = (TypeName: string) => {\n\tconst seeker: unknown = (instance: object) => {\n\n\t\tif (typeof instance !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\t \n\t\tif (!instance!.constructor) {\n\t\t\treturn false;\n\t\t}\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tif (Reflect.getPrototypeOf(instance).constructor.name === 'Promise') {\n\t\t\t// if ( instance instanceof Promise ) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t\t// @ts-ignore\n\t\t\treturn instance[ SymbolConstructorName ] === TypeName;\n\t\t}\n\n\t\tconst constructors: {\n\t\t\tstring: new () => unknown\n\t\t} = collectConstructors(instance);\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\treturn constructors[ TypeName ] || false;\n\n\t};\n\treturn seeker;\n};\n\nconst getTypeSplitPath = (path: string) => {\n\tconst split = path\n\t\t// beautifull names\n\t\t.replace(/\\n|\\t| /g, '')\n\t\t.replace(/\\[(\\w+)\\]/g, '.$1')\n\t\t.replace(/^\\./, '')\n\t\t.split(/\\.|\\/|:/);\n\treturn split;\n};\n\nexport type asyncStack = {\n\t__stack__?: string\n\t__type__: {\n\t\tisSubType: boolean\n\t}\n\tparent: () => asyncStack\n}\n\nconst getExistentAsyncStack = (existentInstance: asyncStack): unknown => {\n\n\tconst stack = [];\n\tlet proto = existentInstance;\n\n\twhile (proto) {\n\n\t\tconst props = _getProps(proto) as Props;\n\n\t\tif (!props.__stack__) {\n\t\t\tbreak;\n\t\t}\n\n\t\tconst pstack = props\n\t\t\t.__stack__\n\t\t\t.split('\\n')\n\t\t\t.reduce((arr: string[], line: string) => {\n\t\t\t\tif (line.length) {\n\t\t\t\t\tarr.push(line);\n\t\t\t\t}\n\t\t\t\treturn arr;\n\t\t\t}, []);\n\n\t\tproto = proto.parent();\n\n\t\tconst protoProps = _getProps(proto) as Props;\n\n\t\tif (proto && protoProps && protoProps.__type__) {\n\n\t\t\tif (protoProps.__type__.isSubType) {\n\t\t\t\tstack.push(...pstack.slice(0, 1));\n\t\t\t} else {\n\t\t\t\tstack.push(...pstack);\n\t\t\t}\n\n\t\t} else {\n\t\t\tstack.push(...pstack);\n\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn stack;\n\n};\n\nconst forbiddenNames = [ MNEMONICA, MNEMOSYNE ];\n\nconst checkTypeName = (name: string) => {\n\n\tif (!name.length) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName must not be empty');\n\t}\n\n\tif (name[ 0 ] !== name[ 0 ].toUpperCase()) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName should start with Uppercase Letter');\n\t}\n\n\tif (forbiddenNames.includes(name)) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName of reserved keyword');\n\t}\n\n};\n\ntype parentSub = {\n\t__type__: {\n\t\tsubtypes: Map<string, parentSub>\n\t}\n\t__parent__: parentSub\n}\n\nconst findSubTypeFromParent = (instance: parentSub, subType: string): parentSub | undefined => {\n\tlet subtype = null;\n\n\t// if (!instance.__subtypes__) {\n\n\t// if ( !instance.__type__ ) {\n\t// \t// mocha + chai makes .inspect 4 Shaper class\n\t// \t// or .showDiff if something wrong with constructor\n\t// \t// debugger;\n\t// \treturn null;\n\t// }\n\n\tconst props = _getProps(instance) as Props;\n\n\tif (props.__type__.subtypes.has(subType)) {\n\t\tsubtype = props.__type__.subtypes.get(subType);\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\treturn subtype;\n\t}\n\treturn findSubTypeFromParent(props.__parent__, subType);\n};\n\n// const isClass = ( functionPointer: CallableFunction ) => {\n// \tconst value = Function.prototype.toString.call( functionPointer );\n// \treturn /^\\s*class\\s+/.test( value.trim() );\n// };\n\n// accordingly to the gist from here:\n// https://gist.github.com/wentout/ea3afe9c822a6b6ef32f9e4f3e98b1ba\nconst isClass = (fn: CallableFunction) => {\n\t\n\tconst str = String(fn);\n\treturn str.indexOf('class ') === 0;\n\n\t/*\n\n\t// not necessary to check fn for typeof\n\t// because of other checks made before\n\t// if (typeof fn !== 'function') {\n\t// \treturn false;\n\t// }\n\n\t// seemingly\n\t// class prototype is always object\n\tif (!(fn.prototype instanceof Object)) {\n\t\treturn false;\n\t}\n\t// but only if not augmented\n\n\t// class prototype.constructor cannot be re-defined (usually)\n\t// but for functions user may re-assign it easily\n\t// just assigning the way .prototype = {}\n\t// and they 99.9% do this, cause nobody cares\n\t// but we are checking if this is class, so it works ...\n\tif (fn.prototype.constructor !== fn) {\n\t\treturn false;\n\t}\n\n\t// and the most unknown thing is that,\n\t// cause for functions it it writeable )))\n\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\treturn Reflect.getOwnPropertyDescriptor(fn, 'prototype')!.writable === false;\n\n\t*/\n};\n\nconst makeFakeModificatorType = (\n\tTypeName: string,\n\tfakeModificator = function () { }\n) => {\n\n\tconst modificatorBody = compileNewModificatorFunctionBody(TypeName);\n\n\tconst modificatorType = modificatorBody(\n\t\tfakeModificator,\n\t\tCreationHandler,\n\t\tSymbolConstructorName\n\t);\n\n\treturn modificatorType();\n\n};\n\n\n// TODO: .valueOf(), .toString() ???\nconst reflectPrimitiveWrappers = (_thisArg: unknown) => {\n\tlet thisArg = _thisArg;\n\n\tif (_thisArg === null) {\n\t\tthisArg = Object.create(null);\n\t\todp(thisArg, Symbol.toPrimitive, {\n\t\t\tget () {\n\t\t\t\treturn () => {\n\t\t\t\t\treturn _thisArg;\n\t\t\t\t};\n\t\t\t}\n\t\t});\n\t}\n\n\tif (\n\t\t_thisArg instanceof Number ||\n\t\t_thisArg instanceof Boolean ||\n\t\t_thisArg instanceof String\n\t) {\n\t\todp(thisArg, Symbol.toPrimitive, {\n\t\t\tget () {\n\t\t\t\treturn () => {\n\t\t\t\t\treturn _thisArg.valueOf();\n\t\t\t\t};\n\t\t\t}\n\t\t});\n\t}\n\n\treturn thisArg;\n};\n\nconst TypesUtils = {\n\tisClass,\n\tCreationHandler,\n\tcheckProto,\n\tgetTypeChecker,\n\tgetTypeSplitPath,\n\tgetExistentAsyncStack,\n\tcheckTypeName,\n\tfindSubTypeFromParent,\n\tmakeFakeModificatorType,\n\treflectPrimitiveWrappers,\n};\n\nexport default TypesUtils;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/utils/index.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict';\n\nimport { constants } from '../../constants';\nimport { ErrorsTypes } from '../../descriptors/errors';\nimport { utils } from '../../utils';\n\nconst {\n\todp,\n\tSymbolConstructorName,\n\tMNEMONICA,\n\tMNEMOSYNE,\n} = constants;\n\nconst {\n\tWRONG_TYPE_DEFINITION,\n} = ErrorsTypes;\n\nconst {\n\tcollectConstructors\n} = utils;\n\nimport { _getProps, Props } from '../types/Props';\n\nconst CreationHandler = function (this: object & { constructor: NewableFunction }, constructionAnswer: unknown) {\n\t// standard says :\n\t// if constructor returns something\n\t// then this is a toy\n\t// we have to play with\n\t// respectively\n\t// so we will not follow the rule\n\t// if (constructionAnswer instanceof types[TypeName]) {\n\t// and instead follow the line below\n\n\t// but if it is not an instace of Object ... so ...\n\t// if ( constructionAnswer instanceof Object )\n\t// if (constructionAnswer instanceof this.constructor)\n\t// will fall the on post processing\n\treturn constructionAnswer;\n\n\t// TODO: this check was not covered with tests\n\t// if (this instanceof Promise) {\n\t// \treturn this;\n\t// }\n};\n\nimport compileNewModificatorFunctionBody from '../types/compileNewModificatorFunctionBody';\n\nconst checkProto = (proto: unknown) => {\n\tif (!(proto instanceof Object)) {\n\t\tthrow new WRONG_TYPE_DEFINITION('expect prototype to be an object');\n\t}\n};\n\nconst getTypeChecker = (TypeName: string) => {\n\tconst seeker: unknown = (instance: object) => {\n\n\t\tif (typeof instance !== 'object') {\n\t\t\treturn false;\n\t\t}\n\n\t\t \n\t\tif (!instance!.constructor) {\n\t\t\treturn false;\n\t\t}\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tif (Reflect.getPrototypeOf(instance).constructor.name === 'Promise') {\n\t\t\t// if ( instance instanceof Promise ) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t\t// @ts-ignore\n\t\t\treturn instance[ SymbolConstructorName ] === TypeName;\n\t\t}\n\n\t\tconst constructors: {\n\t\t\tstring: new () => unknown\n\t\t} = collectConstructors(instance);\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\treturn constructors[ TypeName ] || false;\n\n\t};\n\treturn seeker;\n};\n\nconst getTypeSplitPath = (path: string) => {\n\tconst split = path\n\t\t// beautifull names\n\t\t.replace(/\\n|\\t| /g, '')\n\t\t.replace(/\\[(\\w+)\\]/g, '.$1')\n\t\t.replace(/^\\./, '')\n\t\t.split(/\\.|\\/|:/);\n\treturn split;\n};\n\nexport type asyncStack = {\n\t__stack__?: string\n\t__type__: {\n\t\tisSubType: boolean\n\t}\n\tparent: () => asyncStack\n}\n\nconst getExistentAsyncStack = (existentInstance: asyncStack): unknown => {\n\n\tconst stack = [];\n\tlet proto = existentInstance;\n\n\twhile (proto) {\n\n\t\tconst props = _getProps(proto) as Props;\n\n\t\tif (!props.__stack__) {\n\t\t\tbreak;\n\t\t}\n\n\t\tconst pstack = props\n\t\t\t.__stack__\n\t\t\t.split('\\n')\n\t\t\t.reduce((arr: string[], line: string) => {\n\t\t\t\tif (line.length) {\n\t\t\t\t\tarr.push(line);\n\t\t\t\t}\n\t\t\t\treturn arr;\n\t\t\t}, []);\n\n\t\tproto = proto.parent();\n\n\t\tconst protoProps = _getProps(proto) as Props;\n\n\t\tif (proto && protoProps && protoProps.__type__) {\n\n\t\t\tif (protoProps.__type__.isSubType) {\n\t\t\t\tstack.push(...pstack.slice(0, 1));\n\t\t\t} else {\n\t\t\t\tstack.push(...pstack);\n\t\t\t}\n\n\t\t} else {\n\t\t\tstack.push(...pstack);\n\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn stack;\n\n};\n\nconst forbiddenNames = [ MNEMONICA, MNEMOSYNE ];\n\nconst checkTypeName = (name: string) => {\n\n\tif (!name.length) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName must not be empty');\n\t}\n\n\tif (name[ 0 ] !== name[ 0 ].toUpperCase()) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName should start with Uppercase Letter');\n\t}\n\n\tif (forbiddenNames.includes(name)) {\n\t\tthrow new WRONG_TYPE_DEFINITION('TypeName of reserved keyword');\n\t}\n\n};\n\nexport type parentSub = {\n\t__type__: {\n\t\tsubtypes: Map<string, parentSub>\n\t}\n\t__parent__: parentSub\n}\n\nconst findSubTypeFromParent = (instance: parentSub, subType: string): parentSub | null => {\n\tlet subtype = null;\n\n\tconst props = _getProps(instance) as Props;\n\n\tif (props) {\n\t\tif(props.__type__.subtypes.has(subType)) {\n\t\t\tconst _subtype = props.__type__.subtypes.get(subType);\n\t\t\tsubtype = _subtype;\n\t\t} else {\n\t\t\tsubtype = findSubTypeFromParent(props.__parent__, subType);\n\t\t}\n\t}\n\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t// @ts-ignore\n\treturn subtype;\n};\n\n// const isClass = ( functionPointer: CallableFunction ) => {\n// \tconst value = Function.prototype.toString.call( functionPointer );\n// \treturn /^\\s*class\\s+/.test( value.trim() );\n// };\n\n// accordingly to the gist from here:\n// https://gist.github.com/wentout/ea3afe9c822a6b6ef32f9e4f3e98b1ba\nconst isClass = (fn: CallableFunction) => {\n\t\n\tconst str = String(fn);\n\treturn str.indexOf('class ') === 0;\n\n\t/*\n\n\t// not necessary to check fn for typeof\n\t// because of other checks made before\n\t// if (typeof fn !== 'function') {\n\t// \treturn false;\n\t// }\n\n\t// seemingly\n\t// class prototype is always object\n\tif (!(fn.prototype instanceof Object)) {\n\t\treturn false;\n\t}\n\t// but only if not augmented\n\n\t// class prototype.constructor cannot be re-defined (usually)\n\t// but for functions user may re-assign it easily\n\t// just assigning the way .prototype = {}\n\t// and they 99.9% do this, cause nobody cares\n\t// but we are checking if this is class, so it works ...\n\tif (fn.prototype.constructor !== fn) {\n\t\treturn false;\n\t}\n\n\t// and the most unknown thing is that,\n\t// cause for functions it it writeable )))\n\t// eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\treturn Reflect.getOwnPropertyDescriptor(fn, 'prototype')!.writable === false;\n\n\t*/\n};\n\nconst makeFakeModificatorType = (\n\tTypeName: string,\n\tfakeModificator = function () { }\n) => {\n\n\tconst modificatorBody = compileNewModificatorFunctionBody(TypeName);\n\n\tconst modificatorType = modificatorBody(\n\t\tfakeModificator,\n\t\tCreationHandler,\n\t\tSymbolConstructorName\n\t);\n\n\treturn modificatorType();\n\n};\n\n\n// TODO: .valueOf(), .toString() ???\nconst reflectPrimitiveWrappers = (_thisArg: unknown) => {\n\tlet thisArg = _thisArg;\n\n\tif (_thisArg === null) {\n\t\tthisArg = Object.create(null);\n\t\todp(thisArg, Symbol.toPrimitive, {\n\t\t\tget () {\n\t\t\t\treturn () => {\n\t\t\t\t\treturn _thisArg;\n\t\t\t\t};\n\t\t\t}\n\t\t});\n\t}\n\n\tif (\n\t\t_thisArg instanceof Number ||\n\t\t_thisArg instanceof Boolean ||\n\t\t_thisArg instanceof String\n\t) {\n\t\todp(thisArg, Symbol.toPrimitive, {\n\t\t\tget () {\n\t\t\t\treturn () => {\n\t\t\t\t\treturn _thisArg.valueOf();\n\t\t\t\t};\n\t\t\t}\n\t\t});\n\t}\n\n\treturn thisArg;\n};\n\nconst TypesUtils = {\n\tisClass,\n\tCreationHandler,\n\tcheckProto,\n\tgetTypeChecker,\n\tgetTypeSplitPath,\n\tgetExistentAsyncStack,\n\tcheckTypeName,\n\tfindSubTypeFromParent,\n\tmakeFakeModificatorType,\n\treflectPrimitiveWrappers,\n};\n\nexport default TypesUtils;\n"]}

package/build/descriptors/index.js

@@ -3,5 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.descriptors = void 0;
 const errors_1 = require("./errors");
 const types_1 = require("./types");
-exports.descriptors = Object.assign(Object.assign({}, types_1.types), { ErrorsTypes: errors_1.ErrorsTypes });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVzY3JpcHRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYixxQ0FBdUM7QUFDdkMsbUNBRWlCO0FBR0osUUFBQSxXQUFXLG1DQUVwQixhQUFLLEtBRVIsV0FBVyxFQUFYLG9CQUFXLElBRVYiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IEVycm9yc1R5cGVzIH0gZnJvbSAnLi9lcnJvcnMnO1xuaW1wb3J0IHtcblx0dHlwZXNcbn0gZnJvbSAnLi90eXBlcyc7XG5cblxuZXhwb3J0IGNvbnN0IGRlc2NyaXB0b3JzID0ge1xuXG5cdC4uLnR5cGVzLFxuXG5cdEVycm9yc1R5cGVzXG5cbn07XG4iXX0=
+exports.descriptors = {
+    ...types_1.types,
+    ErrorsTypes: errors_1.ErrorsTypes
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVzY3JpcHRvcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYixxQ0FBdUM7QUFDdkMsbUNBRWlCO0FBR0osUUFBQSxXQUFXLEdBQUc7SUFFMUIsR0FBRyxhQUFLO0lBRVIsV0FBVyxFQUFYLG9CQUFXO0NBRVgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgRXJyb3JzVHlwZXMgfSBmcm9tICcuL2Vycm9ycyc7XG5pbXBvcnQge1xuXHR0eXBlc1xufSBmcm9tICcuL3R5cGVzJztcblxuXG5leHBvcnQgY29uc3QgZGVzY3JpcHRvcnMgPSB7XG5cblx0Li4udHlwZXMsXG5cblx0RXJyb3JzVHlwZXNcblxufTtcbiJdfQ==

package/build/index.d.ts

@@ -1,4 +1,5 @@
 import { TypeLookup, IDEF, hook, hooksTypes, constructorOptions, Proto, SN, IDefinitorInstance } from './types';
+export declare const isClass: (fn: CallableFunction) => boolean, findSubTypeFromParent: (instance: import("./api/utils/index").parentSub, subType: string) => import("./api/utils/index").parentSub | null;
 export type { IDEF, ConstructorFunction } from './types';
 export { getProps, setProps } from './api/types/Props';
 export declare const defaultTypes: any;
@@ -7,11 +8,13 @@ export declare const lookup: TypeLookup;
 export declare const apply: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, args?: unknown[]) => { [key in keyof S]: S[key]; };
 export declare const call: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, ...args: unknown[]) => { [key in keyof S]: S[key]; };
 export declare const bind: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>) => (...args: unknown[]) => { [key in keyof S]: S[key]; };
-export declare const decorate: (parentClass?: {
-    new (): unknown;
-} | constructorOptions | undefined, config?: constructorOptions) => <T extends {
-    new (): unknown;
-}>(cstr: T, s: ClassDecoratorContext<T>) => T;
+type Constructor<T = unknown> = new (...args: unknown[]) => T;
+type DecoratedClass<T extends Constructor<object>> = T & (<U extends Constructor<object>>(target: U) => DecoratedClass<U>) & {
+    define: IDefinitorInstance<InstanceType<T>, unknown>['define'];
+    registerHook: IDefinitorInstance<InstanceType<T>, unknown>['registerHook'];
+    lookup: TypeLookup;
+};
+export declare const decorate: <T extends Constructor<object> | constructorOptions | undefined = undefined>(target?: T, config?: constructorOptions) => <U extends Constructor<object>>(cstr: U) => DecoratedClass<U>;
 export declare const registerHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;
 export declare const mnemonica: {
     [index: string]: unknown;

package/build/index.js

@@ -1,6 +1,8 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolConstructorName = exports.SymbolParentType = exports.mnemonica = exports.registerHook = exports.decorate = exports.bind = exports.call = exports.apply = exports.lookup = exports.define = exports.defaultTypes = exports.setProps = exports.getProps = void 0;
+exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolConstructorName = exports.SymbolParentType = exports.mnemonica = exports.registerHook = exports.decorate = exports.bind = exports.call = exports.apply = exports.lookup = exports.define = exports.defaultTypes = exports.setProps = exports.getProps = exports.findSubTypeFromParent = exports.isClass = void 0;
+const index_1 = require("./api/utils/index");
+exports.isClass = index_1.default.isClass, exports.findSubTypeFromParent = index_1.default.findSubTypeFromParent;
 var Props_1 = require("./api/types/Props");
 Object.defineProperty(exports, "getProps", { enumerable: true, get: function () { return Props_1.getProps; } });
 Object.defineProperty(exports, "setProps", { enumerable: true, get: function () { return Props_1.setProps; } });
@@ -8,6 +10,7 @@ const constants_1 = require("./constants");
 const { odp } = constants_1.constants;
 const errorsApi = require("./api/errors");
 const descriptors_1 = require("./descriptors");
+const { WRONG_MODIFICATION_PATTERN } = descriptors_1.descriptors.ErrorsTypes;
 const Mnemosyne_1 = require("./api/types/Mnemosyne");
 const { prepareSubtypeForConstruction } = Mnemosyne_1.default;
 exports.defaultTypes = descriptors_1.descriptors.defaultTypes;
@@ -26,6 +29,9 @@ exports.lookup = function (TypeNestedPath) {
 const $run = function (entity, Constructor, args) {
     const { TypeName } = Constructor;
     const Cstr = prepareSubtypeForConstruction(TypeName, entity);
+    if (Cstr === undefined) {
+        throw new WRONG_MODIFICATION_PATTERN(`[ ${TypeName} ] is not defined as a Type Constructor on used instance`);
+    }
     const result = new Cstr(...args);
     return result;
 };
@@ -43,16 +49,20 @@ const bind = function (entity, Constructor) {
     };
 };
 exports.bind = bind;
-const decorate = function (parentClass, config) {
-    if (config === undefined && typeof parentClass === 'object' && !(parentClass instanceof Function)) {
-        config = parentClass;
-        parentClass = undefined;
-    }
-    const decorator = function (cstr, s) {
-        if (parentClass === undefined) {
-            return (0, exports.define)(s.name, cstr, config);
+const decorate = function (target, config) {
+    const opts = (config === undefined && typeof target === 'object' && !(target instanceof Function))
+        ? target
+        : config;
+    const parentType = (target instanceof Function)
+        ? target
+        : undefined;
+    const decorator = function (cstr) {
+        const { name } = cstr;
+        if (parentType === undefined) {
+            return (0, exports.define)(name, cstr, opts);
         }
-        return parentClass.define(s.name, cstr, config);
+        const parent = parentType;
+        return parent.define(name, cstr, opts);
     };
     return decorator;
 };
@@ -61,13 +71,18 @@ const registerHook = function (Constructor, hookType, cb) {
     Constructor.registerHook(hookType, cb);
 };
 exports.registerHook = registerHook;
-exports.mnemonica = Object.entries(Object.assign(Object.assign(Object.assign({ define: exports.define,
+exports.mnemonica = Object.entries({
+    define: exports.define,
     lookup: exports.lookup,
     apply: exports.apply,
     call: exports.call,
     bind: exports.bind,
     decorate: exports.decorate,
-    registerHook: exports.registerHook }, descriptors_1.descriptors), errorsApi), constants_1.constants)).reduce((acc, entry) => {
+    registerHook: exports.registerHook,
+    ...descriptors_1.descriptors,
+    ...errorsApi,
+    ...constants_1.constants,
+}).reduce((acc, entry) => {
     const [name, code] = entry;
     odp(acc, name, {
         get() {
@@ -84,4 +99,4 @@ 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; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment, space-before-function-paren */\n'use strict';\n\nimport {\n\tTypeLookup,\n\tIDEF,\n\thook,\n\thooksTypes,\n\tconstructorOptions,\n\tProto,\n\tSN,\n\tIDefinitorInstance\n} from './types';\nexport type { IDEF, ConstructorFunction } from './types';\nexport { getProps, setProps } from './api/types/Props';\n\nimport { constants } from './constants';\nconst { odp } = constants;\n\nimport * as errorsApi from './api/errors';\nimport { descriptors } from './descriptors';\n\nimport mnemosynes from './api/types/Mnemosyne';\nconst { prepareSubtypeForConstruction } = mnemosynes;\n\nexport const {\n\tdefaultTypes,\n} = descriptors;\n\nfunction checkThis(pointer: typeof mnemonica | typeof exports | unknown): boolean {\n\treturn pointer === mnemonica || pointer === exports;\n}\n\nexport const define = function <\n\tT,\n\t// K extends IDEF<T>,\n\t// H extends ThisType<IDEF<T>>,\n\tP extends object,\n\tN extends Proto<P, T>,\n\t// so S it just basically allows nested constructors\n\t// and gives extracted props from constructHandler & proto\n\t// then it goes to new() keyword of define output\n\tS extends SN & N,\n\tR extends IDefinitorInstance<N, S>\n>(\n\tthis: unknown,\n\tTypeName?: string,\n\tconstructHandler?: IDEF<T>,\n\tconfig?: constructorOptions,\n): R {\n\tconst types = checkThis(this) ? defaultTypes : this || defaultTypes;\n\treturn types.define(TypeName, constructHandler, config);\n};\n\nexport const lookup = function (TypeNestedPath) {\n\tconst types = checkThis(this) ? defaultTypes : this || defaultTypes;\n\treturn types.lookup(TypeNestedPath);\n} as TypeLookup;\n\n\nconst $run = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\targs: unknown[]\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\t \n\t// debugger;\n\t// @ts-ignore\n\tconst { TypeName } = Constructor;\n\tconst Cstr = prepareSubtypeForConstruction(TypeName, entity) as { new( ...ars: unknown[]): unknown};\n\t// TODO: check lines below and if Constructor is not mnemonized ...\n\t// if (Cstr === undefined) {\n\t// \tthrow new TypeError(`Type ${TypeName} is not defined as a .`);\n\t// }\n\tconst result = new Cstr(...args);\n\t// @ts-ignore\n\treturn result;\n};\n\n// TODO: apply instance .to type .with arguments\nexport const apply = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\targs: unknown[] = []\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\treturn $run<E, T, S>(entity, Constructor, args);\n};\n\n// TODO: call type .by instance .with arguments\nexport const call = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\t...args: unknown[]\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\treturn $run<E, T, S>(entity, Constructor, args);\n};\n\n// TODO: bind type .with instance → (...args)\nexport const bind = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>\n): (...args: unknown[]) => {\n\t[key in keyof S]: S[key]\n} {\n\treturn (...args) => {\n\t\treturn $run<E, T, S>(entity, Constructor, args);\n\t};\n};\n\nexport const decorate = function (\n\tparentClass?: { new(): unknown } | constructorOptions | undefined,\n\tconfig?: constructorOptions\n) {\n\tif (config === undefined && typeof parentClass === 'object' && !(parentClass instanceof Function)) {\n\t\tconfig = parentClass as constructorOptions;\n\t\tparentClass = undefined;\n\t}\n\tconst decorator = function <T extends { new(): unknown }>(cstr: T, s: ClassDecoratorContext<T>): T {\n\t\tif (parentClass === undefined) {\n\t\t\treturn define(s.name, cstr, config) as unknown as T;\n\t\t}\n\t\t// @ts-ignore\n\t\treturn parentClass.define(s.name, cstr, config) as unknown as T;\n\t};\n\treturn decorator;\n};\n\nexport const registerHook = function <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook): void {\n\t// @ts-ignore\n\tConstructor.registerHook(hookType, cb);\n};\n\nexport const mnemonica = Object.entries({\n\n\tdefine,\n\tlookup,\n\tapply,\n\tcall,\n\tbind,\n\tdecorate,\n\tregisterHook,\n\n\t...descriptors,\n\n\t...errorsApi,\n\t...constants,\n\n}).reduce((acc: { [index: string]: unknown }, entry: [string, unknown]) => {\n\tconst [ name, code ] = entry;\n\todp(acc, name, {\n\t\tget() {\n\t\t\treturn code;\n\t\t},\n\t\tenumerable : true\n\t});\n\treturn acc;\n}, {});\n\nexport const {\n\n\tSymbolParentType,\n\tSymbolConstructorName,\n\tSymbolDefaultTypesCollection,\n\tSymbolConfig,\n\tMNEMONICA,\n\tMNEMOSYNE,\n\tTYPE_TITLE_PREFIX,\n\tErrorMessages,\n\tcreateTypesCollection,\n\n} = mnemonica;\n\n\nexport const defaultCollection = defaultTypes.subtypes;\nexport const errors = descriptors.ErrorsTypes;\n\nexport { utils } from './utils';\nexport { defineStackCleaner } from './utils';\n/* eslint-enable @typescript-eslint/ban-ts-comment, space-before-function-paren */\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment, space-before-function-paren */\n'use strict';\n\nimport {\n\tTypeLookup,\n\tIDEF,\n\thook,\n\thooksTypes,\n\tconstructorOptions,\n\tProto,\n\tSN,\n\tIDefinitorInstance\n} from './types';\n\nimport TypesUtils from './api/utils/index';\nexport const {\n\tisClass,\n\tfindSubTypeFromParent,\n} = TypesUtils;\n\nexport type { IDEF, ConstructorFunction } from './types';\nexport { getProps, setProps } from './api/types/Props';\n\nimport { constants } from './constants';\nconst { odp } = constants;\n\nimport * as errorsApi from './api/errors';\nimport { descriptors } from './descriptors';\n\nconst { WRONG_MODIFICATION_PATTERN } = descriptors.ErrorsTypes;\n\nimport mnemosynes from './api/types/Mnemosyne';\nconst { prepareSubtypeForConstruction } = mnemosynes;\n\nexport const {\n\tdefaultTypes,\n} = descriptors;\n\nfunction checkThis(pointer: typeof mnemonica | typeof exports | unknown): boolean {\n\treturn pointer === mnemonica || pointer === exports;\n}\n\nexport const define = function <\n\tT,\n\t// K extends IDEF<T>,\n\t// H extends ThisType<IDEF<T>>,\n\tP extends object,\n\tN extends Proto<P, T>,\n\t// so S it just basically allows nested constructors\n\t// and gives extracted props from constructHandler & proto\n\t// then it goes to new() keyword of define output\n\tS extends SN & N,\n\tR extends IDefinitorInstance<N, S>\n>(\n\tthis: unknown,\n\tTypeName?: string,\n\tconstructHandler?: IDEF<T>,\n\tconfig?: constructorOptions,\n): R {\n\tconst types = checkThis(this) ? defaultTypes : this || defaultTypes;\n\treturn types.define(TypeName, constructHandler, config);\n};\n\nexport const lookup = function (TypeNestedPath) {\n\tconst types = checkThis(this) ? defaultTypes : this || defaultTypes;\n\treturn types.lookup(TypeNestedPath);\n} as TypeLookup;\n\n\nconst $run = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\targs: unknown[]\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\n\t// debugger;\n\t// @ts-ignore\n\tconst { TypeName } = Constructor;\n\tconst Cstr = prepareSubtypeForConstruction(TypeName, entity) as { new(...ars: unknown[]): unknown };\n\t// TODO: check lines below and if Constructor is not mnemonized ...\n\tif (Cstr === undefined) {\n\t\tthrow new WRONG_MODIFICATION_PATTERN(`[ ${TypeName} ] is not defined as a Type Constructor on used instance`);\n\t}\n\tconst result = new Cstr(...args);\n\t// @ts-ignore\n\treturn result;\n};\n\n// TODO: apply instance .to type .with arguments\nexport const apply = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\targs: unknown[] = []\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\treturn $run<E, T, S>(entity, Constructor, args);\n};\n\n// TODO: call type .by instance .with arguments\nexport const call = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\t...args: unknown[]\n): {\n\t\t[key in keyof S]: S[key]\n\t} {\n\treturn $run<E, T, S>(entity, Constructor, args);\n};\n\n// TODO: bind type .with instance → (...args)\nexport const bind = function <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>\n): (...args: unknown[]) => {\n\t[key in keyof S]: S[key]\n} {\n\treturn (...args) => {\n\t\treturn $run<E, T, S>(entity, Constructor, args);\n\t};\n};\n\n\n\n\ntype Constructor<T = unknown> = new(...args: unknown[]) => T;\n\n// Type for decorated classes that can be used as:\n// 1. A constructor: new MyDecoratedClass()\n// 2. A decorator: @MyDecoratedClass() class Sub {}\n// 3. Extended: class Sub extends MyDecoratedClass {}\n// 4. Have mnemonica methods: MyDecoratedClass.define(...)\ntype DecoratedClass<T extends Constructor<object>> =\n\t// Base constructor type\n\tT &\n\t// Callable as decorator: @MyDecoratedClass() class Sub {}\n\t(<U extends Constructor<object>>(target: U) => DecoratedClass<U>) &\n\t// Mnemonica type system methods\n\t{\n\t\tdefine: IDefinitorInstance<InstanceType<T>, unknown>['define'];\n\t\tregisterHook: IDefinitorInstance<InstanceType<T>, unknown>['registerHook'];\n\t\tlookup: TypeLookup;\n\t};\n\nexport const decorate = function <\n\tT extends Constructor<object> | constructorOptions | undefined = undefined\n>(\n\ttarget?: T,\n\tconfig?: constructorOptions\n): <U extends Constructor<object>>(cstr: U) => DecoratedClass<U> {\n\tconst opts = (config === undefined && typeof target === 'object' && !(target instanceof Function))\n\t\t? target as constructorOptions\n\t\t: config;\n\n\tconst parentType = (target instanceof Function)\n\t\t? target as Constructor<object>\n\t\t: undefined;\n\n\tconst decorator = function <U extends Constructor<object>>(cstr: U): DecoratedClass<U> {\n\t\tconst { name } = cstr;\n\t\tif (parentType === undefined) {\n\t\t\treturn define(name, cstr, opts) as unknown as DecoratedClass<U>;\n\t\t}\n\t\tconst parent = parentType as unknown as {\n\t\t\tdefine: (name: string, cstr: Constructor<unknown>, config?: constructorOptions) => unknown\n\t\t};\n\t\treturn parent.define(name, cstr, opts) as unknown as DecoratedClass<U>;\n\t};\n\treturn decorator;\n};\n\n\nexport const registerHook = function <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook): void {\n\t// @ts-ignore\n\tConstructor.registerHook(hookType, cb);\n};\n\nexport const mnemonica = Object.entries({\n\n\tdefine,\n\tlookup,\n\tapply,\n\tcall,\n\tbind,\n\tdecorate,\n\tregisterHook,\n\n\t...descriptors,\n\n\t...errorsApi,\n\t...constants,\n\n}).reduce((acc: { [index: string]: unknown }, entry: [string, unknown]) => {\n\tconst [ name, code ] = entry;\n\todp(acc, name, {\n\t\tget() {\n\t\t\treturn code;\n\t\t},\n\t\tenumerable : true\n\t});\n\treturn acc;\n}, {});\n\nexport const {\n\n\tSymbolParentType,\n\tSymbolConstructorName,\n\tSymbolDefaultTypesCollection,\n\tSymbolConfig,\n\tMNEMONICA,\n\tMNEMOSYNE,\n\tTYPE_TITLE_PREFIX,\n\tErrorMessages,\n\tcreateTypesCollection,\n\n} = mnemonica;\n\n\nexport const defaultCollection = defaultTypes.subtypes;\nexport const errors = descriptors.ErrorsTypes;\n\nexport { utils } from './utils';\nexport { defineStackCleaner } from './utils';\n/* eslint-enable @typescript-eslint/ban-ts-comment, space-before-function-paren */\n\n"]}

package/build/types/index.d.ts

@@ -46,8 +46,8 @@ export type SN = Record<string, new () => unknown>;
 export interface IDefinitorInstance<N extends object, S> {
     new (...arg: unknown[]): {
         [key in keyof S]: S[key];
-    };
-    define: IDefinitor<N, string>;
+    } & IDefinitor<N, string>;
+    define: IDefinitorInstance<N, string>;
     registerHook: (hookType: hooksTypes, cb: hook) => void;
 }
 export interface IDefinitor<P extends object, SubTypeName extends string> {

package/build/types/index.js

@@ -1,3 +1,3 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/index.js

@@ -24,12 +24,14 @@ const wrapThis = (method) => {
         return method(instance !== undefined ? instance : this, ...args);
     };
 };
-exports.utils = Object.assign({}, Object.entries(utilsUnWrapped)
-    .reduce((methods, util) => {
-    const [name, fn] = util;
-    methods[name] = wrapThis(fn);
-    return methods;
-}, {}));
+exports.utils = {
+    ...Object.entries(utilsUnWrapped)
+        .reduce((methods, util) => {
+        const [name, fn] = util;
+        methods[name] = wrapThis(fn);
+        return methods;
+    }, {}),
+};
 var defineStackCleaner_1 = require("./defineStackCleaner");
 Object.defineProperty(exports, "defineStackCleaner", { enumerable: true, get: function () { return defineStackCleaner_1.defineStackCleaner; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYiwrREFBNEQ7QUFDNUQsdUNBQW9DO0FBQ3BDLHFDQUFrQztBQUNsQyxpQ0FBOEI7QUFDOUIscUNBQWtDO0FBQ2xDLG1DQUFnQztBQUNoQyxtQ0FBZ0M7QUFFaEMsTUFBTSxjQUFjLEdBQUc7SUFFdEIsT0FBTyxFQUFQLGlCQUFPO0lBQ1AsSUFBSSxFQUFKLFdBQUk7SUFFSixNQUFNLEVBQU4sZUFBTTtJQUVOLE1BQU0sRUFBTixlQUFNO0lBRU4sS0FBSyxFQUFMLGFBQUs7SUFDTCxLQUFLLEVBQUwsYUFBSztJQUVMLElBQUksbUJBQW1CO1FBQ3RCLE9BQU8seUNBQW1CLENBQUM7SUFDNUIsQ0FBQztDQUVELENBQUM7QUFFRixNQUFNLFFBQVEsR0FBRyxDQUFFLE1BQXdCLEVBQUcsRUFBRTtJQUMvQyxPQUFPLFVBQXNCLFFBQWEsRUFBRSxHQUFHLElBQVc7UUFDekQsT0FBTyxNQUFNLENBQUUsUUFBUSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxJQUFJLENBQUUsQ0FBQztJQUNwRSxDQUFDLENBQUM7QUFDSCxDQUFDLENBQUM7QUFFVyxRQUFBLEtBQUssR0FBK0I7SUFFaEQsR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFFLGNBQWMsQ0FBRTtTQUNqQyxNQUFNLENBQUUsQ0FBRSxPQUFtQyxFQUFFLElBQUksRUFBRyxFQUFFO1FBQ3hELE1BQU0sQ0FBRSxJQUFJLEVBQUUsRUFBRSxDQUFFLEdBQUcsSUFBSSxDQUFDO1FBQzFCLE9BQU8sQ0FBRSxJQUFJLENBQUUsR0FBRyxRQUFRLENBQUUsRUFBRSxDQUFFLENBQUM7UUFDakMsT0FBTyxPQUFPLENBQUM7SUFDaEIsQ0FBQyxFQUFFLEVBQUUsQ0FBRTtDQUVSLENBQUM7QUFFRiwyREFBMEQ7QUFBakQsd0hBQUEsa0JBQWtCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IGNvbGxlY3RDb25zdHJ1Y3RvcnMgfSBmcm9tICcuL2NvbGxlY3RDb25zdHJ1Y3RvcnMnO1xuaW1wb3J0IHsgZXh0cmFjdCB9IGZyb20gJy4vZXh0cmFjdCc7XG5pbXBvcnQgeyBwYXJlbnQgfSBmcm9tICcuL3BhcmVudCc7XG5pbXBvcnQgeyBwaWNrIH0gZnJvbSAnLi9waWNrJztcbmltcG9ydCB7IHRvSlNPTiB9IGZyb20gJy4vdG9KU09OJztcbmltcG9ydCB7IHBhcnNlIH0gZnJvbSAnLi9wYXJzZSc7XG5pbXBvcnQgeyBtZXJnZSB9IGZyb20gJy4vbWVyZ2UnO1xuXG5jb25zdCB1dGlsc1VuV3JhcHBlZCA9IHtcblxuXHRleHRyYWN0LFxuXHRwaWNrLFxuXG5cdHBhcmVudCxcblxuXHR0b0pTT04sXG5cblx0cGFyc2UsXG5cdG1lcmdlLFxuXG5cdGdldCBjb2xsZWN0Q29uc3RydWN0b3JzICgpIHtcblx0XHRyZXR1cm4gY29sbGVjdENvbnN0cnVjdG9ycztcblx0fSxcblxufTtcblxuY29uc3Qgd3JhcFRoaXMgPSAoIG1ldGhvZDogQ2FsbGFibGVGdW5jdGlvbiApID0+IHtcblx0cmV0dXJuIGZ1bmN0aW9uICggdGhpczogYW55LCBpbnN0YW5jZTogYW55LCAuLi5hcmdzOiBhbnlbXSApIHtcblx0XHRyZXR1cm4gbWV0aG9kKCBpbnN0YW5jZSAhPT0gdW5kZWZpbmVkID8gaW5zdGFuY2UgOiB0aGlzLCAuLi5hcmdzICk7XG5cdH07XG59O1xuXG5leHBvcnQgY29uc3QgdXRpbHM6IHsgWyBpbmRleDogc3RyaW5nIF06IGFueSB9ID0ge1xuXG5cdC4uLk9iamVjdC5lbnRyaWVzKCB1dGlsc1VuV3JhcHBlZCApXG5cdFx0LnJlZHVjZSggKCBtZXRob2RzOiB7IFsgaW5kZXg6IHN0cmluZyBdOiBhbnkgfSwgdXRpbCApID0+IHtcblx0XHRcdGNvbnN0IFsgbmFtZSwgZm4gXSA9IHV0aWw7XG5cdFx0XHRtZXRob2RzWyBuYW1lIF0gPSB3cmFwVGhpcyggZm4gKTtcblx0XHRcdHJldHVybiBtZXRob2RzO1xuXHRcdH0sIHt9ICksXG5cbn07XG5cbmV4cG9ydCB7IGRlZmluZVN0YWNrQ2xlYW5lciB9IGZyb20gJy4vZGVmaW5lU3RhY2tDbGVhbmVyJztcbiJdfQ==

package/build/utils/parse.js

@@ -17,7 +17,7 @@ const parse = (self) => {
         throw new WRONG_ARGUMENTS_USED(`have to use "instance" itself: '${proto.constructor.name}' vs '${protoProto.constructor.name}'`);
     }
     const { name } = proto.constructor;
-    const props = (0, extract_1.extract)(Object.assign({}, self));
+    const props = (0, extract_1.extract)({ ...self });
     delete props.constructor;
     const joint = (0, extract_1.extract)(Object.assign({}, proto));
     delete joint.constructor;
@@ -32,4 +32,4 @@ const parse = (self) => {
     };
 };
 exports.parse = parse;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnemonica",
-  "version": "0.9.9977",
+  "version": "0.9.99778",
   "description": "abstract technique that aids information retention : instance inheritance system",
   "type": "commonjs",
   "main": "./build/index.js",
@@ -30,15 +30,17 @@
   ],
   "scripts": {
     "build": "rm -rf ./build && npx tsc --pretty --project tsconfig.json && npm run lint:src && npm run lint:test",
+    "build:all": "rm -rf ./build && npx tsc --pretty --project tsconfig.json && npm run decorate:ts && npm run lint:src && npm run lint:test",
     "example": "npm run build && node ./test/example.js",
     "example:ts": "npx tsc ./test-ts/*.ts && npx eslint --fix ./test-ts/*.js && node ./test-ts/test-no-types.js && node ./test-ts/test-with-types.js",
     "deopt": "node --trace-deopt --trace-opt ./node_modules/mocha/bin/mocha.js ./test/index.js",
+    "decorate:ts": "npx tsc --target ES2021 --moduleResolution NodeNext --module NodeNext --sourceMap ./test/decorate.ts",
     "lint": "npx eslint",
     "lint:src": "npx eslint --fix ./src",
     "lint:test": "npx eslint --fix ./test",
     "test": "mocha --allow-uncaught --enable-source-maps test/index.js",
-    "test:cov": "npm run build && nyc --reporter=text-summary --reporter=lcov mocha --allow-uncaught --enable-source-maps --ui bdd --reporter spec ./test/index.js",
-    "test:debug": "npx tsc --pretty --project tsconfig.json && npx mocha --allow-uncaught --enable-source-maps --reporter spec --inspect-brk test/index",
+    "test:cov": "npm run build:all && nyc --reporter=text-summary --reporter=lcov mocha --allow-uncaught --enable-source-maps --ui bdd --reporter spec ./test/index.js",
+    "debug": "npx tsc --pretty --project tsconfig.json && npx mocha --allow-uncaught --enable-source-maps --reporter spec --inspect-brk test/index",
     "test:jest": "npx jest",
     "test:jest:cov": "npx jest --collectCoverage",
     "test:jest:debug": "npx --node-options=--inspect-brk jest",
@@ -64,27 +66,27 @@
   "homepage": "https://github.com/wentout/mnemonica#readme",
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^9",
     "@types/jest": "^30.0.0",
-    "@types/node": "^25.0.9",
-    "@typescript-eslint/eslint-plugin": "^8.53.0",
-    "@typescript-eslint/parser": "^8.53.0",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
     "chai": "^6.2.2",
-    "eslint": "^9.39.2",
+    "eslint": "^9",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-no-arrow-this": "^1.2.0",
-    "globals": "^17.0.0",
+    "globals": "^17.3.0",
     "husky": "^9.1.7",
     "jest": "^30.2.0",
     "json5": "^2.2.3",
     "lint-staged": "^16.2.7",
     "mocha": "^11.7.5",
     "mocha-lcov-reporter": "^1.3.0",
-    "nyc": "^17.1.0",
-    "oxlint": "^1.39.0",
+    "nyc": "^18.0.0",
+    "oxlint": "^1.49.0",
     "ts-jest": "^29.4.6",
-    "typeomatica": "^0.3.4",
+    "typeomatica": "^0.3.55",
     "typescript": "^5.9.3"
   },
   "engines": {