typeomatica 0.3.55 → 0.3.57

package/README.md

@@ -1,4 +1,4 @@
-# Type ø matica
+# TypeØmatica
 
 [![Coverage Status](https://coveralls.io/repos/github/wentout/typeomatica/badge.svg?branch=main)](https://coveralls.io/github/wentout/typeomatica?branch=main)
 
@@ -8,37 +8,383 @@
 
 [**$ npm install <u>typeomatica</u>**](https://www.npmjs.com/package/typeomatica)
 
-
 This package is a part of [mnemonica](https://www.npmjs.com/package/mnemonica) project.
 
-Strict Types checker for objects which represent Data Types.
+**Strict Runtime Type Checker for JavaScript Objects**
+
+TypeØmatica uses JavaScript Proxies to enforce type safety at runtime, exactly as TypeScript expects at compile time. Once a property is assigned a value, its type is locked and cannot be changed.
+
+---
+
+## Quick Start
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class User extends BaseClass {
+  name: string = 'default';
+  age: number = 0;
+}
+
+const user = new User();
+
+// ✓ Valid assignments
+user.name = 'John';
+user.age = 25;
+
+// ✗ Runtime error (even if TypeScript is bypassed with @ts-ignore)
+user.age = '25';  // TypeError: Type Mismatch
+```
+
+---
+
+## Table of Contents
+
+- [What is TypeØmatica?](#what-is-typeomatica)
+- [Installation](#installation)
+- [Core Concepts](#core-concepts)
+- [API Reference](#api-reference)
+- [Usage Patterns](#usage-patterns)
+- [Type Examples](#type-examples)
+- [Working with Wrapped Values](#working-with-wrapped-values)
+- [Error Reference](#error-reference)
+- [Integration with Mnemonica](#integration-with-mnemonica)
+
+---
+
+## What is TypeØmatica?
+
+TypeØmatica provides strict runtime type checking for JavaScript objects using Proxy-based interception. It ensures that once a property is initialized with a type, that type cannot be violated at runtime.
+
+**Key Features:**
+- Runtime type enforcement (complements TypeScript's compile-time checks)
+- Proxy-based property interception
+- Type locking after initial assignment
+- Prevents prototype mutation, property redefinition, and deletion
+
+---
+
+## Installation
+
+```bash
+npm install typeomatica
+```
+
+---
+
+## Core Concepts
+
+### How It Works
+
+TypeØmatica wraps objects with JavaScript Proxies that intercept:
+- `get` - Property reads
+- `set` - Property writes (with type validation)
+- `setPrototypeOf` - Blocks prototype changes
+- `defineProperty` - Blocks property redefinition
+- `deleteProperty` - Blocks property deletion
+
+### Type Categories
+
+| Category | Types | Behavior |
+|----------|-------|----------|
+| `primitives` | string, number, boolean, bigint, symbol, undefined | Type-locked accessors |
+| `nullish` | null | Only null allowed |
+| `objects` | object, arrays, dates | Same constructor type required |
+| `functions` | methods | Restricted on data types |
+
+---
+
+## API Reference
+
+### BaseClass
+
+The primary class for strict-type objects.
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class MyClass extends BaseClass {
+  field: string = 'value';
+  constructor() {
+    super();
+  }
+}
+```
+
+### BasePrototype
+
+Functional equivalent of `BaseClass`.
+
+```typescript
+import { BasePrototype } from 'typeomatica';
+
+const Base = BasePrototype({ initialProp: 123 });
+class MyClass extends Base { }
+```
+
+### @Strict() Decorator
+
+Apply strict typing without extending BaseClass.
+
+```typescript
+import { Strict } from 'typeomatica';
+
+@Strict({ deep: true })
+class MyClass {
+  field: number = 0;
+}
+```
+
+**Decorator Arguments:**
+- First argument: Base prototype or options object
+- Second argument: Options object
+
+### Options Interface
+
+```typescript
+interface TypeomaticaOptions {
+  strictAccessCheck?: boolean;  // default: false
+}
+```
+
+**Options:**
+- `strictAccessCheck: true` - Enables strict receiver checking (throws `ACCESS_DENIED` error when property is accessed from wrong context)
+- `deep: true` - Enable recursive property checking (when using BasePrototype with initial values)
+
+### Usage with Options
+
+```typescript
+// With BaseClass - strict access checking enabled
+class SecureData extends BaseClass {
+  secret: string = '';
+  constructor() {
+    super(undefined, { strictAccessCheck: true });
+  }
+}
+
+// With BasePrototype - strict access checking enabled
+const SecureBase = BasePrototype({ data: '' }, { strictAccessCheck: true });
+class User extends SecureBase {
+  name: string = '';
+}
+
+// With @Strict decorator - strict access checking enabled
+@Strict(undefined, { strictAccessCheck: true })
+class Product {
+  price: number = 0;
+}
+```
+
+### Symbol Exports
+
+```typescript
+import { 
+  SymbolTypeomaticaProxyReference,  // Access proxy internals
+  SymbolInitialValue                 // Access original values
+} from 'typeomatica';
+```
+
+---
 
-# how it works
+## Usage Patterns
 
-see `test/index.ts`
+### Pattern 1: Extending BaseClass
 
-```js
+```typescript
+import { BaseClass } from 'typeomatica';
 
-class SimpleBase extends BasePrototype {
-	stringProp = '123';
-};
+class User extends BaseClass {
+  name: string = '';
+  age: number = 0;
+  active: boolean = true;
+}
 
-// nect code line will work properly
-simpleInstance.stringProp = '321';
+const user = new User();
+user.name = 'John';     // ✓ Works
+user.age = 25;          // ✓ Works
 
-// but next code line will throw TypeError('Type Mismatch')
 // @ts-ignore
-simpleInstance.stringProp = 123;
+user.age = '25';        // ✗ TypeError: Type Mismatch
+```
+
+### Pattern 2: @Strict Decorator
+
+```typescript
+import { Strict } from 'typeomatica';
+
+@Strict({ deep: true })
+class Product {
+  id: number = 0;
+  title: string = '';
+  price: number = 0;
+}
 
+const product = new Product();
+product.price = 29.99;      // ✓ Works
+// @ts-ignore
+product.price = '$29.99';   // ✗ TypeError: Type Mismatch
 ```
 
-That is it. It will be impossible to assign anything else except of:
+### Pattern 3: BaseClass as Prototype
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class UserData {
+  name: string = 'default';
+  age: number = 0;
+}
+
+// Inject type checking into prototype chain
+Object.setPrototypeOf(UserData.prototype, new BaseClass({ deep: true }));
 
-```js 
-typeof something === 'string'
+const user = new UserData();
+user.name = 'John';     // ✓ Works
+// @ts-ignore
+user.name = 123;        // ✗ TypeError: Type Mismatch
 ```
 
-to `stringProp` in runtime.
+---
+
+## Type Examples
+
+### Primitives
+
+```typescript
+import { BaseClass } from 'typeomatica';
+
+class Primitives extends BaseClass {
+  str: string = 'hello';
+  num: number = 42;
+  bool: boolean = true;
+  bigint: bigint = BigInt(100);
+}
+
+const p = new Primitives();
+p.str = 'world';          // ✓ Works
+p.num = 100;              // ✓ Works
+// @ts-ignore
+p.str = 123;              // ✗ TypeError: Type Mismatch
+```
+
+### Null and Undefined
+
+```typescript
+class Nullable extends BaseClass {
+  nullValue: null = null;
+  undefinedValue: undefined = undefined;
+}
+
+const n = new Nullable();
+n.nullValue = null;              // ✓ Works
+// @ts-ignore
+n.nullValue = undefined;         // ✗ TypeError: Type Mismatch
+```
+
+### Objects
+
+```typescript
+class WithObject extends BaseClass {
+  data: object = {};
+  list: number[] = [];
+}
+
+const w = new WithObject();
+w.data = { a: 1 };              // ✓ Works
+w.list = [1, 2, 3];             // ✓ Works
+// @ts-ignore
+w.data = 123;                   // ✗ TypeError: Type Mismatch
+// @ts-ignore
+w.data = new Set();             // ✗ TypeError: Type Mismatch (Set !== Object)
+```
+
+---
+
+## Working with Wrapped Values
+
+TypeØmatica wraps primitives to enforce type safety. Use `valueOf()` for operations.
+
+### Numeric Operations
+
+```typescript
+class Calc extends BaseClass {
+  count: number = 10;
+}
+
+const calc = new Calc();
+
+// ✗ Direct arithmetic throws
+const result = calc.count + 5;  // ReferenceError: Value Access Denied
+
+// ✓ Use valueOf()
+const result = calc.count.valueOf() + 5;  // 15
+const sum = 3 + +calc.count;               // 13
+```
+
+### String Operations
+
+```typescript
+class Text extends BaseClass {
+  message: string = 'hello';
+}
+
+const text = new Text();
+text.message.valueOf().toUpperCase();  // 'HELLO'
+text.message.valueOf().length;         // 5
+```
+
+---
+
+## Error Reference
+
+| Error Message | Error Type | When Thrown |
+|---------------|------------|-------------|
+| `Type Mismatch` | TypeError | Wrong type assigned to property |
+| `Value Access Denied` | ReferenceError | Property accessed from wrong context (only when `strictAccessCheck: true`) |
+| `Attempt to Access to Undefined Prop` | Error | Reading non-existent property |
+| `Functions are Restricted` | TypeError | Function assigned to data property |
+| `Re-Assirnment is Forbidden` | TypeError | Modifying read-only custom field |
+| `Setting prototype is not allowed` | Error | Calling `Object.setPrototypeOf()` |
+| `Defining new Properties is not allowed` | Error | Calling `Object.defineProperty()` |
+| `Properties Deletion is not allowed` | Error | Calling `delete` on property |
+
+---
+
+## Integration with Mnemonica
+
+TypeØmatica integrates seamlessly with [mnemonica](https://www.npmjs.com/package/mnemonica) for combined prototype inheritance and runtime type safety.
+
+```typescript
+import { decorate } from 'mnemonica';
+import { BaseClass, Strict } from 'typeomatica';
+
+@decorate()
+@Strict()
+class Entity extends BaseClass {
+  id: string = '';
+  createdAt: Date = new Date();
+}
+
+// Works with mnemonica's inheritance system
+const User = Entity.define('User', function(this: { email: string }) {
+  this.email = '';
+});
+
+const user = new User();
+// @ts-ignore
+user.email = 123;  // ✗ TypeError: Type Mismatch
+```
+
+**Decorator Order Matters:**
+- `@Strict()` must come AFTER `@decorate()` (inner decorator)
+- Decorators apply bottom-to-top
+
+For complete integration documentation, see [mnemonica's TypeØmatica guide](https://github.com/wentout/mnemonica/blob/main/core/TypeØmatica.md).
+
+---
+
+## License
+
+MIT
 
-As we describe Data Types &mdash; please take a peek for tests directory:
-[HERE](https://github.com/wentout/typeomatica/blob/main/test/index.ts).
+Copyright (c) 2019-2024 https://github.com/wentout

package/lib/fields.js

@@ -4,6 +4,7 @@ exports.FieldConstructor = void 0;
 const errors_1 = require("./errors");
 const SymbolInitialValue = Symbol('Initial Value');
 class FieldConstructor {
+    [SymbolInitialValue];
     get get() {
         const self = this;
         return function () {
@@ -25,4 +26,4 @@ class FieldConstructor {
 exports.FieldConstructor = FieldConstructor;
 Object.freeze(FieldConstructor.prototype);
 Object.seal(FieldConstructor.prototype);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -1,11 +1,14 @@
+export interface TypeomaticaOptions {
+    strictAccessCheck?: boolean;
+}
 export declare const baseTarget: (_proto?: object) => any;
 export declare const SymbolTypeomaticaProxyReference: unique symbol;
 export declare const BaseConstructorPrototype: {
-    new <T extends object | {}>(_target?: T): T;
-    <T extends object | {}, S extends T>(_target?: S extends infer S_1 ? S_1 : {}): S;
+    new <T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T;
+    <T extends object | {}, S extends T>(_target?: S extends infer S_1 ? S_1 : {}, options?: TypeomaticaOptions): S;
 };
 export declare class BaseClass {
-    constructor(_target?: object);
+    constructor(_target?: object, options?: TypeomaticaOptions);
 }
 export declare const SymbolInitialValue: symbol;
-export declare const Strict: (_target?: object) => <T>(cstr: T) => T;
+export declare const Strict: (_target?: object, options?: TypeomaticaOptions) => <T>(cstr: T) => T;

package/lib/index.js

@@ -4,46 +4,54 @@ exports.Strict = exports.SymbolInitialValue = exports.BaseClass = exports.BaseCo
 const errors_1 = require("./errors");
 const types_1 = require("./types");
 const fields_1 = require("./fields");
-const resolver = Object.entries({
-    primitives: types_1.primitives,
-    special: types_1.special,
-    nullish: types_1.nullish,
-    objects: types_1.objects,
-    functions: types_1.functions
-}).reduce((obj, [key, _handler]) => {
-    obj[key] = function (initialValue, receiver) {
-        const handler = _handler(initialValue);
-        return {
-            get() {
-                const invocationThis = this;
-                if (invocationThis !== receiver) {
-                    throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
+const createResolver = (options = {}) => {
+    const { strictAccessCheck = false } = options;
+    return Object.entries({
+        primitives: types_1.primitives,
+        special: types_1.special,
+        nullish: types_1.nullish,
+        objects: types_1.objects,
+        functions: types_1.functions
+    }).reduce((obj, [key, _handler]) => {
+        obj[key] = function (initialValue, receiver) {
+            const handler = _handler(initialValue);
+            return {
+                get() {
+                    const invocationThis = this;
+                    if (strictAccessCheck && invocationThis !== receiver) {
+                        throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
+                    }
+                    const result = handler.get();
+                    return result;
+                },
+                set(replacementValue) {
+                    const invocationThis = this;
+                    if (strictAccessCheck && invocationThis !== receiver) {
+                        throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
+                    }
+                    const result = handler.set(replacementValue);
+                    return result;
                 }
-                const result = handler.get();
-                return result;
-            },
-            set(replacementValue) {
-                const invocationThis = this;
-                if (invocationThis !== receiver) {
-                    throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
-                }
-                const result = handler.set(replacementValue);
-                return result;
-            }
+            };
         };
-    };
-    return obj;
-}, {});
-const createProperty = (propName, initialValue, receiver) => {
+        return obj;
+    }, {});
+};
+const createProperty = (propName, initialValue, receiver, options) => {
     const value = initialValue;
     const valueIsPrimitive = (0, types_1.isPrimitive)(initialValue);
     const isObject = typeof initialValue === 'object';
     const isFunction = initialValue instanceof Function;
     const isNull = initialValue === null;
     const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special'));
+    const resolver = createResolver(options);
     const descriptor = (isObject && (value instanceof fields_1.FieldConstructor)) ?
         value
-        : Object.assign({ enumerable: true }, resolver[types](value, receiver));
+        :
+            {
+                enumerable: true,
+                ...resolver[types](value, receiver),
+            };
     const result = Reflect.defineProperty(receiver, propName, descriptor);
     return result;
 };
@@ -57,7 +65,7 @@ const props2skip = new Set([
 const util = require('util');
 const hasNodeInspect = (util && util.inspect && util.inspect.custom);
 (hasNodeInspect && (props2skip.add(util.inspect.custom)));
-const handlers = {
+const createHandlers = (options) => ({
     get(target, prop, receiver) {
         const result = Reflect.get(target, prop, receiver);
         if (result !== undefined) {
@@ -81,7 +89,7 @@ const handlers = {
         throw new Error(errorMessage);
     },
     set(_, prop, value, receiver) {
-        const result = createProperty(prop, value, receiver);
+        const result = createProperty(prop, value, receiver, options);
         return result;
     },
     setPrototypeOf() {
@@ -93,8 +101,7 @@ const handlers = {
     deleteProperty() {
         throw new Error('Properties Deletion is not allowed!');
     },
-};
-Object.freeze(handlers);
+});
 const baseTarget = (_proto) => {
     const proto = typeof _proto === 'object' ? _proto : null;
     const answer = Object.create(proto);
@@ -102,7 +109,7 @@ const baseTarget = (_proto) => {
 };
 exports.baseTarget = baseTarget;
 exports.SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference');
-const getTypeomaticaProxyReference = (_target) => {
+const getTypeomaticaProxyReference = (_target, options) => {
     const target = Object.create(_target);
     const id = `TypeØmaticaProxyReference-${Math.random()}`;
     Object.defineProperty(target, exports.SymbolTypeomaticaProxyReference, {
@@ -110,12 +117,13 @@ const getTypeomaticaProxyReference = (_target) => {
             return id;
         }
     });
+    const handlers = createHandlers(options);
     const proxy = new Proxy(target, handlers);
     return proxy;
 };
-exports.BaseConstructorPrototype = function (_target) {
+exports.BaseConstructorPrototype = function (_target, options) {
     if (!new.target) {
-        const self = exports.BaseConstructorPrototype.bind(this, _target);
+        const self = exports.BaseConstructorPrototype.bind(this, _target, options);
         self.prototype = {
             constructor: exports.BaseConstructorPrototype
         };
@@ -125,7 +133,7 @@ exports.BaseConstructorPrototype = function (_target) {
         return this;
     }
     const target = (0, exports.baseTarget)(_target);
-    const InstancePrototype = getTypeomaticaProxyReference(target);
+    const InstancePrototype = getTypeomaticaProxyReference(target, options);
     let proto;
     let protoPointer = this;
     let protoConstrcutor;
@@ -158,12 +166,12 @@ Object.defineProperty(module, 'exports', {
     enumerable: true
 });
 class BaseClass {
-    constructor(_target) {
+    constructor(_target, options) {
         if (this[exports.SymbolTypeomaticaProxyReference]) {
             return this;
         }
         const target = (0, exports.baseTarget)(_target);
-        const proxy = getTypeomaticaProxyReference(target);
+        const proxy = getTypeomaticaProxyReference(target, options);
         let proto = this;
         let protoPointer;
         let found = false;
@@ -179,13 +187,13 @@ class BaseClass {
     }
 }
 exports.BaseClass = BaseClass;
-const strict = function (_target) {
+const strict = function (_target, options) {
     const decorator = function (cstr) {
         if (cstr.prototype[exports.SymbolTypeomaticaProxyReference]) {
             return cstr;
         }
         const target = (0, exports.baseTarget)(_target);
-        const proxy = getTypeomaticaProxyReference(target);
+        const proxy = getTypeomaticaProxyReference(target, options);
         const _replacer = Object.create(proxy);
         Object.setPrototypeOf(cstr.prototype, _replacer);
         return cstr;
@@ -232,4 +240,4 @@ Object.defineProperty(module.exports, 'Strict', {
 });
 Object.freeze(exports.BaseConstructorPrototype);
 Object.freeze(exports.BaseConstructorPrototype.prototype);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// oxlint-disable typescript/no-this-alias\n/* eslint-disable no-debugger */\n'use strict';\n\nimport { ErrorsNames } from './errors';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types';\n\nimport { FieldConstructor } from './fields';\n\nconst resolver = Object.entries({\n\tprimitives,\n\tspecial,\n\tnullish,\n\tobjects,\n\tfunctions\n}).reduce((obj: object, [key, _handler]) => {\n\t// @ts-ignore\n\tobj[key] = function (initialValue: object, receiver: object) {\n\t\tconst handler = _handler(initialValue);\n\t\treturn {\n\t\t\tget() {\n\t\t\t\tconst invocationThis = this;\n\t\t\t\tif (invocationThis !== receiver) {\n\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t}\n\t\t\t\tconst result = handler.get();\n\t\t\t\treturn result;\n\t\t\t},\n\t\t\tset(replacementValue: unknown) {\n\t\t\t\tconst invocationThis = this;\n\t\t\t\tif (invocationThis !== receiver) {\n\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t}\n\t\t\t\tconst result = handler.set(replacementValue);\n\t\t\t\treturn result;\n\t\t\t}\n\t\t};\n\t};\n\n\treturn obj;\n}, {});\n\nconst createProperty = (propName: string, initialValue: unknown, receiver: object) => {\n\n\tconst value = initialValue;\n\tconst valueIsPrimitive = isPrimitive(initialValue);\n\tconst isObject = typeof initialValue === 'object';\n\tconst isFunction = initialValue instanceof Function;\n\tconst isNull = initialValue === null;\n\n\t/**\n\t * special: undefined or BigInt or Symbol\n\t * \tor other non constructible type\n\t */\n\n\tconst types = valueIsPrimitive ? 'primitives' : (\n\t\tisObject ? (\n\t\t\tisNull ? 'nullish' : 'objects'\n\t\t) : (\n\t\t\tisFunction ? 'functions' : 'special'\n\t\t)\n\t);\n\n\tconst descriptor = (isObject && (value instanceof FieldConstructor)) ?\n\t\tvalue\n\t\t:\n\t\t{\n\t\t\tenumerable: true,\n\t\t\t// @ts-ignore\n\t\t\t...resolver[types](value, receiver),\n\t\t};\n\n\t// if (value instanceof FieldConstructor) {\n\t// \tdescriptor;\n\t// \tdebugger;\n\t// }\n\n\tconst result = Reflect.defineProperty(receiver, propName, descriptor);\n\treturn result;\n\n};\n\n// line below 'href' is for util.inspect works, useful for v24\nconst props2skip = new Set([\n\tSymbol.toStringTag,\n\tSymbol.iterator,\n\t// Symbol.toPrimitive,\n\t'toString',\n\t'valueOf',\n\t'href'\n]);\n// const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);\nconst util = require('util');\nconst hasNodeInspect = (util && util.inspect && util.inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(util.inspect.custom)));\n\nconst handlers = {\n\tget(target: object, prop: string | symbol, receiver: object) {\n\t\tconst result = Reflect.get(target, prop, receiver);\n\t\tif (result !== undefined) {\n\t\t\treturn result;\n\t\t}\n\t\tif (prop === 'toJSON') {\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\treturn function (this: typeof target) {\n\t\t\t\tconst entries = Object.entries(this);\n\t\t\t\treturn JSON.stringify(entries.reduce((obj, [key, value]) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tobj[key] = value.valueOf();\n\t\t\t\t\treturn obj;\n\t\t\t\t}, {}));\n\t\t\t};\n\t\t}\n\t\tconst { name } = receiver.constructor;\n\t\tif (props2skip.has(prop)) {\n\t\t\tconst message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`;\n\t\t\treturn message;\n\t\t}\n\t\tconst errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\tthrow new Error(errorMessage);\n\t},\n\tset(_: object, prop: string, value: unknown, receiver: object) {\n\t\tconst result = createProperty(prop, value, receiver);\n\t\treturn result;\n\t},\n\tsetPrototypeOf() {\n\t\tthrow new Error('Setting prototype is not allowed!');\n\t},\n\t// defineProperty(target: object, key: string, descriptor: object) {\n\tdefineProperty() {\n\t\tthrow new Error('Defining new Properties is not allowed!');\n\t\t// Reflect.defineProperty(target, key, descriptor);\n\t},\n\tdeleteProperty() {\n\t\tthrow new Error('Properties Deletion is not allowed!');\n\t},\n\t// getPrototypeOf() {\n\t// \tdebugger;\n\t// \tthrow new Error('Getting prototype is not allowed');\n\t// },\n};\n\nObject.freeze(handlers);\n\n// user have to precisely define all props\nexport const baseTarget = (_proto?: object) => {\n\tconst proto = typeof _proto === 'object' ? _proto : null;\n\tconst answer = Object.create(proto);\n\treturn answer;\n};\n\nexport const SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference');\nconst getTypeomaticaProxyReference = (_target: object) => {\n\tconst target = Object.create(_target);\n\tconst id = `TypeØmaticaProxyReference-${Math.random()}`;\n\tObject.defineProperty(target, SymbolTypeomaticaProxyReference, {\n\t\tget() {\n\t\t\treturn id;\n\t\t}\n\t});\n\tconst proxy = new Proxy(target, handlers);\n\treturn proxy;\n};\n\n\nexport const BaseConstructorPrototype = function <T extends object, S extends T>(this: S extends T ? S : {}, _target?: T ): T {\n\tif (!new.target) {\n\n\t\tconst self: {\n\t\t\tprototype: {\n\t\t\t\tconstructor: typeof BaseConstructorPrototype\n\t\t\t}\n\t\t\t//@ts-ignore\n\t\t} = BaseConstructorPrototype.bind(this, _target);\n\n\t\tself.prototype = {\n\t\t\tconstructor: BaseConstructorPrototype\n\t\t};\n\n\t\t// @ts-ignore\n\t\treturn self;\n\n\t}\n\n\t// @ts-ignore\n\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t// @ts-ignore\n\t\treturn this;\n\t}\n\n\tconst target = baseTarget(_target) as object;\n\n\tconst InstancePrototype = getTypeomaticaProxyReference(target);\n\n\tlet proto;\n\tlet protoPointer = this as object;\n\tlet protoConstrcutor;\n\n\tlet constructors = false;\n\n\t// @ts-ignore\n\t// const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean;\n\t// if (hasProxyReference) {\n\t// \tthrow new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!');\n\t// }\n\n\tdo {\n\t\tproto = protoPointer;\n\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\tif (BaseConstructorPrototype.prototype === protoPointer) {\n\t\t\tconstructors = true;\n\t\t\tbreak;\n\t\t}\n\t\tif (!protoPointer) break;\n\t\tconst descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor');\n\t\tif (!descriptor) continue;\n\t\tconst value = descriptor.value || descriptor.get;\n\t\t// if (!value) continue;\n\t\tprotoConstrcutor = value;\n\t} while (protoConstrcutor !== BaseConstructorPrototype);\n\n\tif (!constructors && protoConstrcutor !== BaseConstructorPrototype) {\n\t\tthrow new Error('Unable to setup TypeØmatica handler!');\n\t}\n\n\tObject.setPrototypeOf(proto, InstancePrototype);\n\t// @ts-ignore\n\treturn this;\n\n} as {\n\tnew<T extends object | {}>(_target?: T): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer S ? S : {}): S\n};\n\nObject.defineProperty(module, 'exports', {\n\tget() {\n\t\treturn BaseConstructorPrototype;\n\t},\n\tenumerable: true\n});\n\nexport class BaseClass {\n\tconstructor(_target?: object) {\n\t\t// @ts-ignore\n\t\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn this;\n\t\t}\n\n\t\tconst target = baseTarget(_target) as object;\n\t\tconst proxy = getTypeomaticaProxyReference(target);\n\t\tlet proto: object | null = this;\n\t\tlet protoPointer: object | null;\n\t\tlet found: boolean = false;\n\t\tdo {\n\t\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\t\t// if (protoPointer[SymbolTypeomaticaProxyReference]) {\n\t\t\t// \tthrow new Error('Double TypeØmatica extension is not allowed!');\n\t\t\t// }\n\t\t\tif (protoPointer === Object.prototype) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/*\n\t\t\t// it can be, that protoPointer === null\n\t\t\t// though too hard to implement this test\n\t\t\t*/\n\t\t\tproto = protoPointer;\n\t\t} while (!found);\n\t\tObject.setPrototypeOf(proto, proxy);\n\t}\n}\n\n\nconst strict = function (_target?: object) {\n\tconst decorator = function<T>(cstr: T): T {\n\n\t\t// @ts-ignore\n\t\tif (cstr.prototype[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn cstr;\n\t\t}\n\n\t\tconst target = baseTarget(_target);\n\t\tconst proxy = getTypeomaticaProxyReference(target);\n\t\tconst _replacer = Object.create(proxy);\n\n\t\t// @ts-ignore\n\t\tObject.setPrototypeOf(cstr.prototype, _replacer);\n\n\t\treturn cstr;\n\n\n\t\t// const MyClassProxy = new Proxy(cstr, {\n\t\t// \tconstruct(_, argumentsList, newTarget) {\n\t\t// \t\tdebugger;\n\t\t// \t\tconst target = baseTarget(_target);\n\t\t// \t\tconst proxy = getTypeomaticaProxyReference(target);\n\t\t// \t\tconst _replacer = Object.create(proxy);\n\n\t\t// \t\tconst _proto = cstr.prototype;\n\n\t\t// \t\tconst proto = Object.create(Object.getPrototypeOf(_proto));\n\t\t// \t\tproto.iAmProto = true;\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\n\t\t// \t\tconst descriptors = Object.getOwnPropertyDescriptors(_proto);\n\t\t// \t\tObject.defineProperties(proto, descriptors);\n\n\t\t// \t\tconst replacer = Object.create(_replacer);\n\t\t// \t\tObject.setPrototypeOf(proto, replacer);\n\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\t\t// \t\tconst result = Reflect.construct(cstr, argumentsList, newTarget);\n\n\t\t// \t\tdebugger;\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, _proto);\n\t\t// \t\tdebugger;\n\n\t\t// \t\treturn result;\n\t\t// \t},\n\t\t// });\n\t\t// return MyClassProxy;\n\t};\n\n\treturn decorator;\n\n};\nexport const { SymbolInitialValue } = FieldConstructor;\nexport const Strict = strict;\n\nObject.defineProperty(module.exports, 'BaseClass', {\n\tget() {\n\t\treturn BaseClass;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'FieldConstructor', {\n\tget() {\n\t\treturn FieldConstructor;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\tget() {\n\t\treturn SymbolInitialValue;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\tget() {\n\t\treturn SymbolTypeomaticaProxyReference;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'baseTarget', {\n\tget() {\n\t\treturn baseTarget;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'Strict', {\n\tget() {\n\t\treturn strict;\n\t},\n\tenumerable: true\n});\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// oxlint-disable typescript/no-this-alias\n/* eslint-disable no-debugger */\n'use strict';\n\nimport { ErrorsNames } from './errors';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types';\n\nimport { FieldConstructor } from './fields';\n\nexport interface TypeomaticaOptions {\n\tstrictAccessCheck?: boolean;\n}\n\nconst createResolver = (options: TypeomaticaOptions = {}) => {\n\tconst { strictAccessCheck = false } = options;\n\t\n\treturn Object.entries({\n\t\tprimitives,\n\t\tspecial,\n\t\tnullish,\n\t\tobjects,\n\t\tfunctions\n\t}).reduce((obj: object, [key, _handler]) => {\n\t\t// @ts-ignore\n\t\tobj[key] = function (initialValue: object, receiver: object) {\n\t\t\tconst handler = _handler(initialValue);\n\t\t\treturn {\n\t\t\t\tget() {\n\t\t\t\t\tconst invocationThis = this;\n\t\t\t\t\tif (strictAccessCheck && invocationThis !== receiver) {\n\t\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t\t}\n\t\t\t\t\tconst result = handler.get();\n\t\t\t\t\treturn result;\n\t\t\t\t},\n\t\t\t\tset(replacementValue: unknown) {\n\t\t\t\t\tconst invocationThis = this;\n\t\t\t\t\tif (strictAccessCheck && invocationThis !== receiver) {\n\t\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t\t}\n\t\t\t\t\tconst result = handler.set(replacementValue);\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\t\t\t};\n\t\t};\n\n\t\treturn obj;\n\t}, {});\n};\n\nconst createProperty = (propName: string, initialValue: unknown, receiver: object, options?: TypeomaticaOptions) => {\n\n\tconst value = initialValue;\n\tconst valueIsPrimitive = isPrimitive(initialValue);\n\tconst isObject = typeof initialValue === 'object';\n\tconst isFunction = initialValue instanceof Function;\n\tconst isNull = initialValue === null;\n\n\t/**\n\t * special: undefined or BigInt or Symbol\n\t * \tor other non constructible type\n\t */\n\n\tconst types = valueIsPrimitive ? 'primitives' : (\n\t\tisObject ? (\n\t\t\tisNull ? 'nullish' : 'objects'\n\t\t) : (\n\t\t\tisFunction ? 'functions' : 'special'\n\t\t)\n\t);\n\n\tconst resolver = createResolver(options);\n\n\tconst descriptor = (isObject && (value instanceof FieldConstructor)) ?\n\t\tvalue\n\t\t:\n\t\t{\n\t\t\tenumerable: true,\n\t\t\t// @ts-ignore\n\t\t\t...resolver[types](value, receiver),\n\t\t};\n\n\t// if (value instanceof FieldConstructor) {\n\t// \tdescriptor;\n\t// \tdebugger;\n\t// }\n\n\tconst result = Reflect.defineProperty(receiver, propName, descriptor);\n\treturn result;\n\n};\n\n// line below 'href' is for util.inspect works, useful for v24\nconst props2skip = new Set([\n\tSymbol.toStringTag,\n\tSymbol.iterator,\n\t// Symbol.toPrimitive,\n\t'toString',\n\t'valueOf',\n\t'href'\n]);\n// const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);\nconst util = require('util');\nconst hasNodeInspect = (util && util.inspect && util.inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(util.inspect.custom)));\n\nconst createHandlers = (options?: TypeomaticaOptions) => ({\n\tget(target: object, prop: string | symbol, receiver: object) {\n\t\tconst result = Reflect.get(target, prop, receiver);\n\t\tif (result !== undefined) {\n\t\t\treturn result;\n\t\t}\n\t\tif (prop === 'toJSON') {\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\treturn function (this: typeof target) {\n\t\t\t\tconst entries = Object.entries(this);\n\t\t\t\treturn JSON.stringify(entries.reduce((obj, [key, value]) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tobj[key] = value.valueOf();\n\t\t\t\t\treturn obj;\n\t\t\t\t}, {}));\n\t\t\t};\n\t\t}\n\t\tconst { name } = receiver.constructor;\n\t\tif (props2skip.has(prop)) {\n\t\t\tconst message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`;\n\t\t\treturn message;\n\t\t}\n\t\tconst errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\tthrow new Error(errorMessage);\n\t},\n\tset(_: object, prop: string, value: unknown, receiver: object) {\n\t\tconst result = createProperty(prop, value, receiver, options);\n\t\treturn result;\n\t},\n\tsetPrototypeOf() {\n\t\t\tthrow new Error('Setting prototype is not allowed!');\n\t},\n\t// defineProperty(target: object, key: string, descriptor: object) {\n\tdefineProperty() {\n\t\t\tthrow new Error('Defining new Properties is not allowed!');\n\t\t// Reflect.defineProperty(target, key, descriptor);\n\t},\n\tdeleteProperty() {\n\t\t\tthrow new Error('Properties Deletion is not allowed!');\n\t},\n\t// getPrototypeOf() {\n\t// \tdebugger;\n\t// \tthrow new Error('Getting prototype is not allowed');\n\t// },\n});\n\n// user have to precisely define all props\nexport const baseTarget = (_proto?: object) => {\n\tconst proto = typeof _proto === 'object' ? _proto : null;\n\tconst answer = Object.create(proto);\n\treturn answer;\n};\n\nexport const SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference');\nconst getTypeomaticaProxyReference = (_target: object, options?: TypeomaticaOptions) => {\n\tconst target = Object.create(_target);\n\tconst id = `TypeØmaticaProxyReference-${Math.random()}`;\n\tObject.defineProperty(target, SymbolTypeomaticaProxyReference, {\n\t\tget() {\n\t\t\treturn id;\n\t\t}\n\t});\n\tconst handlers = createHandlers(options);\n\tconst proxy = new Proxy(target, handlers);\n\treturn proxy;\n};\n\n\nexport const BaseConstructorPrototype = function <T extends object, S extends T>(this: S extends T ? S : {}, _target?: T, options?: TypeomaticaOptions ): T {\n\tif (!new.target) {\n\n\t\tconst self: {\n\t\t\tprototype: {\n\t\t\t\tconstructor: typeof BaseConstructorPrototype\n\t\t\t}\n\t\t\t//@ts-ignore\n\t\t} = BaseConstructorPrototype.bind(this, _target, options);\n\n\t\tself.prototype = {\n\t\t\tconstructor: BaseConstructorPrototype\n\t\t};\n\n\t\t// @ts-ignore\n\t\treturn self;\n\n\t}\n\n\t// @ts-ignore\n\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t// @ts-ignore\n\t\treturn this;\n\t}\n\n\tconst target = baseTarget(_target) as object;\n\n\tconst InstancePrototype = getTypeomaticaProxyReference(target, options);\n\n\tlet proto;\n\tlet protoPointer = this as object;\n\tlet protoConstrcutor;\n\n\tlet constructors = false;\n\n\t// @ts-ignore\n\t// const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean;\n\t// if (hasProxyReference) {\n\t// \tthrow new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!');\n\t// }\n\n\tdo {\n\t\tproto = protoPointer;\n\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\tif (BaseConstructorPrototype.prototype === protoPointer) {\n\t\t\tconstructors = true;\n\t\t\tbreak;\n\t\t}\n\t\tif (!protoPointer) break;\n\t\tconst descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor');\n\t\tif (!descriptor) continue;\n\t\tconst value = descriptor.value || descriptor.get;\n\t\t// if (!value) continue;\n\t\tprotoConstrcutor = value;\n\t} while (protoConstrcutor !== BaseConstructorPrototype);\n\n\tif (!constructors && protoConstrcutor !== BaseConstructorPrototype) {\n\t\tthrow new Error('Unable to setup TypeØmatica handler!');\n\t}\n\n\tObject.setPrototypeOf(proto, InstancePrototype);\n\t// @ts-ignore\n\treturn this;\n\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer S ? S : {}, options?: TypeomaticaOptions): S\n};\n\nObject.defineProperty(module, 'exports', {\n\tget() {\n\t\treturn BaseConstructorPrototype;\n\t},\n\tenumerable: true\n});\n\nexport class BaseClass {\n\tconstructor(_target?: object, options?: TypeomaticaOptions) {\n\t\t// @ts-ignore\n\t\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn this;\n\t\t}\n\n\t\tconst target = baseTarget(_target) as object;\n\t\tconst proxy = getTypeomaticaProxyReference(target, options);\n\t\tlet proto: object | null = this;\n\t\tlet protoPointer: object | null;\n\t\tlet found: boolean = false;\n\t\tdo {\n\t\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\t\t// if (protoPointer[SymbolTypeomaticaProxyReference]) {\n\t\t\t// \tthrow new Error('Double TypeØmatica extension is not allowed!');\n\t\t\t// }\n\t\t\tif (protoPointer === Object.prototype) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/*\n\t\t\t// it can be, that protoPointer === null\n\t\t\t// though too hard to implement this test\n\t\t\t*/\n\t\t\tproto = protoPointer;\n\t\t} while (!found);\n\t\tObject.setPrototypeOf(proto, proxy);\n\t}\n}\n\n\nconst strict = function (_target?: object, options?: TypeomaticaOptions) {\n\tconst decorator = function<T>(cstr: T): T {\n\n\t\t// @ts-ignore\n\t\tif (cstr.prototype[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn cstr;\n\t\t}\n\n\t\tconst target = baseTarget(_target);\n\t\tconst proxy = getTypeomaticaProxyReference(target, options);\n\t\tconst _replacer = Object.create(proxy);\n\n\t\t// @ts-ignore\n\t\tObject.setPrototypeOf(cstr.prototype, _replacer);\n\n\t\treturn cstr;\n\n\n\t\t// const MyClassProxy = new Proxy(cstr, {\n\t\t// \tconstruct(_, argumentsList, newTarget) {\n\t\t// \t\tdebugger;\n\t\t// \t\tconst target = baseTarget(_target);\n\t\t// \t\tconst proxy = getTypeomaticaProxyReference(target);\n\t\t// \t\tconst _replacer = Object.create(proxy);\n\n\t\t// \t\tconst _proto = cstr.prototype;\n\n\t\t// \t\tconst proto = Object.create(Object.getPrototypeOf(_proto));\n\t\t// \t\tproto.iAmProto = true;\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\n\t\t// \t\tconst descriptors = Object.getOwnPropertyDescriptors(_proto);\n\t\t// \t\tObject.defineProperties(proto, descriptors);\n\n\t\t// \t\tconst replacer = Object.create(_replacer);\n\t\t// \t\tObject.setPrototypeOf(proto, replacer);\n\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\t\t// \t\tconst result = Reflect.construct(cstr, argumentsList, newTarget);\n\n\t\t// \t\tdebugger;\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, _proto);\n\t\t// \t\tdebugger;\n\n\t\t// \t\treturn result;\n\t\t// \t},\n\t\t// });\n\t\t// return MyClassProxy;\n\t};\n\n\treturn decorator;\n\n};\nexport const { SymbolInitialValue } = FieldConstructor;\nexport const Strict = strict;\n\nObject.defineProperty(module.exports, 'BaseClass', {\n\tget() {\n\t\treturn BaseClass;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'FieldConstructor', {\n\tget() {\n\t\treturn FieldConstructor;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\tget() {\n\t\treturn SymbolInitialValue;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\tget() {\n\t\treturn SymbolTypeomaticaProxyReference;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'baseTarget', {\n\tget() {\n\t\treturn baseTarget;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'Strict', {\n\tget() {\n\t\treturn strict;\n\t},\n\tenumerable: true\n});\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typeomatica",
-	"version": "0.3.55",
+	"version": "0.3.57",
 	"description": "type logic against javascript metaprogramming",
 	"engines": {
 		"node": ">=16"
@@ -24,12 +24,12 @@
 		"build": "lib/"
 	},
 	"scripts": {
-		"build": "rm -rf ./lib && npx tsc --target es6 --pretty",
+		"build": "rm -rf ./lib && npx tsc --target esnext --pretty",
 		"lint:lib": "npx eslint --fix ./lib",
 		"lint:src": "npx eslint --fix ./src",
 		"test": "npx jest",
 		"test:cov": "npx jest --collectCoverage",
-		"test:addition": "npm run build && node --test --experimental-test-coverage  ./test/addition.js",
+		"test:addition": "node --test --experimental-test-coverage  ./test/noJest.ts",
 		"debug:on-issues": "echo 'if debugger; command is not working try other Node.JS version'",
 		"debug": "node --inspect-brk --nolazy node_modules/.bin/jest --runInBand --detectOpenHandles",
 		"debug:jest": "node --nolazy --inspect-brk ./node_modules/jest/bin/jest.js --runInBand --colors --verbose",