diff --git a/AGENTS.md b/AGENTS.md index 334982c..519f9f4 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,6 +32,8 @@ npm run lint:src # ESLint on src/ npm run lint:lib # ESLint on lib/ ``` +Documentation-only changes (`.md` files) do not require running tests or linters. + ## Module architecture - CJS consumers get `lib/index.js` via `main` / `exports.require`. @@ -54,6 +56,66 @@ npm run lint:lib # ESLint on lib/ - Class properties that should be type-checked must be declared with `declare prop: Type;` and assigned inside the constructor. Initialized class fields (`prop: Type = value`) bypass the Proxy. - `src/esm.ts` must not introduce new runtime logic; it only re-exports. +## Prototype wiring internals + +Understanding how the proxy is attached prevents accidental prototype pollution or coverage regressions. + +### `BaseClass` + +The constructor checks whether the instance already reaches a TypeØmatica proxy through its prototype chain. If it does, it returns immediately. + +Otherwise it walks up the prototype chain until it finds the class that directly extends `BaseClass` and installs the proxy there. This keeps intermediate classes intact. For `class C extends B extends A extends BaseClass` the resulting chain is: + +``` +instance → C.prototype → B.prototype → A.prototype → proxy → target +``` + +Every class prototype in that chain (`C.prototype`, `B.prototype`, and `A.prototype`) is frozen by default, so none of them can be reassigned or grow new properties at runtime. Pass `{ frozenPrototypes: false }` in `TypeomaticaOptions` to keep them mutable. + +For a direct subclass `class X extends BaseClass` the walk stops immediately: + +``` +instance → X.prototype → proxy → target +``` + +For a direct `new BaseClass(...)` call the instance itself is wired and `BaseClass.prototype` is frozen, but not mutated into a proxy. + +### `BaseConstructorPrototype` + +In constructor mode the function walks the instance's prototype chain until it reaches `BaseConstructorPrototype.prototype` (or a prototype whose `constructor` is `BaseConstructorPrototype`). The object just before that stopping point is treated as the class prototype: + +``` +instance → DerivedClass.prototype → BaseConstructorPrototype.prototype +``` + +It sets `DerivedClass.prototype.__proto__` to the proxy and freezes `DerivedClass.prototype` by default (configurable via `frozenPrototypes: false`): + +``` +instance → DerivedClass.prototype → proxy → target +``` + +For a direct `new BaseConstructorPrototype(...)` call there is no derived class, so the instance itself becomes the wired object and `BaseConstructorPrototype.prototype` is frozen as the class prototype. + +### `@Strict()` decorator + +At decoration time it reparents the class prototype to a plain object that itself inherits from the proxy, then freezes the class prototype by default (configurable via `frozenPrototypes: false`): + +``` +Class.prototype → plainReplacer → proxy → target +``` + +The extra plain replacer exists because the class already owns its methods and accessors on `Class.prototype`; the proxy only needs to handle missing properties. + +### Direct extension + +`class MyClass extends BaseConstructorPrototype {}` is valid, but after the first instance the chain becomes: + +``` +MyClass.prototype → proxy → target → null +``` + +Therefore `instanceof BaseConstructorPrototype` will be `false` after wiring. The factory form `class MyClass extends BasePrototype({...})` is the preferred API. + ## What to discuss before changing - Proxy handler logic in `createHandlers()`. diff --git a/FOR_HUMANS.md b/FOR_HUMANS.md index 051641b..50fb85c 100644 --- a/FOR_HUMANS.md +++ b/FOR_HUMANS.md @@ -71,6 +71,18 @@ class User extends BaseClass { Or use `FieldConstructor` if you need custom getters/setters. +## Three ways to attach it + +TypeØmatica gives you three APIs that all put a Proxy on your class prototype chain and then freeze that prototype. Pick whichever fits your existing code shape. + +| API | Looks like | When it wires | Initial state | Best for | +|---|---|---|---|---| +| `BaseClass` | `class X extends BaseClass { ... }` | First instance constructed | Per instance via `super({...})` | Modern class-based code | +| `BasePrototype` | `class X extends BasePrototype({...}) { ... }` or `const X = BasePrototype({...})` | First instance constructed | Bound at class/factory creation | Function constructors or factory-returned constructors | +| `@Strict()` | `@Strict({...}) class X { ... }` | When the class is decorated | Bound at decoration | Existing classes you do not want to `extend` | + +The behavior is the same: after a property is assigned, its type is locked, and attempts to mutate the prototype or add new properties to it are rejected. + ## Five-minute example ```typescript diff --git a/README.md b/README.md index 3736c0c..8c0ea9e 100644 --- a/README.md +++ b/README.md @@ -153,11 +153,93 @@ TypeØmatica wraps objects with JavaScript Proxies that intercept: --- +## The Three Entry Points + +TypeØmatica exposes three APIs that all do the same underlying thing — attach a Proxy to a prototype chain so property writes are type-checked and the class prototype is frozen. They differ in how you create and attach that prototype. + +| | `BaseClass` | `BasePrototype` / `BaseConstructorPrototype` | `@Strict()` | +|---|---|---|---| +| **How you use it** | `class X extends BaseClass { ... }` | `class X extends BasePrototype({...}) { ... }` or `const X = BasePrototype({...})` | `@Strict({...}) class X { ... }` | +| **Wiring moment** | First time an instance is constructed | First time an instance is constructed | When the class is decorated (module load) | +| **Initial state** | Can pass a *new* target per instance via `super({...})` | Target is bound at class/factory creation; `super(...)` args are ignored because the constructor is bound | Target/options are bound at decoration | +| **Prototype chain shape** | `X.prototype → … → classDirectlyExtendingBase.prototype → proxy → target` | `X.prototype → proxy → target` (class usage) | `X.prototype → plain replacer → proxy → target` | +| **Function-constructor support** | No | Yes — `BasePrototype` can return a constructor function | No | +| **Default export?** | No, it is a named export/property | Yes, `require('typeomatica')` is `BaseConstructorPrototype` | No, exported as `Strict` | + +### 1. `BaseConstructorPrototype` (default export) — manual prototype manipulation + +`BaseConstructorPrototype` is the lowest-level API. It returns an instance that is designed to be assigned as the prototype of an existing constructor function using `Object.setPrototypeOf`. + +```typescript +import BasePrototype from 'typeomatica'; + +const MyConstructor = function (this: { value: number }) { + this.value = 0; +}; + +const baseProto = new BasePrototype({ value: 0 }); +Object.setPrototypeOf(MyConstructor.prototype, baseProto); + +const instance = new MyConstructor(); +instance.value = 42; // ✓ Works +// @ts-ignore +instance.value = '42'; // ✗ TypeError: Type Mismatch +``` + +Use this when you already have a constructor function and need to inject type checking into its prototype chain manually, or when you want a factory that returns a constructor function. + +### 2. `BaseClass` — `extends` + +`BaseClass` is the same mechanism wrapped in a class. When you `extends BaseClass`, TypeØmatica internally sets the proxy prototype for you. + +```typescript +import { BaseClass } from 'typeomatica'; + +class MyClass extends BaseClass { + declare value: number; + constructor() { + super({ value: 0 }); + this.value = this.value; + } +} +``` + +`super()` accepts an optional initial-state object and `TypeomaticaOptions`. Because the proxy target is set up during `super()`, you usually re-assign the inherited values inside the constructor (as shown above) so they pass through the proxy and become type-locked. Unlike `BasePrototype`, `BaseClass` lets you pass a *new* initial-state object per instance. + +### 3. `@Strict()` — decorator + +`@Strict()` does the same prototype injection but as a class decorator. It accepts the same optional arguments as `BaseConstructorPrototype`: + +- First argument: initial-state object (`{ starterProp: value }`). +- Second argument: `TypeomaticaOptions` (e.g., `{ strictAccessCheck: true }`). + +```typescript +import { Strict } from 'typeomatica'; + +@Strict({ value: 0 }, { strictAccessCheck: true }) +class MyClass { + declare value: number; + constructor() { + this.value = 0; + } +} +``` + +Use `@Strict()` when you want a clean class decorator and need to pass initial state or options without changing the class `extends` clause. + +### Which one should I use? + +- Use **`BaseClass`** for modern `extends`-based classes, especially when you want per-instance initial state through `super({...})`. +- Use **`BasePrototype(...)`** when you need a factory that returns a constructor, or when working with function constructors. +- Use **`@Strict()`** when you want to Typeømatica-wrap an existing class without changing its `extends` clause. + +--- + ## API Reference ### BaseClass -The primary class for strict-type objects. +The primary class for strict-type objects. `super()` accepts an optional initial-state object and `TypeomaticaOptions`. ```typescript import { BaseClass } from 'typeomatica'; @@ -165,15 +247,17 @@ import { BaseClass } from 'typeomatica'; class MyClass extends BaseClass { declare field: string; constructor() { - super(); - this.field = 'value'; + super({ field: 'value' }); + this.field = this.field; } } ``` ### BaseConstructorPrototype (default export) -Functional equivalent of `BaseClass`. The default export of the package is `BaseConstructorPrototype`, which can be called without `new` to produce a base constructor. +Functional equivalent of `BaseClass`. The default export of the package is `BaseConstructorPrototype`. + +**Form 1 — call without `new` to get a base constructor:** ```typescript import BasePrototype from 'typeomatica'; @@ -183,6 +267,21 @@ const Base = BasePrototype({ initialProp: 123 }); class MyClass extends Base { } ``` +**Form 2 — call with `new` to get a prototype object for `Object.setPrototypeOf`:** + +```typescript +import BasePrototype from 'typeomatica'; + +const MyConstructor = function (this: { initialProp: number }) { + this.initialProp = 0; +}; + +const baseProto = new BasePrototype({ initialProp: 123 }); +Object.setPrototypeOf(MyConstructor.prototype, baseProto); + +const instance = new MyConstructor(); +``` + ### @Strict() Decorator Apply strict typing without extending BaseClass. @@ -415,11 +514,13 @@ const doubled = registers.count.valueOf() * 2; ```typescript interface TypeomaticaOptions { strictAccessCheck?: boolean; // default: false + frozenPrototypes?: boolean; // default: true } ``` **Options:** - `strictAccessCheck: true` - Enables strict receiver checking (throws `ACCESS_DENIED` error when property is accessed from wrong context) +- `frozenPrototypes: false` - Keeps class prototypes mutable so methods/properties can be added at runtime (foot-gun allowed) ### Usage with Options @@ -451,6 +552,16 @@ class Product { this.price = 0; } } + +// With BaseClass - allow runtime prototype mutation (not recommended) +class ExtensibleBase extends BaseClass { + declare value: number; + constructor() { + super(undefined, { frozenPrototypes: false }); + this.value = 0; + } +} +ExtensibleBase.prototype.helper = () => 'ok'; ``` ### Symbol Exports diff --git a/lib/esm/fields.d.ts b/lib/esm/fields.d.ts index 1fceeb5..049a9b8 100644 --- a/lib/esm/fields.d.ts +++ b/lib/esm/fields.d.ts @@ -3,10 +3,10 @@ interface FieldDefinition { [SymbolInitialValue]: unknown; } export declare class FieldConstructor implements FieldDefinition { - [SymbolInitialValue]: unknown; - get get(): () => unknown; - get set(): () => never; - constructor(value: unknown); - static get SymbolInitialValue(): symbol; + [SymbolInitialValue]: unknown; + get get(): () => unknown; + get set(): () => never; + constructor(value: unknown); + static get SymbolInitialValue(): symbol; } export {}; diff --git a/lib/esm/index.d.ts b/lib/esm/index.d.ts index dcf8bc1..4a25d32 100644 --- a/lib/esm/index.d.ts +++ b/lib/esm/index.d.ts @@ -1,6 +1,7 @@ import { FieldConstructor } from './fields.js'; export interface TypeomaticaOptions { strictAccessCheck?: boolean; + frozenPrototypes?: boolean; } export declare const baseTarget: (_proto?: object) => any; export declare const SymbolTypeomaticaProxyReference: unique symbol; @@ -9,7 +10,7 @@ export declare const BaseConstructorPrototype: { (_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S; }; export declare class BaseClass { - constructor(_target?: object, options?: TypeomaticaOptions); + constructor(_target?: object, options?: TypeomaticaOptions); } export declare const SymbolInitialValue: symbol; declare const FieldConstructorExport: typeof FieldConstructor; diff --git a/lib/esm/index.js b/lib/esm/index.js index 003ca6f..8edcd60 100644 --- a/lib/esm/index.js +++ b/lib/esm/index.js @@ -93,6 +93,9 @@ const createHandlers = (options) => ({ }, {})); }; } + if (prop === 'constructor') { + return undefined; + } const { name } = receiver.constructor; if (props2skip.has(prop)) { const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; @@ -155,7 +158,9 @@ export const BaseConstructorPrototype = function (_target, options) { return this; } const target = baseTarget(_target); + const { frozenPrototypes: freezeProtos = true } = options || {}; const InstancePrototype = getTypeomaticaProxyReference(target, options); + const classPrototype = Object.getPrototypeOf(this); let proto; let protoPointer = this; let protoConstrcutor; @@ -185,41 +190,64 @@ export const BaseConstructorPrototype = function (_target, options) { throw new Error('Unable to setup TypeØmatica handler!'); } Object.setPrototypeOf(proto, InstancePrototype); + if (freezeProtos) { + Object.freeze(classPrototype); + } // @ts-ignore return this; }; +const freezeClassPrototypes = (instance, shouldFreeze) => { + if (!shouldFreeze) { + return; + } + const first = Object.getPrototypeOf(instance); + const firstIsProxy = first !== null && !!Reflect.getOwnPropertyDescriptor(first, SymbolTypeomaticaProxyReference); + if (firstIsProxy) { + Object.freeze(BaseClass.prototype); + return; + } + let p = first; + while (p !== null && p !== BaseClass.prototype && p !== Object.prototype) { + const next = Object.getPrototypeOf(p); + const nextIsProxy = next !== null && !!Reflect.getOwnPropertyDescriptor(next, SymbolTypeomaticaProxyReference); + Object.freeze(p); + if (nextIsProxy) { + break; + } + p = next; + } + Object.freeze(BaseClass.prototype); +}; export class BaseClass { constructor(_target, options) { + const { frozenPrototypes: freezeProtos = true } = options || {}; // @ts-ignore if (this[SymbolTypeomaticaProxyReference]) { + freezeClassPrototypes(this, freezeProtos); return this; } const target = baseTarget(_target); const proxy = getTypeomaticaProxyReference(target, options); - let proto = this; - let protoPointer; - let found = false; - do { - protoPointer = Object.getPrototypeOf(proto); - // if (protoPointer[SymbolTypeomaticaProxyReference]) { - // throw new Error('Double TypeØmatica extension is not allowed!'); - // } - if (protoPointer === Object.prototype) { - found = true; - break; - } - /* - // it can be, that protoPointer === null - // though too hard to implement this test - */ - proto = protoPointer; - } while (!found); - Object.setPrototypeOf(proto, proxy); + const instanceProto = Object.getPrototypeOf(this); + if (instanceProto === BaseClass.prototype) { + Object.setPrototypeOf(this, proxy); + freezeClassPrototypes(this, freezeProtos); + return this; + } + let classProto = instanceProto; + let parentProto = Object.getPrototypeOf(classProto); + while (parentProto !== BaseClass.prototype && parentProto !== null) { + classProto = parentProto; + parentProto = Object.getPrototypeOf(classProto); + } + Object.setPrototypeOf(classProto, proxy); + freezeClassPrototypes(this, freezeProtos); } } const strict = function (_target, options) { + const { frozenPrototypes: freezeProtos = true } = options || {}; const decorator = function (cstr) { // @ts-ignore if (cstr.prototype[SymbolTypeomaticaProxyReference]) { @@ -230,6 +258,10 @@ const strict = function (_target, options) { const _replacer = Object.create(proxy); // @ts-ignore Object.setPrototypeOf(cstr.prototype, _replacer); + if (freezeProtos) { + // @ts-ignore + Object.freeze(cstr.prototype); + } return cstr; // const MyClassProxy = new Proxy(cstr, { // construct(_, argumentsList, newTarget) { @@ -312,4 +344,4 @@ function setupCommonJS() { setupCommonJS(); Object.freeze(BaseConstructorPrototype); Object.freeze(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 \n'use strict';\n\nimport { inspect } from 'util';\nimport { ErrorsNames } from './errors.js';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types/index.js';\n\nimport { FieldConstructor } from './fields.js';\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\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 hasNodeInspect = (inspect && inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(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\t// const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\t// throw 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\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\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/* eslint-disable no-unused-vars */\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S\n};\n/* eslint-enable no-unused-vars */\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;\nconst FieldConstructorExport = FieldConstructor;\nexport { FieldConstructorExport as FieldConstructor };\nexport const Strict = strict;\n\n/* istanbul ignore next */\nfunction setupCommonJS() {\n\tif (typeof module === 'undefined' || typeof module.exports === 'undefined') {\n\t\treturn;\n\t}\n\tObject.defineProperty(module, 'exports', {\n\t\tget() {\n\t\t\treturn BaseConstructorPrototype;\n\t\t},\n\t\tenumerable: true\n\t});\n\n\tObject.defineProperty(module.exports, 'BaseClass', {\n\t\tget() {\n\t\t\treturn BaseClass;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'FieldConstructor', {\n\t\tget() {\n\t\t\treturn FieldConstructor;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\t\tget() {\n\t\t\treturn SymbolInitialValue;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\t\tget() {\n\t\t\treturn SymbolTypeomaticaProxyReference;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'baseTarget', {\n\t\tget() {\n\t\t\treturn baseTarget;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'Strict', {\n\t\tget() {\n\t\t\treturn strict;\n\t\t},\n\t\tenumerable: true\n\t});\n}\n\nsetupCommonJS();\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]} \ No newline at end of file +//# 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 \n'use strict';\n\nimport { inspect } from 'util';\nimport { ErrorsNames } from './errors.js';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types/index.js';\n\nimport { FieldConstructor } from './fields.js';\n\nexport interface TypeomaticaOptions {\n\tstrictAccessCheck?: boolean;\n\tfrozenPrototypes?: 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\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 hasNodeInspect = (inspect && inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(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\tif (prop === 'constructor') {\n\t\t\treturn undefined;\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\t// const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\t// throw 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\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\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\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\n\tconst InstancePrototype = getTypeomaticaProxyReference(target, options);\n\n\tconst classPrototype = Object.getPrototypeOf(this) as object;\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\tif (freezeProtos) {\n\t\tObject.freeze(classPrototype);\n\t}\n\t// @ts-ignore\n\treturn this;\n\n/* eslint-disable no-unused-vars */\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S\n};\n/* eslint-enable no-unused-vars */\n\nconst freezeClassPrototypes = (instance: object, shouldFreeze: boolean) => {\n\tif (!shouldFreeze) {\n\t\treturn;\n\t}\n\n\tconst first = Object.getPrototypeOf(instance);\n\tconst firstIsProxy = first !== null && !!Reflect.getOwnPropertyDescriptor(first, SymbolTypeomaticaProxyReference);\n\tif (firstIsProxy) {\n\t\tObject.freeze(BaseClass.prototype);\n\t\treturn;\n\t}\n\n\tlet p = first;\n\twhile (p !== null && p !== BaseClass.prototype && p !== Object.prototype) {\n\t\tconst next = Object.getPrototypeOf(p);\n\t\tconst nextIsProxy = next !== null && !!Reflect.getOwnPropertyDescriptor(next, SymbolTypeomaticaProxyReference);\n\t\tObject.freeze(p);\n\t\tif (nextIsProxy) {\n\t\t\tbreak;\n\t\t}\n\t\tp = next;\n\t}\n\tObject.freeze(BaseClass.prototype);\n};\n\nexport class BaseClass {\n\tconstructor(_target?: object, options?: TypeomaticaOptions) {\n\t\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\n\t\t// @ts-ignore\n\t\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t\tfreezeClassPrototypes(this, freezeProtos);\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\tconst instanceProto = Object.getPrototypeOf(this);\n\n\t\tif (instanceProto === BaseClass.prototype) {\n\t\t\tObject.setPrototypeOf(this, proxy);\n\t\t\tfreezeClassPrototypes(this, freezeProtos);\n\t\t\treturn this;\n\t\t}\n\n\t\tlet classProto = instanceProto;\n\t\tlet parentProto = Object.getPrototypeOf(classProto);\n\t\twhile (parentProto !== BaseClass.prototype && parentProto !== null) {\n\t\t\tclassProto = parentProto;\n\t\t\tparentProto = Object.getPrototypeOf(classProto);\n\t\t}\n\n\t\tObject.setPrototypeOf(classProto, proxy);\n\t\tfreezeClassPrototypes(this, freezeProtos);\n\t}\n}\n\n\nconst strict = function (_target?: object, options?: TypeomaticaOptions) {\n\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\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\t\tif (freezeProtos) {\n\t\t\t// @ts-ignore\n\t\t\tObject.freeze(cstr.prototype);\n\t\t}\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;\nconst FieldConstructorExport = FieldConstructor;\nexport { FieldConstructorExport as FieldConstructor };\nexport const Strict = strict;\n\n/* istanbul ignore next */\nfunction setupCommonJS() {\n\tif (typeof module === 'undefined' || typeof module.exports === 'undefined') {\n\t\treturn;\n\t}\n\tObject.defineProperty(module, 'exports', {\n\t\tget() {\n\t\t\treturn BaseConstructorPrototype;\n\t\t},\n\t\tenumerable: true\n\t});\n\n\tObject.defineProperty(module.exports, 'BaseClass', {\n\t\tget() {\n\t\t\treturn BaseClass;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'FieldConstructor', {\n\t\tget() {\n\t\t\treturn FieldConstructor;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\t\tget() {\n\t\t\treturn SymbolInitialValue;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\t\tget() {\n\t\t\treturn SymbolTypeomaticaProxyReference;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'baseTarget', {\n\t\tget() {\n\t\t\treturn baseTarget;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'Strict', {\n\t\tget() {\n\t\t\treturn strict;\n\t\t},\n\t\tenumerable: true\n\t});\n}\n\nsetupCommonJS();\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]} \ No newline at end of file diff --git a/lib/fields.d.ts b/lib/fields.d.ts index 1fceeb5..049a9b8 100644 --- a/lib/fields.d.ts +++ b/lib/fields.d.ts @@ -3,10 +3,10 @@ interface FieldDefinition { [SymbolInitialValue]: unknown; } export declare class FieldConstructor implements FieldDefinition { - [SymbolInitialValue]: unknown; - get get(): () => unknown; - get set(): () => never; - constructor(value: unknown); - static get SymbolInitialValue(): symbol; + [SymbolInitialValue]: unknown; + get get(): () => unknown; + get set(): () => never; + constructor(value: unknown); + static get SymbolInitialValue(): symbol; } export {}; diff --git a/lib/index.d.ts b/lib/index.d.ts index dcf8bc1..4a25d32 100644 --- a/lib/index.d.ts +++ b/lib/index.d.ts @@ -1,6 +1,7 @@ import { FieldConstructor } from './fields.js'; export interface TypeomaticaOptions { strictAccessCheck?: boolean; + frozenPrototypes?: boolean; } export declare const baseTarget: (_proto?: object) => any; export declare const SymbolTypeomaticaProxyReference: unique symbol; @@ -9,7 +10,7 @@ export declare const BaseConstructorPrototype: { (_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S; }; export declare class BaseClass { - constructor(_target?: object, options?: TypeomaticaOptions); + constructor(_target?: object, options?: TypeomaticaOptions); } export declare const SymbolInitialValue: symbol; declare const FieldConstructorExport: typeof FieldConstructor; diff --git a/lib/index.js b/lib/index.js index ea4eec6..fa278ef 100644 --- a/lib/index.js +++ b/lib/index.js @@ -95,6 +95,9 @@ const createHandlers = (options) => ({ }, {})); }; } + if (prop === 'constructor') { + return undefined; + } const { name } = receiver.constructor; if (props2skip.has(prop)) { const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; @@ -158,7 +161,9 @@ exports.BaseConstructorPrototype = function (_target, options) { return this; } const target = (0, exports.baseTarget)(_target); + const { frozenPrototypes: freezeProtos = true } = options || {}; const InstancePrototype = getTypeomaticaProxyReference(target, options); + const classPrototype = Object.getPrototypeOf(this); let proto; let protoPointer = this; let protoConstrcutor; @@ -188,42 +193,65 @@ exports.BaseConstructorPrototype = function (_target, options) { throw new Error('Unable to setup TypeØmatica handler!'); } Object.setPrototypeOf(proto, InstancePrototype); + if (freezeProtos) { + Object.freeze(classPrototype); + } // @ts-ignore return this; }; +const freezeClassPrototypes = (instance, shouldFreeze) => { + if (!shouldFreeze) { + return; + } + const first = Object.getPrototypeOf(instance); + const firstIsProxy = first !== null && !!Reflect.getOwnPropertyDescriptor(first, exports.SymbolTypeomaticaProxyReference); + if (firstIsProxy) { + Object.freeze(BaseClass.prototype); + return; + } + let p = first; + while (p !== null && p !== BaseClass.prototype && p !== Object.prototype) { + const next = Object.getPrototypeOf(p); + const nextIsProxy = next !== null && !!Reflect.getOwnPropertyDescriptor(next, exports.SymbolTypeomaticaProxyReference); + Object.freeze(p); + if (nextIsProxy) { + break; + } + p = next; + } + Object.freeze(BaseClass.prototype); +}; class BaseClass { constructor(_target, options) { + const { frozenPrototypes: freezeProtos = true } = options || {}; // @ts-ignore if (this[exports.SymbolTypeomaticaProxyReference]) { + freezeClassPrototypes(this, freezeProtos); return this; } const target = (0, exports.baseTarget)(_target); const proxy = getTypeomaticaProxyReference(target, options); - let proto = this; - let protoPointer; - let found = false; - do { - protoPointer = Object.getPrototypeOf(proto); - // if (protoPointer[SymbolTypeomaticaProxyReference]) { - // throw new Error('Double TypeØmatica extension is not allowed!'); - // } - if (protoPointer === Object.prototype) { - found = true; - break; - } - /* - // it can be, that protoPointer === null - // though too hard to implement this test - */ - proto = protoPointer; - } while (!found); - Object.setPrototypeOf(proto, proxy); + const instanceProto = Object.getPrototypeOf(this); + if (instanceProto === BaseClass.prototype) { + Object.setPrototypeOf(this, proxy); + freezeClassPrototypes(this, freezeProtos); + return this; + } + let classProto = instanceProto; + let parentProto = Object.getPrototypeOf(classProto); + while (parentProto !== BaseClass.prototype && parentProto !== null) { + classProto = parentProto; + parentProto = Object.getPrototypeOf(classProto); + } + Object.setPrototypeOf(classProto, proxy); + freezeClassPrototypes(this, freezeProtos); } } exports.BaseClass = BaseClass; const strict = function (_target, options) { + const { frozenPrototypes: freezeProtos = true } = options || {}; const decorator = function (cstr) { // @ts-ignore if (cstr.prototype[exports.SymbolTypeomaticaProxyReference]) { @@ -234,6 +262,10 @@ const strict = function (_target, options) { const _replacer = Object.create(proxy); // @ts-ignore Object.setPrototypeOf(cstr.prototype, _replacer); + if (freezeProtos) { + // @ts-ignore + Object.freeze(cstr.prototype); + } return cstr; // const MyClassProxy = new Proxy(cstr, { // construct(_, argumentsList, newTarget) { @@ -316,4 +348,4 @@ function setupCommonJS() { setupCommonJS(); 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":"AAAA,0CAA0C;AAE1C,YAAY,CAAC;;;AAEb,+BAA+B;AAC/B,2CAA0C;AAE1C,+CAO0B;AAE1B,2CAA+C;AAM/C,MAAM,cAAc,GAAG,CAAC,UAA8B,EAAE,EAAE,EAAE;IAC3D,MAAM,EAAE,iBAAiB,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAE9C,OAAO,MAAM,CAAC,OAAO,CAAC;QACrB,UAAU,EAAV,qBAAU;QACV,OAAO,EAAP,kBAAO;QACP,OAAO,EAAP,kBAAO;QACP,OAAO,EAAP,kBAAO;QACP,SAAS,EAAT,oBAAS;KACT,CAAC,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,EAAE;QAC1C,aAAa;QACb,GAAG,CAAC,GAAG,CAAC,GAAG,UAAU,YAAoB,EAAE,QAAgB;YAC1D,MAAM,OAAO,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACvC,OAAO;gBACN,GAAG;oBACF,MAAM,cAAc,GAAG,IAAI,CAAC;oBAC5B,IAAI,iBAAiB,IAAI,cAAc,KAAK,QAAQ,EAAE,CAAC;wBACtD,MAAM,IAAI,cAAc,CAAC,uBAAW,CAAC,aAAa,CAAC,CAAC;oBACrD,CAAC;oBACD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;oBAC7B,OAAO,MAAM,CAAC;gBACf,CAAC;gBACD,GAAG,CAAC,gBAAyB;oBAC5B,MAAM,cAAc,GAAG,IAAI,CAAC;oBAC5B,IAAI,iBAAiB,IAAI,cAAc,KAAK,QAAQ,EAAE,CAAC;wBACtD,MAAM,IAAI,cAAc,CAAC,uBAAW,CAAC,aAAa,CAAC,CAAC;oBACrD,CAAC;oBACD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;oBAC7C,OAAO,MAAM,CAAC;gBACf,CAAC;aACD,CAAC;QACH,CAAC,CAAC;QAEF,OAAO,GAAG,CAAC;IACZ,CAAC,EAAE,EAAE,CAAC,CAAC;AACR,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,QAAgB,EAAE,YAAqB,EAAE,QAAgB,EAAE,OAA4B,EAAE,EAAE;IAElH,MAAM,KAAK,GAAG,YAAY,CAAC;IAC3B,MAAM,gBAAgB,GAAG,IAAA,sBAAW,EAAC,YAAY,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC;IAClD,MAAM,UAAU,GAAG,YAAY,YAAY,QAAQ,CAAC;IACpD,MAAM,MAAM,GAAG,YAAY,KAAK,IAAI,CAAC;IAErC;;;OAGG;IAEH,MAAM,KAAK,GAAG,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAC/C,QAAQ,CAAC,CAAC,CAAC,CACV,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAC9B,CAAC,CAAC,CAAC,CACH,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CACpC,CACD,CAAC;IAEF,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IAEzC,MAAM,UAAU,GAAG,CAAC,QAAQ,IAAI,CAAC,KAAK,YAAY,4BAAgB,CAAC,CAAC,CAAC,CAAC;QACrE,KAAK,CAAC,CAAC,CAAC;QACP,UAAU,EAAE,IAAI;QAChB,aAAa;QACb,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC;KACnC,CAAC;IAEH,2CAA2C;IAC3C,eAAe;IACf,aAAa;IACb,IAAI;IAEJ,MAAM,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IACtE,OAAO,MAAM,CAAC;AAEf,CAAC,CAAC;AAEF,8DAA8D;AAC9D,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC;IAC1B,MAAM,CAAC,WAAW;IAClB,MAAM,CAAC,QAAQ;IACf,sBAAsB;IACtB,UAAU;IACV,SAAS;IACT,MAAM;CACN,CAAC,CAAC;AACH,qEAAqE;AACrE,MAAM,cAAc,GAAG,CAAC,cAAO,IAAI,cAAO,CAAC,MAAM,CAAC,CAAC;AACnD,iDAAiD;AACjD,CAAC,cAAc,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,cAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAErD,MAAM,cAAc,GAAG,CAAC,OAA4B,EAAE,EAAE,CAAC,CAAC;IACzD,GAAG,CAAC,MAAc,EAAE,IAAqB,EAAE,QAAgB;QAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QACnD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,MAAM,CAAC;QACf,CAAC;QACD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvB,0CAA0C;YAC1C,OAAO;gBACN,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;oBAC1D,aAAa;oBACb,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC3B,OAAO,GAAG,CAAC;gBACZ,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YACT,CAAC,CAAC;QACH,CAAC;QACD,MAAM,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,WAAW,CAAC;QACtC,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,MAAM,OAAO,GAAG,GAAG,IAAI,0BAA0B,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC;YAC5E,OAAO,OAAO,CAAC;QAChB,CAAC;QACD,iGAAiG;QACjG,iCAAiC;IAClC,CAAC;IACD,GAAG,CAAC,CAAS,EAAE,IAAY,EAAE,KAAc,EAAE,QAAgB;QAC5D,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC;IACf,CAAC;IACD,cAAc;QACb,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACtD,CAAC;IACD,oEAAoE;IACpE,cAAc;QACb,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC3D,mDAAmD;IACpD,CAAC;IACD,cAAc;QACb,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACxD,CAAC;IACD,qBAAqB;IACrB,aAAa;IACb,wDAAwD;IACxD,KAAK;CACL,CAAC,CAAC;AAEH,0CAA0C;AACnC,MAAM,UAAU,GAAG,CAAC,MAAe,EAAE,EAAE;IAC7C,MAAM,KAAK,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IACzD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,MAAM,CAAC;AACf,CAAC,CAAC;AAJW,QAAA,UAAU,cAIrB;AAEW,QAAA,+BAA+B,GAAG,MAAM,CAAC,2BAA2B,CAAC,CAAC;AACnF,MAAM,4BAA4B,GAAG,CAAC,OAAe,EAAE,OAA4B,EAAE,EAAE;IACtF,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACtC,MAAM,EAAE,GAAG,6BAA6B,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;IACxD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,uCAA+B,EAAE;QAC9D,GAAG;YACF,OAAO,EAAE,CAAC;QACX,CAAC;KACD,CAAC,CAAC;IACH,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;IACzC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1C,OAAO,KAAK,CAAC;AACd,CAAC,CAAC;AAGW,QAAA,wBAAwB,GAAG,UAAqE,OAAW,EAAE,OAA4B;IACrJ,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;QAEjB,MAAM,IAAI,GAKN,gCAAwB,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAE1D,IAAI,CAAC,SAAS,GAAG;YAChB,WAAW,EAAE,gCAAwB;SACrC,CAAC;QAEF,aAAa;QACb,OAAO,IAAI,CAAC;IAEb,CAAC;IAED,aAAa;IACb,IAAI,IAAI,CAAC,uCAA+B,CAAC,EAAE,CAAC;QAC3C,aAAa;QACb,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,OAAO,CAAW,CAAC;IAE7C,MAAM,iBAAiB,GAAG,4BAA4B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAExE,IAAI,KAAK,CAAC;IACV,IAAI,YAAY,GAAG,IAAc,CAAC;IAClC,IAAI,gBAAgB,CAAC;IAErB,IAAI,YAAY,GAAG,KAAK,CAAC;IAEzB,aAAa;IACb,iGAAiG;IACjG,2BAA2B;IAC3B,yGAAyG;IACzG,IAAI;IAEJ,GAAG,CAAC;QACH,KAAK,GAAG,YAAY,CAAC;QACrB,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,gCAAwB,CAAC,SAAS,KAAK,YAAY,EAAE,CAAC;YACzD,YAAY,GAAG,IAAI,CAAC;YACpB,MAAM;QACP,CAAC;QACD,IAAI,CAAC,YAAY;YAAE,MAAM;QACzB,MAAM,UAAU,GAAG,OAAO,CAAC,wBAAwB,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;QACjF,IAAI,CAAC,UAAU;YAAE,SAAS;QAC1B,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,IAAI,UAAU,CAAC,GAAG,CAAC;QACjD,wBAAwB;QACxB,gBAAgB,GAAG,KAAK,CAAC;IAC1B,CAAC,QAAQ,gBAAgB,KAAK,gCAAwB,EAAE;IAExD,IAAI,CAAC,YAAY,IAAI,gBAAgB,KAAK,gCAAwB,EAAE,CAAC;QACpE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IAChD,aAAa;IACb,OAAO,IAAI,CAAC;IAEb,mCAAmC;AACnC,CAGC,CAAC;AACF,kCAAkC;AAElC,MAAa,SAAS;IACrB,YAAY,OAAgB,EAAE,OAA4B;QACzD,aAAa;QACb,IAAI,IAAI,CAAC,uCAA+B,CAAC,EAAE,CAAC;YAC3C,OAAO,IAAI,CAAC;QACb,CAAC;QAED,MAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,OAAO,CAAW,CAAC;QAC7C,MAAM,KAAK,GAAG,4BAA4B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,IAAI,KAAK,GAAkB,IAAI,CAAC;QAChC,IAAI,YAA2B,CAAC;QAChC,IAAI,KAAK,GAAY,KAAK,CAAC;QAC3B,GAAG,CAAC;YACH,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC5C,uDAAuD;YACvD,oEAAoE;YACpE,IAAI;YACJ,IAAI,YAAY,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;gBACvC,KAAK,GAAG,IAAI,CAAC;gBACb,MAAM;YACP,CAAC;YACD;;;cAGE;YACF,KAAK,GAAG,YAAY,CAAC;QACtB,CAAC,QAAQ,CAAC,KAAK,EAAE;QACjB,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;CACD;AA7BD,8BA6BC;AAGD,MAAM,MAAM,GAAG,UAAU,OAAgB,EAAE,OAA4B;IACtE,MAAM,SAAS,GAAG,UAAY,IAAO;QAEpC,aAAa;QACb,IAAI,IAAI,CAAC,SAAS,CAAC,uCAA+B,CAAC,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC;QACb,CAAC;QAED,MAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,OAAO,CAAC,CAAC;QACnC,MAAM,KAAK,GAAG,4BAA4B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAEvC,aAAa;QACb,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAEjD,OAAO,IAAI,CAAC;QAGZ,yCAAyC;QACzC,4CAA4C;QAC5C,cAAc;QACd,wCAAwC;QACxC,wDAAwD;QACxD,4CAA4C;QAE5C,mCAAmC;QAEnC,gEAAgE;QAChE,2BAA2B;QAE3B,kDAAkD;QAElD,kEAAkE;QAClE,iDAAiD;QAEjD,+CAA+C;QAC/C,4CAA4C;QAG5C,kDAAkD;QAClD,sEAAsE;QAEtE,cAAc;QACd,mDAAmD;QACnD,cAAc;QAEd,mBAAmB;QACnB,MAAM;QACN,MAAM;QACN,uBAAuB;IACxB,CAAC,CAAC;IAEF,OAAO,SAAS,CAAC;AAElB,CAAC,CAAC;AACa,0BAAkB,GAAK,4BAAgB,oBAAC;AACvD,MAAM,sBAAsB,GAAG,4BAAgB,CAAC;AACb,kDAAgB;AACtC,QAAA,MAAM,GAAG,MAAM,CAAC;AAE7B,0BAA0B;AAC1B,SAAS,aAAa;IACrB,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,WAAW,EAAE,CAAC;QAC5E,OAAO;IACR,CAAC;IACD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE;QACxC,GAAG;YACF,OAAO,gCAAwB,CAAC;QACjC,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IAEH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE;QAClD,GAAG;YACF,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE;QACzD,GAAG;YACF,OAAO,4BAAgB,CAAC;QACzB,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,oBAAoB,EAAE;QAC3D,GAAG;YACF,OAAO,0BAAkB,CAAC;QAC3B,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,iCAAiC,EAAE;QACxE,GAAG;YACF,OAAO,uCAA+B,CAAC;QACxC,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE;QACnD,GAAG;YACF,OAAO,kBAAU,CAAC;QACnB,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE;QAC/C,GAAG;YACF,OAAO,MAAM,CAAC;QACf,CAAC;QACD,UAAU,EAAE,IAAI;KAChB,CAAC,CAAC;AACJ,CAAC;AAED,aAAa,EAAE,CAAC;AAEhB,MAAM,CAAC,MAAM,CAAC,gCAAwB,CAAC,CAAC;AACxC,MAAM,CAAC,MAAM,CAAC,gCAAwB,CAAC,SAAS,CAAC,CAAC","sourcesContent":["// oxlint-disable typescript/no-this-alias\n \n'use strict';\n\nimport { inspect } from 'util';\nimport { ErrorsNames } from './errors.js';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types/index.js';\n\nimport { FieldConstructor } from './fields.js';\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\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 hasNodeInspect = (inspect && inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(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\t// const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\t// throw 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\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\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/* eslint-disable no-unused-vars */\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S\n};\n/* eslint-enable no-unused-vars */\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;\nconst FieldConstructorExport = FieldConstructor;\nexport { FieldConstructorExport as FieldConstructor };\nexport const Strict = strict;\n\n/* istanbul ignore next */\nfunction setupCommonJS() {\n\tif (typeof module === 'undefined' || typeof module.exports === 'undefined') {\n\t\treturn;\n\t}\n\tObject.defineProperty(module, 'exports', {\n\t\tget() {\n\t\t\treturn BaseConstructorPrototype;\n\t\t},\n\t\tenumerable: true\n\t});\n\n\tObject.defineProperty(module.exports, 'BaseClass', {\n\t\tget() {\n\t\t\treturn BaseClass;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'FieldConstructor', {\n\t\tget() {\n\t\t\treturn FieldConstructor;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\t\tget() {\n\t\t\treturn SymbolInitialValue;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\t\tget() {\n\t\t\treturn SymbolTypeomaticaProxyReference;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'baseTarget', {\n\t\tget() {\n\t\t\treturn baseTarget;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'Strict', {\n\t\tget() {\n\t\t\treturn strict;\n\t\t},\n\t\tenumerable: true\n\t});\n}\n\nsetupCommonJS();\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]} \ No newline at end of file +//# 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 \n'use strict';\n\nimport { inspect } from 'util';\nimport { ErrorsNames } from './errors.js';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types/index.js';\n\nimport { FieldConstructor } from './fields.js';\n\nexport interface TypeomaticaOptions {\n\tstrictAccessCheck?: boolean;\n\tfrozenPrototypes?: 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\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 hasNodeInspect = (inspect && inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(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\tif (prop === 'constructor') {\n\t\t\treturn undefined;\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\t// const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\t// throw 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\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\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\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\n\tconst InstancePrototype = getTypeomaticaProxyReference(target, options);\n\n\tconst classPrototype = Object.getPrototypeOf(this) as object;\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\tif (freezeProtos) {\n\t\tObject.freeze(classPrototype);\n\t}\n\t// @ts-ignore\n\treturn this;\n\n/* eslint-disable no-unused-vars */\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer InferredS ? InferredS : {}, options?: TypeomaticaOptions): S\n};\n/* eslint-enable no-unused-vars */\n\nconst freezeClassPrototypes = (instance: object, shouldFreeze: boolean) => {\n\tif (!shouldFreeze) {\n\t\treturn;\n\t}\n\n\tconst first = Object.getPrototypeOf(instance);\n\tconst firstIsProxy = first !== null && !!Reflect.getOwnPropertyDescriptor(first, SymbolTypeomaticaProxyReference);\n\tif (firstIsProxy) {\n\t\tObject.freeze(BaseClass.prototype);\n\t\treturn;\n\t}\n\n\tlet p = first;\n\twhile (p !== null && p !== BaseClass.prototype && p !== Object.prototype) {\n\t\tconst next = Object.getPrototypeOf(p);\n\t\tconst nextIsProxy = next !== null && !!Reflect.getOwnPropertyDescriptor(next, SymbolTypeomaticaProxyReference);\n\t\tObject.freeze(p);\n\t\tif (nextIsProxy) {\n\t\t\tbreak;\n\t\t}\n\t\tp = next;\n\t}\n\tObject.freeze(BaseClass.prototype);\n};\n\nexport class BaseClass {\n\tconstructor(_target?: object, options?: TypeomaticaOptions) {\n\t\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\n\t\t// @ts-ignore\n\t\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t\tfreezeClassPrototypes(this, freezeProtos);\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\tconst instanceProto = Object.getPrototypeOf(this);\n\n\t\tif (instanceProto === BaseClass.prototype) {\n\t\t\tObject.setPrototypeOf(this, proxy);\n\t\t\tfreezeClassPrototypes(this, freezeProtos);\n\t\t\treturn this;\n\t\t}\n\n\t\tlet classProto = instanceProto;\n\t\tlet parentProto = Object.getPrototypeOf(classProto);\n\t\twhile (parentProto !== BaseClass.prototype && parentProto !== null) {\n\t\t\tclassProto = parentProto;\n\t\t\tparentProto = Object.getPrototypeOf(classProto);\n\t\t}\n\n\t\tObject.setPrototypeOf(classProto, proxy);\n\t\tfreezeClassPrototypes(this, freezeProtos);\n\t}\n}\n\n\nconst strict = function (_target?: object, options?: TypeomaticaOptions) {\n\tconst { frozenPrototypes: freezeProtos = true } = options || {};\n\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\t\tif (freezeProtos) {\n\t\t\t// @ts-ignore\n\t\t\tObject.freeze(cstr.prototype);\n\t\t}\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;\nconst FieldConstructorExport = FieldConstructor;\nexport { FieldConstructorExport as FieldConstructor };\nexport const Strict = strict;\n\n/* istanbul ignore next */\nfunction setupCommonJS() {\n\tif (typeof module === 'undefined' || typeof module.exports === 'undefined') {\n\t\treturn;\n\t}\n\tObject.defineProperty(module, 'exports', {\n\t\tget() {\n\t\t\treturn BaseConstructorPrototype;\n\t\t},\n\t\tenumerable: true\n\t});\n\n\tObject.defineProperty(module.exports, 'BaseClass', {\n\t\tget() {\n\t\t\treturn BaseClass;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'FieldConstructor', {\n\t\tget() {\n\t\t\treturn FieldConstructor;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\t\tget() {\n\t\t\treturn SymbolInitialValue;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\t\tget() {\n\t\t\treturn SymbolTypeomaticaProxyReference;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'baseTarget', {\n\t\tget() {\n\t\t\treturn baseTarget;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'Strict', {\n\t\tget() {\n\t\t\treturn strict;\n\t\t},\n\t\tenumerable: true\n\t});\n}\n\nsetupCommonJS();\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 82256cb..3136adb 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "typeomatica", - "version": "0.3.58", + "version": "0.3.59", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "typeomatica", - "version": "0.3.58", + "version": "0.3.59", "license": "MIT", "devDependencies": { "@eslint/eslintrc": "^3.3.5", @@ -2812,9 +2812,9 @@ "license": "MIT" }, "node_modules/baseline-browser-mapping": { - "version": "2.10.38", - "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.38.tgz", - "integrity": "sha512-31/02mVB4yuQU6adKk5SlY6m+mxDwUq5KZkyYgnLrrKl7TEm1+3PyDtDBz2kOv/wxZz41GHsvV1A/u6RmiyBvw==", + "version": "2.10.40", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.40.tgz", + "integrity": "sha512-BSSLZ9/Cjjv7Gtj5B68ZzXcXUg8iOf3fme+FCuh8rC/Go+Kmh8cox7M3A8dolou16s64QjLPOSdngh7GxXvkSw==", "dev": true, "license": "Apache-2.0", "bin": { @@ -3300,9 +3300,9 @@ "license": "MIT" }, "node_modules/electron-to-chromium": { - "version": "1.5.378", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.378.tgz", - "integrity": "sha512-VinvOAuuPmdD1guEgGv5f2Qp7/vlfqOrUOMYNnOD4wj3pit8kRsQHzfIf6teyUGWo15Tg5+bOJaRunvyltpVWQ==", + "version": "1.5.379", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.379.tgz", + "integrity": "sha512-v/qV5aV5EUA2pGilzUCq5/eyOloZAqDZBu9UMBIzgPpLlprjSR6zswsWBTv0KpqxLGUAZEwhO95ZCt7srymNVA==", "dev": true, "license": "ISC" }, @@ -3650,9 +3650,9 @@ } }, "node_modules/expect-type": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", - "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz", + "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==", "dev": true, "license": "Apache-2.0", "engines": { diff --git a/package.json b/package.json index 4b0457a..f872add 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "typeomatica", - "version": "0.3.58", + "version": "0.3.59", "description": "type logic against javascript metaprogramming", "engines": { "node": ">=16" diff --git a/src/index.ts b/src/index.ts index da34892..4411b55 100644 --- a/src/index.ts +++ b/src/index.ts @@ -18,6 +18,7 @@ import { FieldConstructor } from './fields.js'; export interface TypeomaticaOptions { strictAccessCheck?: boolean; + frozenPrototypes?: boolean; } const createResolver = (options: TypeomaticaOptions = {}) => { @@ -128,6 +129,9 @@ const createHandlers = (options?: TypeomaticaOptions) => ({ }, {})); }; } + if (prop === 'constructor') { + return undefined; + } const { name } = receiver.constructor; if (props2skip.has(prop)) { const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; @@ -205,9 +209,12 @@ export const BaseConstructorPrototype = function } const target = baseTarget(_target) as object; + const { frozenPrototypes: freezeProtos = true } = options || {}; const InstancePrototype = getTypeomaticaProxyReference(target, options); + const classPrototype = Object.getPrototypeOf(this) as object; + let proto; let protoPointer = this as object; let protoConstrcutor; @@ -240,6 +247,9 @@ export const BaseConstructorPrototype = function } Object.setPrototypeOf(proto, InstancePrototype); + if (freezeProtos) { + Object.freeze(classPrototype); + } // @ts-ignore return this; @@ -250,39 +260,67 @@ export const BaseConstructorPrototype = function }; /* eslint-enable no-unused-vars */ +const freezeClassPrototypes = (instance: object, shouldFreeze: boolean) => { + if (!shouldFreeze) { + return; + } + + const first = Object.getPrototypeOf(instance); + const firstIsProxy = first !== null && !!Reflect.getOwnPropertyDescriptor(first, SymbolTypeomaticaProxyReference); + if (firstIsProxy) { + Object.freeze(BaseClass.prototype); + return; + } + + let p = first; + while (p !== null && p !== BaseClass.prototype && p !== Object.prototype) { + const next = Object.getPrototypeOf(p); + const nextIsProxy = next !== null && !!Reflect.getOwnPropertyDescriptor(next, SymbolTypeomaticaProxyReference); + Object.freeze(p); + if (nextIsProxy) { + break; + } + p = next; + } + Object.freeze(BaseClass.prototype); +}; + export class BaseClass { constructor(_target?: object, options?: TypeomaticaOptions) { + const { frozenPrototypes: freezeProtos = true } = options || {}; + // @ts-ignore if (this[SymbolTypeomaticaProxyReference]) { + freezeClassPrototypes(this, freezeProtos); return this; } const target = baseTarget(_target) as object; const proxy = getTypeomaticaProxyReference(target, options); - let proto: object | null = this; - let protoPointer: object | null; - let found: boolean = false; - do { - protoPointer = Object.getPrototypeOf(proto); - // if (protoPointer[SymbolTypeomaticaProxyReference]) { - // throw new Error('Double TypeØmatica extension is not allowed!'); - // } - if (protoPointer === Object.prototype) { - found = true; - break; - } - /* - // it can be, that protoPointer === null - // though too hard to implement this test - */ - proto = protoPointer; - } while (!found); - Object.setPrototypeOf(proto, proxy); + const instanceProto = Object.getPrototypeOf(this); + + if (instanceProto === BaseClass.prototype) { + Object.setPrototypeOf(this, proxy); + freezeClassPrototypes(this, freezeProtos); + return this; + } + + let classProto = instanceProto; + let parentProto = Object.getPrototypeOf(classProto); + while (parentProto !== BaseClass.prototype && parentProto !== null) { + classProto = parentProto; + parentProto = Object.getPrototypeOf(classProto); + } + + Object.setPrototypeOf(classProto, proxy); + freezeClassPrototypes(this, freezeProtos); } } const strict = function (_target?: object, options?: TypeomaticaOptions) { + const { frozenPrototypes: freezeProtos = true } = options || {}; + const decorator = function(cstr: T): T { // @ts-ignore @@ -296,6 +334,10 @@ const strict = function (_target?: object, options?: TypeomaticaOptions) { // @ts-ignore Object.setPrototypeOf(cstr.prototype, _replacer); + if (freezeProtos) { + // @ts-ignore + Object.freeze(cstr.prototype); + } return cstr; diff --git a/test/index.ts b/test/index.ts index a5610e1..da3977c 100644 --- a/test/index.ts +++ b/test/index.ts @@ -121,6 +121,35 @@ class SimpleBase extends BaseClass { } const simpleInstance = addTag(new SimpleBase); +class InitialStateBase extends BaseClass { + constructor() { + super({ initialNumber: 42, initialString: 'hello' }); + // @ts-ignore + this.initialNumber = this.initialNumber; + // @ts-ignore + this.initialString = this.initialString; + } +} + +class DeepBaseA extends BaseClass { + aMethod() { + return 'A'; + } +} +class DeepBaseB extends DeepBaseA { + bMethod() { + return 'B'; + } +} +class DeepBaseC extends DeepBaseB { + cMethod() { + return 'C'; + } +} +const deepBaseInstance = addTag(new DeepBaseC()); + +const directBaseInstance = addTag(new BaseClass({ directProp: 123 })); + interface IFCstr { (): void new(): { @@ -281,6 +310,46 @@ describe('props tests', () => { expect(proto.someProp).toEqual(123); }); + test('BaseClass accepts initial state through super()', () => { + const instance = addTag(new InitialStateBase()); + expect(instance.initialNumber.valueOf()).toEqual(42); + expect(instance.initialString.valueOf()).toEqual('hello'); + + instance.initialNumber = 100; + expect(instance.initialNumber.valueOf()).toEqual(100); + + expect(() => { + // @ts-ignore + instance.initialNumber = 'wrong'; + }).toThrow('Type Mismatch'); + }); + + test('direct BaseClass instantiation works without polluting BaseClass.prototype', () => { + expect(directBaseInstance.directProp.valueOf()).toEqual(123); + // @ts-ignore + directBaseInstance.directProp = 456; + expect(directBaseInstance.directProp.valueOf()).toEqual(456); + expect(() => { + // @ts-ignore + directBaseInstance.directProp = 'wrong'; + }).toThrow('Type Mismatch'); + }); + + test('frozenPrototypes: false allows runtime prototype mutation', () => { + class UnfrozenBase extends BaseClass { + declare value: number; + constructor() { + super(undefined, { frozenPrototypes: false }); + this.value = 1; + } + } + const instance = addTag(new UnfrozenBase()); + expect(Object.isFrozen(UnfrozenBase.prototype)).toBe(false); + // @ts-ignore + UnfrozenBase.prototype.extra = 123; + expect(instance.extra.valueOf()).toEqual(123); + }); + test('base instance has props', () => { let gf: string; let sv: string; @@ -636,6 +705,29 @@ describe('prototype mutations tests', () => { }).toThrow(new ReferenceError('Value Access Denied')); }); + test('class prototype cannot be reassigned', () => { + expect(() => { + Object.setPrototypeOf(Base.prototype, {}); + }).toThrow(TypeError); + }); + + test('class prototype cannot grow new properties', () => { + expect(() => { + // @ts-ignore + Base.prototype.newProp = 1; + }).toThrow(TypeError); + }); + + test('proxy constructor access does not recurse', () => { + const proxy = Object.getPrototypeOf(DeepBaseA.prototype); + expect(() => { + // @ts-ignore + proxy.constructor; + }).not.toThrow(); + // @ts-ignore + expect(proxy.constructor).toBeUndefined(); + }); + }); describe('methods tests', () => { @@ -722,6 +814,25 @@ describe('deep extend works', () => { }); + test('BaseClass deep hierarchy preserves intermediate prototype methods', () => { + expect(deepBaseInstance.aMethod()).toEqual('A'); + expect(deepBaseInstance.bMethod()).toEqual('B'); + expect(deepBaseInstance.cMethod()).toEqual('C'); + expect(deepBaseInstance).toBeInstanceOf(DeepBaseA); + expect(deepBaseInstance).toBeInstanceOf(DeepBaseB); + expect(deepBaseInstance).toBeInstanceOf(DeepBaseC); + }); + + test('BaseClass freezes every prototype in the hierarchy', () => { + expect(Object.isFrozen(DeepBaseA.prototype)).toBe(true); + expect(Object.isFrozen(DeepBaseB.prototype)).toBe(true); + expect(Object.isFrozen(DeepBaseC.prototype)).toBe(true); + expect(() => { + // @ts-ignore + DeepBaseB.prototype.newProp = 1; + }).toThrow(TypeError); + }); + test('network extention works', () => { expect(networkedInstance).toBeInstanceOf(NetworkedExtention); @@ -871,7 +982,6 @@ describe('coverage: ', () => { // @ts-ignore expect(cov5.hidden).toBeTruthy(); - console.log(ogp(cov5)); debugger; const proxyPointer = ogp(ogp(ogp(cov5))); @@ -900,6 +1010,27 @@ describe('coverage: ', () => { expect(error).toBeInstanceOf(Error); expect(error.message).toBe('Properties Deletion is not allowed!'); + class CovCLS6 extends BasePrototype({ value: 1 }, { frozenPrototypes: false }) { + declare value: number; + } + const cov6 = addTag(new CovCLS6); + expect(Object.isFrozen(CovCLS6.prototype)).toBe(false); + // @ts-ignore + CovCLS6.prototype.extra = 2; + // @ts-ignore + expect(cov6.extra.valueOf()).toEqual(2); + + @Strict({ value: 1 }, { frozenPrototypes: false }) + class CovCLS7 { + declare value: number; + } + const cov7 = addTag(new CovCLS7); + expect(Object.isFrozen(CovCLS7.prototype)).toBe(false); + // @ts-ignore + CovCLS7.prototype.extra = 3; + // @ts-ignore + expect(cov7.extra.valueOf()).toEqual(3); + // this tests we passed null // as a target for proto // though it anyway be converted to Object.create(null)