From f8fd86621df1e5ed875f50c7e5a4038f005bc5c0 Mon Sep 17 00:00:00 2001 From: wentout Date: Wed, 19 Aug 2026 15:41:07 +0300 Subject: [PATCH] additions for thunderstruck --- AGENTS.md | 2 +- README.md | 33 +- lib/errors.d.ts | 1 + lib/errors.js | 15 +- lib/esm/errors.d.ts | 1 + lib/esm/errors.js | 13 +- lib/esm/fields.js | 36 +- lib/esm/index.d.ts | 28 ++ lib/esm/index.js | 731 +++++++++++++++++++-------------- lib/esm/types/functions.js | 2 +- lib/esm/types/index.js | 8 +- lib/esm/types/nullish.js | 18 +- lib/esm/types/objects.js | 26 +- lib/esm/types/primitives.js | 112 ++--- lib/esm/types/special.js | 26 +- lib/fields.js | 40 +- lib/index.d.ts | 28 ++ lib/index.js | 748 ++++++++++++++++++++-------------- lib/types/functions.js | 6 +- lib/types/index.js | 30 +- lib/types/nullish.js | 22 +- lib/types/objects.js | 30 +- lib/types/primitives.js | 116 +++--- lib/types/special.js | 30 +- package-lock.json | 50 +-- package.json | 2 +- src/errors.ts | 1 + src/index.ts | 145 ++++++- test/esm/class-fields.test.ts | 63 +++ test/esm/imports.test.ts | 8 + test/index.ts | 163 +++++++- 31 files changed, 1628 insertions(+), 906 deletions(-) create mode 100644 test/esm/class-fields.test.ts diff --git a/AGENTS.md b/AGENTS.md index 519f9f4..6c723c6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -8,7 +8,7 @@ Runtime strict-type enforcement for JavaScript objects using Proxies and decorat | File | Purpose | |------|---------| -| `src/index.ts` | Core: `BaseClass`, `BaseConstructorPrototype` (default export), `@Strict` decorator, proxy handlers, CJS export setup. | +| `src/index.ts` | Core: `BaseClass`, `BaseConstructorPrototype` (default export), `@Strict` decorator, proxy handlers, construction-field tracking + `finalize` family + `unwrap`, CJS export setup. | | `src/esm.ts` | ESM entry point. Re-exports default + named bindings from `src/index.ts`. | | `src/fields.ts` | `FieldConstructor` class for custom property descriptors. | | `src/errors.ts` | Error message constants. | diff --git a/README.md b/README.md index 8c0ea9e..76e1aed 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,34 @@ user.age = 25; user.age = '25'; // TypeError: Type Mismatch ``` -> **Important:** initialized class fields (`name = 'default'`) are stored as own properties and bypass the proxy. Use `declare name: string;` plus constructor assignment, or see `FieldConstructor` for custom descriptors. +> **Important:** initialized class fields (`name = 'default'`) are stored as own properties and bypass the proxy. Use `declare name: string;` plus constructor assignment, or see `FieldConstructor` for custom descriptors — or call `finalize(instance)` to re-establish hiddenly-added fields as guarded ones (see below). + +## Construction Tracking & Finalization + +TypeØmatica records every field that passes through its define machinery, +per instance. Fields added with define semantics (class field initializers, +`Object.defineProperty`) bypass the proxy — `finalize` re-establishes them +as guarded fields after the fact: + +- `getConstructedFields(instance)` — `Set` of field names that certainly + passed through the machinery (a copy; mutating it affects nothing). +- `finalize(instance)` — auto mode: every hiddenly-added own field is + deleted and re-established through the define machinery; sets the + finalized flag. +- `finalizeBy(instance, fields)` — partial mode: same for a listed subset; + does **not** set the finalized flag. +- `isFinalized(instance)` — `true` only if auto `finalize` ran; manual or + partial finalization leaves it `false`. +- `unwrap(instance, field)` — turns a guarded field back into a plain value + property: boxed primitives are read back via `.valueOf()`, objects and + nullish values are placed as-is. Allowed **only** for fields re-established + by `finalize`/`finalizeBy` — those stay `configurable: true` by design. + Fields guarded since construction are non-configurable forever; that lock + is the essential design of the library, not an accident. + +Designed as the `postCreation`-hook companion for mnemonica chains: at each +construction level, diff the instance's own descriptors against +`getConstructedFields(instance)` to find what bypassed the proxy. --- @@ -72,8 +99,8 @@ npm run lint:src # ESLint on src/ - `src/esm.ts` — ESM entry point that re-exports the default and named bindings from `src/index.ts`. - `src/fields.ts` — `FieldConstructor` class for custom property descriptors. - `src/types/*.ts` — type-category handlers (primitives, objects, functions, special, nullish). -- `test/index.ts` — Jest CJS test suite (50 tests, 100% coverage). -- `test/esm/` — Vitest tests that exercise the actual ESM `exports` map. +- `test/index.ts` — Jest CJS test suite (70 tests, 100% coverage). +- `test/esm/` — Vitest tests that exercise the actual ESM `exports` map, including the native class-fields (define semantics) suite. - `examples/` — runnable integration examples. --- diff --git a/lib/errors.d.ts b/lib/errors.d.ts index 6615394..445a1f1 100644 --- a/lib/errors.d.ts +++ b/lib/errors.d.ts @@ -3,4 +3,5 @@ export declare const ErrorsNames: { ACCESS_DENIED: string; RIP_FUNCTIONS: string; FORBIDDEN_RE: string; + FORBIDDEN_UNWRAP: string; }; diff --git a/lib/errors.js b/lib/errors.js index fb27fa9..ed94628 100644 --- a/lib/errors.js +++ b/lib/errors.js @@ -1,11 +1,12 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.ErrorsNames = void 0; exports.ErrorsNames = { - TYPE_MISMATCH: 'Type Mismatch', - ACCESS_DENIED: 'Value Access Denied', - RIP_FUNCTIONS: 'Functions are Restricted', - FORBIDDEN_RE: 'Re-Assirnment is Forbidden', - // MISSING_PROP: 'Attempt to Access to Undefined Prop', + TYPE_MISMATCH: 'Type Mismatch', + ACCESS_DENIED: 'Value Access Denied', + RIP_FUNCTIONS: 'Functions are Restricted', + FORBIDDEN_RE: 'Re-Assirnment is Forbidden', + FORBIDDEN_UNWRAP: 'Unwrap is allowed only for finalized fields', + // MISSING_PROP: 'Attempt to Access to Undefined Prop', }; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUVBLFFBQUEsV0FBVyxHQUFHO0lBQzFCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsYUFBYSxFQUFFLDBCQUEwQjtJQUN6QyxZQUFZLEVBQUUsNEJBQTRCO0lBQzFDLHVEQUF1RDtDQUN2RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5leHBvcnQgY29uc3QgRXJyb3JzTmFtZXMgPSB7XG5cdFRZUEVfTUlTTUFUQ0g6ICdUeXBlIE1pc21hdGNoJyxcblx0QUNDRVNTX0RFTklFRDogJ1ZhbHVlIEFjY2VzcyBEZW5pZWQnLFxuXHRSSVBfRlVOQ1RJT05TOiAnRnVuY3Rpb25zIGFyZSBSZXN0cmljdGVkJyxcblx0Rk9SQklEREVOX1JFOiAnUmUtQXNzaXJubWVudCBpcyBGb3JiaWRkZW4nLFxuXHQvLyBNSVNTSU5HX1BST1A6ICdBdHRlbXB0IHRvIEFjY2VzcyB0byBVbmRlZmluZWQgUHJvcCcsXG59O1xuIl19 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUVBLFFBQUEsV0FBVyxHQUFHO0lBQzFCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsYUFBYSxFQUFFLDBCQUEwQjtJQUN6QyxZQUFZLEVBQUUsNEJBQTRCO0lBQzFDLGdCQUFnQixFQUFFLDZDQUE2QztJQUMvRCx1REFBdUQ7Q0FDdkQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuZXhwb3J0IGNvbnN0IEVycm9yc05hbWVzID0ge1xuXHRUWVBFX01JU01BVENIOiAnVHlwZSBNaXNtYXRjaCcsXG5cdEFDQ0VTU19ERU5JRUQ6ICdWYWx1ZSBBY2Nlc3MgRGVuaWVkJyxcblx0UklQX0ZVTkNUSU9OUzogJ0Z1bmN0aW9ucyBhcmUgUmVzdHJpY3RlZCcsXG5cdEZPUkJJRERFTl9SRTogJ1JlLUFzc2lybm1lbnQgaXMgRm9yYmlkZGVuJyxcblx0Rk9SQklEREVOX1VOV1JBUDogJ1Vud3JhcCBpcyBhbGxvd2VkIG9ubHkgZm9yIGZpbmFsaXplZCBmaWVsZHMnLFxuXHQvLyBNSVNTSU5HX1BST1A6ICdBdHRlbXB0IHRvIEFjY2VzcyB0byBVbmRlZmluZWQgUHJvcCcsXG59O1xuIl19 \ No newline at end of file diff --git a/lib/esm/errors.d.ts b/lib/esm/errors.d.ts index 6615394..445a1f1 100644 --- a/lib/esm/errors.d.ts +++ b/lib/esm/errors.d.ts @@ -3,4 +3,5 @@ export declare const ErrorsNames: { ACCESS_DENIED: string; RIP_FUNCTIONS: string; FORBIDDEN_RE: string; + FORBIDDEN_UNWRAP: string; }; diff --git a/lib/esm/errors.js b/lib/esm/errors.js index 0bdf37e..448168c 100644 --- a/lib/esm/errors.js +++ b/lib/esm/errors.js @@ -1,9 +1,10 @@ 'use strict'; export const ErrorsNames = { - TYPE_MISMATCH: 'Type Mismatch', - ACCESS_DENIED: 'Value Access Denied', - RIP_FUNCTIONS: 'Functions are Restricted', - FORBIDDEN_RE: 'Re-Assirnment is Forbidden', - // MISSING_PROP: 'Attempt to Access to Undefined Prop', + TYPE_MISMATCH: 'Type Mismatch', + ACCESS_DENIED: 'Value Access Denied', + RIP_FUNCTIONS: 'Functions are Restricted', + FORBIDDEN_RE: 'Re-Assirnment is Forbidden', + FORBIDDEN_UNWRAP: 'Unwrap is allowed only for finalized fields', + // MISSING_PROP: 'Attempt to Access to Undefined Prop', }; -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7QUFFYixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDMUIsYUFBYSxFQUFFLGVBQWU7SUFDOUIsYUFBYSxFQUFFLHFCQUFxQjtJQUNwQyxhQUFhLEVBQUUsMEJBQTBCO0lBQ3pDLFlBQVksRUFBRSw0QkFBNEI7SUFDMUMsdURBQXVEO0NBQ3ZELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmV4cG9ydCBjb25zdCBFcnJvcnNOYW1lcyA9IHtcblx0VFlQRV9NSVNNQVRDSDogJ1R5cGUgTWlzbWF0Y2gnLFxuXHRBQ0NFU1NfREVOSUVEOiAnVmFsdWUgQWNjZXNzIERlbmllZCcsXG5cdFJJUF9GVU5DVElPTlM6ICdGdW5jdGlvbnMgYXJlIFJlc3RyaWN0ZWQnLFxuXHRGT1JCSURERU5fUkU6ICdSZS1Bc3Npcm5tZW50IGlzIEZvcmJpZGRlbicsXG5cdC8vIE1JU1NJTkdfUFJPUDogJ0F0dGVtcHQgdG8gQWNjZXNzIHRvIFVuZGVmaW5lZCBQcm9wJyxcbn07XG4iXX0= \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7QUFFYixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDMUIsYUFBYSxFQUFFLGVBQWU7SUFDOUIsYUFBYSxFQUFFLHFCQUFxQjtJQUNwQyxhQUFhLEVBQUUsMEJBQTBCO0lBQ3pDLFlBQVksRUFBRSw0QkFBNEI7SUFDMUMsZ0JBQWdCLEVBQUUsNkNBQTZDO0lBQy9ELHVEQUF1RDtDQUN2RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5leHBvcnQgY29uc3QgRXJyb3JzTmFtZXMgPSB7XG5cdFRZUEVfTUlTTUFUQ0g6ICdUeXBlIE1pc21hdGNoJyxcblx0QUNDRVNTX0RFTklFRDogJ1ZhbHVlIEFjY2VzcyBEZW5pZWQnLFxuXHRSSVBfRlVOQ1RJT05TOiAnRnVuY3Rpb25zIGFyZSBSZXN0cmljdGVkJyxcblx0Rk9SQklEREVOX1JFOiAnUmUtQXNzaXJubWVudCBpcyBGb3JiaWRkZW4nLFxuXHRGT1JCSURERU5fVU5XUkFQOiAnVW53cmFwIGlzIGFsbG93ZWQgb25seSBmb3IgZmluYWxpemVkIGZpZWxkcycsXG5cdC8vIE1JU1NJTkdfUFJPUDogJ0F0dGVtcHQgdG8gQWNjZXNzIHRvIFVuZGVmaW5lZCBQcm9wJyxcbn07XG4iXX0= \ No newline at end of file diff --git a/lib/esm/fields.js b/lib/esm/fields.js index dc9c106..1095d2e 100644 --- a/lib/esm/fields.js +++ b/lib/esm/fields.js @@ -5,24 +5,24 @@ const SymbolInitialValue = Symbol('Initial Value'); // this[SymbolInitialValue] = value; // } as ObjectConstructor; export class FieldConstructor { - [SymbolInitialValue]; - get get() { - const self = this; - return function ( /* this: FieldDefinition */) { - return self[SymbolInitialValue]; - }; - } - get set() { - return function () { - throw new TypeError(ErrorsNames.FORBIDDEN_RE); - }; - } - constructor(value) { - this[SymbolInitialValue] = value; - } - static get SymbolInitialValue() { - return SymbolInitialValue; - } + [SymbolInitialValue]; + get get() { + const self = this; + return function ( /* this: FieldDefinition */) { + return self[SymbolInitialValue]; + }; + } + get set() { + return function () { + throw new TypeError(ErrorsNames.FORBIDDEN_RE); + }; + } + constructor(value) { + this[SymbolInitialValue] = value; + } + static get SymbolInitialValue() { + return SymbolInitialValue; + } } // Object.assign(FieldConstructor.prototype, { // configurable: false, diff --git a/lib/esm/index.d.ts b/lib/esm/index.d.ts index 4a25d32..59b4356 100644 --- a/lib/esm/index.d.ts +++ b/lib/esm/index.d.ts @@ -16,3 +16,31 @@ export declare const SymbolInitialValue: symbol; declare const FieldConstructorExport: typeof FieldConstructor; export { FieldConstructorExport as FieldConstructor }; export declare const Strict: (_target?: object, options?: TypeomaticaOptions) => (cstr: T) => T; +/** + * Fields that certainly passed through the define machinery for this + * instance. Returns a copy of the internal Set — safe for the caller + * to mutate. + */ +export declare const getConstructedFields: (instance: object) => Set; +/** + * Auto finalization: every hiddenly-added own field of the instance + * (class fields and other define-semantics writes that bypassed the + * proxy) is deleted and re-established through the define machinery. + * Sets the finalized flag — `true` means auto mode ran. + */ +export declare const finalize: (instance: object) => void; +/** + * Partial finalization: re-establish only the listed fields. + * Does NOT set the finalized flag — that flag means auto mode ran, + * everything else is the user's choice. + */ +export declare const finalizeBy: (instance: object, fields: (string | symbol)[]) => void; +export declare const isFinalized: (instance: object) => boolean; +/** + * Turn a guarded field back into a plain value property. + * Allowed only for fields re-established by finalize/finalizeBy — + * they stay configurable by design. Fields guarded since construction + * are non-configurable: that lock is the essential design of the lib. + * Primitives are read back via .valueOf(); objects are placed as-is. + */ +export declare const unwrap: (instance: object, field: string | symbol) => void; diff --git a/lib/esm/index.js b/lib/esm/index.js index 8edcd60..4d973db 100644 --- a/lib/esm/index.js +++ b/lib/esm/index.js @@ -4,344 +4,471 @@ import { inspect } from 'util'; import { ErrorsNames } from './errors.js'; import { functions, nullish, objects, primitives, special, isPrimitive } from './types/index.js'; import { FieldConstructor } from './fields.js'; +// Fields that passed through the define machinery, per instance. +// The postConstruction comparator (Thunderstruck design) diffs the +// instance's own descriptors against this Set to find fields added +// hiddenly — class fields and other define-semantics writes. +const constructionRecords = new WeakMap(); +const ensureRecord = (instance) => { + let record = constructionRecords.get(instance); + if (!record) { + record = { + fields: new Set(), + options: undefined, + finalized: false + }; + constructionRecords.set(instance, record); + } + return record; +}; const createResolver = (options = {}) => { - const { strictAccessCheck = false } = options; - return Object.entries({ - primitives, - special, - nullish, - objects, - functions - }).reduce((obj, [key, _handler]) => { - // @ts-ignore - obj[key] = function (initialValue, receiver) { - const handler = _handler(initialValue); - return { - get() { - const invocationThis = this; - if (strictAccessCheck && invocationThis !== receiver) { - throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - } - const result = handler.get(); - return result; - }, - set(replacementValue) { - const invocationThis = this; - if (strictAccessCheck && invocationThis !== receiver) { - throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - } - const result = handler.set(replacementValue); - return result; - } - }; - }; - return obj; - }, {}); + const { strictAccessCheck = false } = options; + return Object.entries({ + primitives, + special, + nullish, + objects, + functions + }).reduce((obj, [key, _handler]) => { + // @ts-ignore + obj[key] = function (initialValue, receiver) { + const handler = _handler(initialValue); + return { + get() { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + } + const result = handler.get(); + return result; + }, + set(replacementValue) { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + } + const result = handler.set(replacementValue); + return result; + } + }; + }; + return obj; + }, {}); }; -const createProperty = (propName, initialValue, receiver, options) => { - const value = initialValue; - const valueIsPrimitive = isPrimitive(initialValue); - const isObject = typeof initialValue === 'object'; - const isFunction = initialValue instanceof Function; - const isNull = initialValue === null; - /** +const createProperty = (propName, initialValue, receiver, options, configurable = false) => { + const value = initialValue; + const valueIsPrimitive = isPrimitive(initialValue); + const isObject = typeof initialValue === 'object'; + const isFunction = initialValue instanceof Function; + const isNull = initialValue === null; + /** * special: undefined or BigInt or Symbol * or other non constructible type */ - const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special')); - const resolver = createResolver(options); - const descriptor = (isObject && (value instanceof FieldConstructor)) ? - value : { - enumerable: true, - // @ts-ignore - ...resolver[types](value, receiver), - }; - // if (value instanceof FieldConstructor) { - // descriptor; - // debugger; - // } - const result = Reflect.defineProperty(receiver, propName, descriptor); - return result; + const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special')); + const resolver = createResolver(options); + const descriptor = (isObject && (value instanceof FieldConstructor)) ? + value : { + enumerable: true, + configurable, + // @ts-ignore + ...resolver[types](value, receiver), + }; + // if (value instanceof FieldConstructor) { + // descriptor; + // debugger; + // } + const result = Reflect.defineProperty(receiver, propName, descriptor); + const record = ensureRecord(receiver); + record.fields.add(propName); + record.options = options; + return result; }; // line below 'href' is for util.inspect works, useful for v24 const props2skip = new Set([ - Symbol.toStringTag, - Symbol.iterator, - // Symbol.toPrimitive, - 'toString', - 'valueOf', - 'href' + Symbol.toStringTag, + Symbol.iterator, + // Symbol.toPrimitive, + 'toString', + 'valueOf', + 'href' ]); // const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]); const hasNodeInspect = (inspect && inspect.custom); // oxlint-disable-next-line no-unused-expressions (hasNodeInspect && (props2skip.add(inspect.custom))); const createHandlers = (options) => ({ - get(target, prop, receiver) { - const result = Reflect.get(target, prop, receiver); - if (result !== undefined) { - return result; - } - if (prop === 'toJSON') { - - return function () { - const entries = Object.entries(this); - return JSON.stringify(entries.reduce((obj, [key, value]) => { - // @ts-ignore - obj[key] = value.valueOf(); - return obj; - }, {})); - }; - } - if (prop === 'constructor') { - return undefined; - } - const { name } = receiver.constructor; - if (props2skip.has(prop)) { - const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; - return message; - } - // const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`; - // throw new Error(errorMessage); - }, - set(_, prop, value, receiver) { - const result = createProperty(prop, value, receiver, options); - return result; - }, - setPrototypeOf() { - throw new Error('Setting prototype is not allowed!'); - }, - // defineProperty(target: object, key: string, descriptor: object) { - defineProperty() { - throw new Error('Defining new Properties is not allowed!'); - // Reflect.defineProperty(target, key, descriptor); - }, - deleteProperty() { - throw new Error('Properties Deletion is not allowed!'); - }, - // getPrototypeOf() { - // debugger; - // throw new Error('Getting prototype is not allowed'); - // }, + get(target, prop, receiver) { + const result = Reflect.get(target, prop, receiver); + if (result !== undefined) { + return result; + } + if (prop === 'toJSON') { + // eslint-disable-next-line no-unused-vars + return function () { + const entries = Object.entries(this); + return JSON.stringify(entries.reduce((obj, [key, value]) => { + // @ts-ignore + obj[key] = value.valueOf(); + return obj; + }, {})); + }; + } + if (prop === 'constructor') { + return undefined; + } + const { name } = receiver.constructor; + if (props2skip.has(prop)) { + const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; + return message; + } + // const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`; + // throw new Error(errorMessage); + }, + set(_, prop, value, receiver) { + const result = createProperty(prop, value, receiver, options); + return result; + }, + setPrototypeOf() { + throw new Error('Setting prototype is not allowed!'); + }, + // defineProperty(target: object, key: string, descriptor: object) { + defineProperty() { + throw new Error('Defining new Properties is not allowed!'); + // Reflect.defineProperty(target, key, descriptor); + }, + deleteProperty() { + throw new Error('Properties Deletion is not allowed!'); + }, + // getPrototypeOf() { + // debugger; + // throw new Error('Getting prototype is not allowed'); + // }, }); // user have to precisely define all props export const baseTarget = (_proto) => { - const proto = typeof _proto === 'object' ? _proto : null; - const answer = Object.create(proto); - return answer; + const proto = typeof _proto === 'object' ? _proto : null; + const answer = Object.create(proto); + return answer; }; export const SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference'); const getTypeomaticaProxyReference = (_target, options) => { - const target = Object.create(_target); - const id = `TypeØmaticaProxyReference-${Math.random()}`; - Object.defineProperty(target, SymbolTypeomaticaProxyReference, { - get() { - return id; - } - }); - const handlers = createHandlers(options); - const proxy = new Proxy(target, handlers); - return proxy; + const target = Object.create(_target); + const id = `TypeØmaticaProxyReference-${Math.random()}`; + Object.defineProperty(target, SymbolTypeomaticaProxyReference, { + get() { + return id; + } + }); + const handlers = createHandlers(options); + const proxy = new Proxy(target, handlers); + return proxy; }; export const BaseConstructorPrototype = function (_target, options) { - if (!new.target) { - const self = BaseConstructorPrototype.bind(this, _target, options); - self.prototype = { - constructor: BaseConstructorPrototype - }; - // @ts-ignore - return self; - } - // @ts-ignore - if (this[SymbolTypeomaticaProxyReference]) { - // @ts-ignore - 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; - let constructors = false; - // @ts-ignore - // const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean; - // if (hasProxyReference) { - // throw new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!'); - // } - do { - proto = protoPointer; - protoPointer = Object.getPrototypeOf(proto); - if (BaseConstructorPrototype.prototype === protoPointer) { - constructors = true; - break; - } - if (!protoPointer) - break; - const descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor'); - if (!descriptor) - continue; - const value = descriptor.value || descriptor.get; - // if (!value) continue; - protoConstrcutor = value; - } while (protoConstrcutor !== BaseConstructorPrototype); - if (!constructors && protoConstrcutor !== BaseConstructorPrototype) { - throw new Error('Unable to setup TypeØmatica handler!'); - } - Object.setPrototypeOf(proto, InstancePrototype); - if (freezeProtos) { - Object.freeze(classPrototype); - } - // @ts-ignore - return this; - + if (!new.target) { + const self = BaseConstructorPrototype.bind(this, _target, options); + self.prototype = { + constructor: BaseConstructorPrototype + }; + // @ts-ignore + return self; + } + // @ts-ignore + if (this[SymbolTypeomaticaProxyReference]) { + // @ts-ignore + 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; + let constructors = false; + // @ts-ignore + // const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean; + // if (hasProxyReference) { + // throw new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!'); + // } + do { + proto = protoPointer; + protoPointer = Object.getPrototypeOf(proto); + if (BaseConstructorPrototype.prototype === protoPointer) { + constructors = true; + break; + } + if (!protoPointer) + break; + const descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor'); + if (!descriptor) + continue; + const value = descriptor.value || descriptor.get; + // if (!value) continue; + protoConstrcutor = value; + } while (protoConstrcutor !== BaseConstructorPrototype); + if (!constructors && protoConstrcutor !== BaseConstructorPrototype) { + throw new Error('Unable to setup TypeØmatica handler!'); + } + Object.setPrototypeOf(proto, InstancePrototype); + if (freezeProtos) { + Object.freeze(classPrototype); + } + // @ts-ignore + return this; + /* eslint-disable no-unused-vars */ }; - +/* eslint-enable no-unused-vars */ 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); + 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); - 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); - } + 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); + 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]) { - return cstr; - } - const target = baseTarget(_target); - const proxy = getTypeomaticaProxyReference(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) { - // debugger; - // const target = baseTarget(_target); - // const proxy = getTypeomaticaProxyReference(target); - // const _replacer = Object.create(proxy); - // const _proto = cstr.prototype; - // const proto = Object.create(Object.getPrototypeOf(_proto)); - // proto.iAmProto = true; - // Object.setPrototypeOf(cstr.prototype, proto); - // const descriptors = Object.getOwnPropertyDescriptors(_proto); - // Object.defineProperties(proto, descriptors); - // const replacer = Object.create(_replacer); - // Object.setPrototypeOf(proto, replacer); - // Object.setPrototypeOf(cstr.prototype, proto); - // const result = Reflect.construct(cstr, argumentsList, newTarget); - // debugger; - // Object.setPrototypeOf(cstr.prototype, _proto); - // debugger; - // return result; - // }, - // }); - // return MyClassProxy; - }; - return decorator; + const { frozenPrototypes: freezeProtos = true } = options || {}; + const decorator = function (cstr) { + // @ts-ignore + if (cstr.prototype[SymbolTypeomaticaProxyReference]) { + return cstr; + } + const target = baseTarget(_target); + const proxy = getTypeomaticaProxyReference(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) { + // debugger; + // const target = baseTarget(_target); + // const proxy = getTypeomaticaProxyReference(target); + // const _replacer = Object.create(proxy); + // const _proto = cstr.prototype; + // const proto = Object.create(Object.getPrototypeOf(_proto)); + // proto.iAmProto = true; + // Object.setPrototypeOf(cstr.prototype, proto); + // const descriptors = Object.getOwnPropertyDescriptors(_proto); + // Object.defineProperties(proto, descriptors); + // const replacer = Object.create(_replacer); + // Object.setPrototypeOf(proto, replacer); + // Object.setPrototypeOf(cstr.prototype, proto); + // const result = Reflect.construct(cstr, argumentsList, newTarget); + // debugger; + // Object.setPrototypeOf(cstr.prototype, _proto); + // debugger; + // return result; + // }, + // }); + // return MyClassProxy; + }; + return decorator; }; export const { SymbolInitialValue } = FieldConstructor; const FieldConstructorExport = FieldConstructor; export { FieldConstructorExport as FieldConstructor }; export const Strict = strict; +/** + * Fields that certainly passed through the define machinery for this + * instance. Returns a copy of the internal Set — safe for the caller + * to mutate. + */ +export const getConstructedFields = (instance) => { + const record = constructionRecords.get(instance); + const result = record ? new Set(record.fields) : new Set(); + return result; +}; +const finaliseFields = (instance, names) => { + const record = ensureRecord(instance); + names.forEach((name) => { + if (record.fields.has(name)) { + // already passed through the machinery + return; + } + const descriptor = Reflect.getOwnPropertyDescriptor(instance, name); + if (!descriptor || !('value' in descriptor)) { + // nothing hidden under that name, or not a data field + return; + } + delete instance[name]; + // finalized fields stay configurable: they are the ones `unwrap` + // is allowed to turn back into plain value properties + createProperty(name, descriptor.value, instance, record.options, true); + }); +}; +/** + * Auto finalization: every hiddenly-added own field of the instance + * (class fields and other define-semantics writes that bypassed the + * proxy) is deleted and re-established through the define machinery. + * Sets the finalized flag — `true` means auto mode ran. + */ +export const finalize = (instance) => { + const record = ensureRecord(instance); + finaliseFields(instance, Reflect.ownKeys(instance)); + record.finalized = true; +}; +/** + * Partial finalization: re-establish only the listed fields. + * Does NOT set the finalized flag — that flag means auto mode ran, + * everything else is the user's choice. + */ +export const finalizeBy = (instance, fields) => { + finaliseFields(instance, fields); +}; +export const isFinalized = (instance) => { + const record = constructionRecords.get(instance); + const result = record ? record.finalized : false; + return result; +}; +/** + * Turn a guarded field back into a plain value property. + * Allowed only for fields re-established by finalize/finalizeBy — + * they stay configurable by design. Fields guarded since construction + * are non-configurable: that lock is the essential design of the lib. + * Primitives are read back via .valueOf(); objects are placed as-is. + */ +export const unwrap = (instance, field) => { + const descriptor = Reflect.getOwnPropertyDescriptor(instance, field); + if (!descriptor || !descriptor.configurable || typeof descriptor.get !== 'function') { + throw new TypeError(ErrorsNames.FORBIDDEN_UNWRAP); + } + const current = instance[field]; + const currentValueOf = current?.valueOf; + const unwrapped = typeof currentValueOf === 'function' + ? current.valueOf() + : current; + Object.defineProperty(instance, field, { + value: unwrapped, + writable: true, + enumerable: true, + configurable: true + }); +}; /* istanbul ignore next */ function setupCommonJS() { - if (typeof module === 'undefined' || typeof module.exports === 'undefined') { - return; - } - Object.defineProperty(module, 'exports', { - get() { - return BaseConstructorPrototype; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'BaseClass', { - get() { - return BaseClass; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'FieldConstructor', { - get() { - return FieldConstructor; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'SymbolInitialValue', { - get() { - return SymbolInitialValue; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', { - get() { - return SymbolTypeomaticaProxyReference; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'baseTarget', { - get() { - return baseTarget; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'Strict', { - get() { - return strict; - }, - enumerable: true - }); + if (typeof module === 'undefined' || typeof module.exports === 'undefined') { + return; + } + Object.defineProperty(module, 'exports', { + get() { + return BaseConstructorPrototype; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'BaseClass', { + get() { + return BaseClass; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'FieldConstructor', { + get() { + return FieldConstructor; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'SymbolInitialValue', { + get() { + return SymbolInitialValue; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', { + get() { + return SymbolTypeomaticaProxyReference; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'baseTarget', { + get() { + return baseTarget; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'Strict', { + get() { + return strict; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'getConstructedFields', { + get() { + return getConstructedFields; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalize', { + get() { + return finalize; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalizeBy', { + get() { + return finalizeBy; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'isFinalized', { + get() { + return isFinalized; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'unwrap', { + get() { + return unwrap; + }, + enumerable: true + }); } 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\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 +//# 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\ninterface ConstructionRecord {\n\tfields    : Set<string | symbol>;\n\toptions   : TypeomaticaOptions | undefined;\n\tfinalized : boolean;\n}\n\n// Fields that passed through the define machinery, per instance.\n// The postConstruction comparator (Thunderstruck design) diffs the\n// instance's own descriptors against this Set to find fields added\n// hiddenly — class fields and other define-semantics writes.\nconst constructionRecords = new WeakMap<object, ConstructionRecord>();\n\nconst ensureRecord = (instance: object): ConstructionRecord => {\n\tlet record = constructionRecords.get(instance);\n\tif (!record) {\n\t\trecord = {\n\t\t\tfields    : new Set(),\n\t\t\toptions   : undefined,\n\t\t\tfinalized : false\n\t\t};\n\t\tconstructionRecords.set(instance, record);\n\t}\n\treturn record;\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 | symbol, initialValue: unknown, receiver: object, options?: TypeomaticaOptions, configurable = false) => {\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\tconfigurable,\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\n\tconst record = ensureRecord(receiver);\n\trecord.fields.add(propName);\n\trecord.options = options;\n\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/**\n * Fields that certainly passed through the define machinery for this\n * instance. Returns a copy of the internal Set — safe for the caller\n * to mutate.\n */\nexport const getConstructedFields = (instance: object): Set<string | symbol> => {\n\tconst record = constructionRecords.get(instance);\n\tconst result = record ? new Set(record.fields) : new Set<string | symbol>();\n\treturn result;\n};\n\nconst finaliseFields = (instance: object, names: (string | symbol)[]): void => {\n\tconst record = ensureRecord(instance);\n\tnames.forEach((name) => {\n\t\tif (record.fields.has(name)) {\n\t\t\t// already passed through the machinery\n\t\t\treturn;\n\t\t}\n\t\tconst descriptor = Reflect.getOwnPropertyDescriptor(instance, name);\n\t\tif (!descriptor || !('value' in descriptor)) {\n\t\t\t// nothing hidden under that name, or not a data field\n\t\t\treturn;\n\t\t}\n\t\tdelete (instance as Record<PropertyKey, unknown>)[name];\n\t\t// finalized fields stay configurable: they are the ones `unwrap`\n\t\t// is allowed to turn back into plain value properties\n\t\tcreateProperty(name, descriptor.value, instance, record.options, true);\n\t});\n};\n\n/**\n * Auto finalization: every hiddenly-added own field of the instance\n * (class fields and other define-semantics writes that bypassed the\n * proxy) is deleted and re-established through the define machinery.\n * Sets the finalized flag — `true` means auto mode ran.\n */\nexport const finalize = (instance: object): void => {\n\tconst record = ensureRecord(instance);\n\tfinaliseFields(instance, Reflect.ownKeys(instance));\n\trecord.finalized = true;\n};\n\n/**\n * Partial finalization: re-establish only the listed fields.\n * Does NOT set the finalized flag — that flag means auto mode ran,\n * everything else is the user's choice.\n */\nexport const finalizeBy = (instance: object, fields: (string | symbol)[]): void => {\n\tfinaliseFields(instance, fields);\n};\n\nexport const isFinalized = (instance: object): boolean => {\n\tconst record = constructionRecords.get(instance);\n\tconst result = record ? record.finalized : false;\n\treturn result;\n};\n\n/**\n * Turn a guarded field back into a plain value property.\n * Allowed only for fields re-established by finalize/finalizeBy —\n * they stay configurable by design. Fields guarded since construction\n * are non-configurable: that lock is the essential design of the lib.\n * Primitives are read back via .valueOf(); objects are placed as-is.\n */\nexport const unwrap = (instance: object, field: string | symbol): void => {\n\tconst descriptor = Reflect.getOwnPropertyDescriptor(instance, field);\n\tif (!descriptor || !descriptor.configurable || typeof descriptor.get !== 'function') {\n\t\tthrow new TypeError(ErrorsNames.FORBIDDEN_UNWRAP);\n\t}\n\tconst current = (instance as Record<PropertyKey, unknown>)[field];\n\tconst currentValueOf = (current as { valueOf?: unknown })?.valueOf;\n\tconst unwrapped = typeof currentValueOf === 'function'\n\t\t? (current as { valueOf: () => unknown }).valueOf()\n\t\t: current;\n\tObject.defineProperty(instance, field, {\n\t\tvalue        : unwrapped,\n\t\twritable     : true,\n\t\tenumerable   : true,\n\t\tconfigurable : true\n\t});\n};\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\tObject.defineProperty(module.exports, 'getConstructedFields', {\n\t\tget() {\n\t\t\treturn getConstructedFields;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'finalize', {\n\t\tget() {\n\t\t\treturn finalize;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'finalizeBy', {\n\t\tget() {\n\t\t\treturn finalizeBy;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'isFinalized', {\n\t\tget() {\n\t\t\treturn isFinalized;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'unwrap', {\n\t\tget() {\n\t\t\treturn unwrap;\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/esm/types/functions.js b/lib/esm/types/functions.js index 620dd96..527c2db 100644 --- a/lib/esm/types/functions.js +++ b/lib/esm/types/functions.js @@ -1,6 +1,6 @@ 'use strict'; import { ErrorsNames } from '../errors.js'; export const functions = () => { - throw new TypeError(ErrorsNames.RIP_FUNCTIONS); + throw new TypeError(ErrorsNames.RIP_FUNCTIONS); }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3R5cGVzL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7QUFFYixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRTNDLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxHQUFHLEVBQUU7SUFDN0IsTUFBTSxJQUFJLFNBQVMsQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7QUFDaEQsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycy5qcyc7XG5cbmV4cG9ydCBjb25zdCBmdW5jdGlvbnMgPSAoKSA9PiB7XG5cdHRocm93IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuUklQX0ZVTkNUSU9OUyk7XG59OyJdfQ== \ No newline at end of file diff --git a/lib/esm/types/index.js b/lib/esm/types/index.js index 02e2db4..d4b5d2b 100644 --- a/lib/esm/types/index.js +++ b/lib/esm/types/index.js @@ -5,11 +5,11 @@ export { objects } from './objects.js'; export { primitives } from './primitives.js'; export { special } from './special.js'; const PRIMITIVE_TYPES = [ - 'string', - 'number', - 'boolean', + 'string', + 'number', + 'boolean', ]; export const isPrimitive = (value) => { - return PRIMITIVE_TYPES.includes(typeof value); + return PRIMITIVE_TYPES.includes(typeof value); }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDO0FBRWIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDdkMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUV2QyxNQUFNLGVBQWUsR0FBRztJQUN2QixRQUFRO0lBQ1IsUUFBUTtJQUNSLFNBQVM7Q0FDVCxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLENBQUMsS0FBYyxFQUFFLEVBQUU7SUFDN0MsT0FBTyxlQUFlLENBQUMsUUFBUSxDQUFDLE9BQU8sS0FBSyxDQUFDLENBQUM7QUFDL0MsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5leHBvcnQgeyBmdW5jdGlvbnMgfSBmcm9tICcuL2Z1bmN0aW9ucy5qcyc7XG5leHBvcnQgeyBudWxsaXNoIH0gZnJvbSAnLi9udWxsaXNoLmpzJztcbmV4cG9ydCB7IG9iamVjdHMgfSBmcm9tICcuL29iamVjdHMuanMnO1xuZXhwb3J0IHsgcHJpbWl0aXZlcyB9IGZyb20gJy4vcHJpbWl0aXZlcy5qcyc7XG5leHBvcnQgeyBzcGVjaWFsIH0gZnJvbSAnLi9zcGVjaWFsLmpzJztcblxuY29uc3QgUFJJTUlUSVZFX1RZUEVTID0gW1xuXHQnc3RyaW5nJyxcblx0J251bWJlcicsXG5cdCdib29sZWFuJyxcbl07XG5cbmV4cG9ydCBjb25zdCBpc1ByaW1pdGl2ZSA9ICh2YWx1ZTogdW5rbm93bikgPT4ge1xuXHRyZXR1cm4gUFJJTUlUSVZFX1RZUEVTLmluY2x1ZGVzKHR5cGVvZiB2YWx1ZSk7XG59O1xuIl19 \ No newline at end of file diff --git a/lib/esm/types/nullish.js b/lib/esm/types/nullish.js index ef7e049..755ba7a 100644 --- a/lib/esm/types/nullish.js +++ b/lib/esm/types/nullish.js @@ -1,14 +1,14 @@ 'use strict'; import { ErrorsNames } from '../errors.js'; export const nullish = (value) => { - return { - get() { - return value; - }, - set() { - const error = new TypeError(ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set() { + const error = new TypeError(ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9udWxsaXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQztBQUViLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHO1lBQ0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQ3ZELE1BQU0sS0FBSyxDQUFDO1FBQ2IsQ0FBQztLQUNELENBQUM7QUFDSCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IEVycm9yc05hbWVzIH0gZnJvbSAnLi4vZXJyb3JzLmpzJztcblxuZXhwb3J0IGNvbnN0IG51bGxpc2ggPSAodmFsdWU6IG9iamVjdCkgPT4ge1xuXHRyZXR1cm4ge1xuXHRcdGdldCgpIHtcblx0XHRcdHJldHVybiB2YWx1ZTtcblx0XHR9LFxuXHRcdHNldCgpIHtcblx0XHRcdGNvbnN0IGVycm9yID0gbmV3IFR5cGVFcnJvcihFcnJvcnNOYW1lcy5UWVBFX01JU01BVENIKTtcblx0XHRcdHRocm93IGVycm9yO1xuXHRcdH1cblx0fTtcbn07Il19 \ No newline at end of file diff --git a/lib/esm/types/objects.js b/lib/esm/types/objects.js index 854a61e..cf00c93 100644 --- a/lib/esm/types/objects.js +++ b/lib/esm/types/objects.js @@ -1,18 +1,18 @@ 'use strict'; import { ErrorsNames } from '../errors.js'; export const objects = (value) => { - return { - get() { - return value; - }, - set(replacementValue) { - if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) { - value = replacementValue; - return value; - } - const error = new TypeError(ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set(replacementValue) { + if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) { + value = replacementValue; + return value; + } + const error = new TypeError(ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9vYmplY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQztBQUViLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXlCO1lBQzVCLElBQUksZ0JBQWdCLFlBQVksTUFBTSxJQUFJLGdCQUFnQixDQUFDLFdBQVcsS0FBSyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUM7Z0JBQzlGLEtBQUssR0FBRyxnQkFBZ0IsQ0FBQztnQkFDekIsT0FBTyxLQUFLLENBQUM7WUFDZCxDQUFDO1lBQ0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQ3ZELE1BQU0sS0FBSyxDQUFDO1FBQ2IsQ0FBQztLQUNELENBQUM7QUFDSCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IEVycm9yc05hbWVzIH0gZnJvbSAnLi4vZXJyb3JzLmpzJztcblxuZXhwb3J0IGNvbnN0IG9iamVjdHMgPSAodmFsdWU6IG9iamVjdCkgPT4ge1xuXHRyZXR1cm4ge1xuXHRcdGdldCgpIHtcblx0XHRcdHJldHVybiB2YWx1ZTtcblx0XHR9LFxuXHRcdHNldChyZXBsYWNlbWVudFZhbHVlOiB1bmtub3duKSB7XG5cdFx0XHRpZiAocmVwbGFjZW1lbnRWYWx1ZSBpbnN0YW5jZW9mIE9iamVjdCAmJiByZXBsYWNlbWVudFZhbHVlLmNvbnN0cnVjdG9yID09PSB2YWx1ZS5jb25zdHJ1Y3Rvcikge1xuXHRcdFx0XHR2YWx1ZSA9IHJlcGxhY2VtZW50VmFsdWU7XG5cdFx0XHRcdHJldHVybiB2YWx1ZTtcblx0XHRcdH1cblx0XHRcdGNvbnN0IGVycm9yID0gbmV3IFR5cGVFcnJvcihFcnJvcnNOYW1lcy5UWVBFX01JU01BVENIKTtcblx0XHRcdHRocm93IGVycm9yO1xuXHRcdH1cblx0fTtcbn07Il19 \ No newline at end of file diff --git a/lib/esm/types/primitives.js b/lib/esm/types/primitives.js index 57f6828..6c3f5b6 100644 --- a/lib/esm/types/primitives.js +++ b/lib/esm/types/primitives.js @@ -1,61 +1,61 @@ 'use strict'; import { ErrorsNames } from '../errors.js'; export const primitives = (initialValue) => { - let value = Object(initialValue); - const initialType = typeof initialValue; - return { - get() { - const proxyAsValue = new Proxy(value, { - // get(target, prop, receiver) { - get(_, prop) { - if (prop === Symbol.toPrimitive) { - return function (hint) { - if (hint !== initialType) { - throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - } - return value.valueOf(); - }; - } - if (prop === 'valueOf') { - return function () { - return value.valueOf(); - }; - } - // @ts-ignore - if (value[prop] instanceof Function) { - return value[prop].bind(value); - } - const answer = value[prop]; - return answer; - } - }); - return proxyAsValue; - }, - // get() { - // const preparedValue = { - // [Symbol.toPrimitive]() { - // return function () { - // throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - // }; - // } - // }; - // Reflect.setPrototypeOf(preparedValue, value); - // debugger; - // return preparedValue; - // }, - set(replacementValue) { - if (replacementValue instanceof value.constructor) { - value = replacementValue; - return value; - } - const prevalue = Object(replacementValue); - if (prevalue instanceof value.constructor) { - value = prevalue; - return value; - } - const error = new TypeError(ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + let value = Object(initialValue); + const initialType = typeof initialValue; + return { + get() { + const proxyAsValue = new Proxy(value, { + // get(target, prop, receiver) { + get(_, prop) { + if (prop === Symbol.toPrimitive) { + return function (hint) { + if (hint !== initialType) { + throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + } + return value.valueOf(); + }; + } + if (prop === 'valueOf') { + return function () { + return value.valueOf(); + }; + } + // @ts-ignore + if (value[prop] instanceof Function) { + return value[prop].bind(value); + } + const answer = value[prop]; + return answer; + } + }); + return proxyAsValue; + }, + // get() { + // const preparedValue = { + // [Symbol.toPrimitive]() { + // return function () { + // throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + // }; + // } + // }; + // Reflect.setPrototypeOf(preparedValue, value); + // debugger; + // return preparedValue; + // }, + set(replacementValue) { + if (replacementValue instanceof value.constructor) { + value = replacementValue; + return value; + } + const prevalue = Object(replacementValue); + if (prevalue instanceof value.constructor) { + value = prevalue; + return value; + } + const error = new TypeError(ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; //# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/esm/types/special.js b/lib/esm/types/special.js index ed49aa7..3bfaa93 100644 --- a/lib/esm/types/special.js +++ b/lib/esm/types/special.js @@ -1,18 +1,18 @@ 'use strict'; import { ErrorsNames } from '../errors.js'; export const special = (value) => { - return { - get() { - return value; - }, - set(replacementValue) { - if (typeof replacementValue === typeof value) { - value = replacementValue; - return value; - } - const error = new TypeError(ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set(replacementValue) { + if (typeof replacementValue === typeof value) { + value = replacementValue; + return value; + } + const error = new TypeError(ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlY2lhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90eXBlcy9zcGVjaWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQztBQUViLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXdCO1lBQzNCLElBQUksT0FBTyxnQkFBZ0IsS0FBSyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUM5QyxLQUFLLEdBQUcsZ0JBQWdCLENBQUM7Z0JBQ3pCLE9BQU8sS0FBSyxDQUFDO1lBQ2QsQ0FBQztZQUNELE1BQU0sS0FBSyxHQUFHLElBQUksU0FBUyxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUN2RCxNQUFNLEtBQUssQ0FBQztRQUNiLENBQUM7S0FDRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycy5qcyc7XG5cbmV4cG9ydCBjb25zdCBzcGVjaWFsID0gKHZhbHVlOiBvYmplY3QpID0+IHtcblx0cmV0dXJuIHtcblx0XHRnZXQoKSB7XG5cdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0fSxcblx0XHRzZXQocmVwbGFjZW1lbnRWYWx1ZTogb2JqZWN0KSB7XG5cdFx0XHRpZiAodHlwZW9mIHJlcGxhY2VtZW50VmFsdWUgPT09IHR5cGVvZiB2YWx1ZSkge1xuXHRcdFx0XHR2YWx1ZSA9IHJlcGxhY2VtZW50VmFsdWU7XG5cdFx0XHRcdHJldHVybiB2YWx1ZTtcblx0XHRcdH1cblx0XHRcdGNvbnN0IGVycm9yID0gbmV3IFR5cGVFcnJvcihFcnJvcnNOYW1lcy5UWVBFX01JU01BVENIKTtcblx0XHRcdHRocm93IGVycm9yO1xuXHRcdH1cblx0fTtcbn07Il19 \ No newline at end of file diff --git a/lib/fields.js b/lib/fields.js index aed8908..a132419 100644 --- a/lib/fields.js +++ b/lib/fields.js @@ -1,30 +1,30 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.FieldConstructor = void 0; -const errors_js_1 = require('./errors.js'); +const errors_js_1 = require("./errors.js"); const SymbolInitialValue = Symbol('Initial Value'); // export const FieldConstructor = function (this: FieldDefinition, value: unknown) { // this[SymbolInitialValue] = value; // } as ObjectConstructor; class FieldConstructor { - [SymbolInitialValue]; - get get() { - const self = this; - return function ( /* this: FieldDefinition */) { - return self[SymbolInitialValue]; - }; - } - get set() { - return function () { - throw new TypeError(errors_js_1.ErrorsNames.FORBIDDEN_RE); - }; - } - constructor(value) { - this[SymbolInitialValue] = value; - } - static get SymbolInitialValue() { - return SymbolInitialValue; - } + [SymbolInitialValue]; + get get() { + const self = this; + return function ( /* this: FieldDefinition */) { + return self[SymbolInitialValue]; + }; + } + get set() { + return function () { + throw new TypeError(errors_js_1.ErrorsNames.FORBIDDEN_RE); + }; + } + constructor(value) { + this[SymbolInitialValue] = value; + } + static get SymbolInitialValue() { + return SymbolInitialValue; + } } exports.FieldConstructor = FieldConstructor; // Object.assign(FieldConstructor.prototype, { diff --git a/lib/index.d.ts b/lib/index.d.ts index 4a25d32..59b4356 100644 --- a/lib/index.d.ts +++ b/lib/index.d.ts @@ -16,3 +16,31 @@ export declare const SymbolInitialValue: symbol; declare const FieldConstructorExport: typeof FieldConstructor; export { FieldConstructorExport as FieldConstructor }; export declare const Strict: (_target?: object, options?: TypeomaticaOptions) => (cstr: T) => T; +/** + * Fields that certainly passed through the define machinery for this + * instance. Returns a copy of the internal Set — safe for the caller + * to mutate. + */ +export declare const getConstructedFields: (instance: object) => Set; +/** + * Auto finalization: every hiddenly-added own field of the instance + * (class fields and other define-semantics writes that bypassed the + * proxy) is deleted and re-established through the define machinery. + * Sets the finalized flag — `true` means auto mode ran. + */ +export declare const finalize: (instance: object) => void; +/** + * Partial finalization: re-establish only the listed fields. + * Does NOT set the finalized flag — that flag means auto mode ran, + * everything else is the user's choice. + */ +export declare const finalizeBy: (instance: object, fields: (string | symbol)[]) => void; +export declare const isFinalized: (instance: object) => boolean; +/** + * Turn a guarded field back into a plain value property. + * Allowed only for fields re-established by finalize/finalizeBy — + * they stay configurable by design. Fields guarded since construction + * are non-configurable: that lock is the essential design of the lib. + * Primitives are read back via .valueOf(); objects are placed as-is. + */ +export declare const unwrap: (instance: object, field: string | symbol) => void; diff --git a/lib/index.js b/lib/index.js index fa278ef..4e3386c 100644 --- a/lib/index.js +++ b/lib/index.js @@ -1,351 +1,483 @@ // oxlint-disable typescript/no-this-alias 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); -exports.Strict = exports.FieldConstructor = exports.SymbolInitialValue = exports.BaseClass = exports.BaseConstructorPrototype = exports.SymbolTypeomaticaProxyReference = exports.baseTarget = void 0; -const util_1 = require('util'); -const errors_js_1 = require('./errors.js'); -const index_js_1 = require('./types/index.js'); -const fields_js_1 = require('./fields.js'); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.unwrap = exports.isFinalized = exports.finalizeBy = exports.finalize = exports.getConstructedFields = exports.Strict = exports.FieldConstructor = exports.SymbolInitialValue = exports.BaseClass = exports.BaseConstructorPrototype = exports.SymbolTypeomaticaProxyReference = exports.baseTarget = void 0; +const util_1 = require("util"); +const errors_js_1 = require("./errors.js"); +const index_js_1 = require("./types/index.js"); +const fields_js_1 = require("./fields.js"); +// Fields that passed through the define machinery, per instance. +// The postConstruction comparator (Thunderstruck design) diffs the +// instance's own descriptors against this Set to find fields added +// hiddenly — class fields and other define-semantics writes. +const constructionRecords = new WeakMap(); +const ensureRecord = (instance) => { + let record = constructionRecords.get(instance); + if (!record) { + record = { + fields: new Set(), + options: undefined, + finalized: false + }; + constructionRecords.set(instance, record); + } + return record; +}; const createResolver = (options = {}) => { - const { strictAccessCheck = false } = options; - return Object.entries({ - primitives: index_js_1.primitives, - special: index_js_1.special, - nullish: index_js_1.nullish, - objects: index_js_1.objects, - functions: index_js_1.functions - }).reduce((obj, [key, _handler]) => { - // @ts-ignore - obj[key] = function (initialValue, receiver) { - const handler = _handler(initialValue); - return { - get() { - const invocationThis = this; - if (strictAccessCheck && invocationThis !== receiver) { - throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); - } - const result = handler.get(); - return result; - }, - set(replacementValue) { - const invocationThis = this; - if (strictAccessCheck && invocationThis !== receiver) { - throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); - } - const result = handler.set(replacementValue); - return result; - } - }; - }; - return obj; - }, {}); + const { strictAccessCheck = false } = options; + return Object.entries({ + primitives: index_js_1.primitives, + special: index_js_1.special, + nullish: index_js_1.nullish, + objects: index_js_1.objects, + functions: index_js_1.functions + }).reduce((obj, [key, _handler]) => { + // @ts-ignore + obj[key] = function (initialValue, receiver) { + const handler = _handler(initialValue); + return { + get() { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); + } + const result = handler.get(); + return result; + }, + set(replacementValue) { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); + } + const result = handler.set(replacementValue); + return result; + } + }; + }; + return obj; + }, {}); }; -const createProperty = (propName, initialValue, receiver, options) => { - const value = initialValue; - const valueIsPrimitive = (0, index_js_1.isPrimitive)(initialValue); - const isObject = typeof initialValue === 'object'; - const isFunction = initialValue instanceof Function; - const isNull = initialValue === null; - /** +const createProperty = (propName, initialValue, receiver, options, configurable = false) => { + const value = initialValue; + const valueIsPrimitive = (0, index_js_1.isPrimitive)(initialValue); + const isObject = typeof initialValue === 'object'; + const isFunction = initialValue instanceof Function; + const isNull = initialValue === null; + /** * special: undefined or BigInt or Symbol * or other non constructible type */ - const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special')); - const resolver = createResolver(options); - const descriptor = (isObject && (value instanceof fields_js_1.FieldConstructor)) ? - value : { - enumerable: true, - // @ts-ignore - ...resolver[types](value, receiver), - }; - // if (value instanceof FieldConstructor) { - // descriptor; - // debugger; - // } - const result = Reflect.defineProperty(receiver, propName, descriptor); - return result; + const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special')); + const resolver = createResolver(options); + const descriptor = (isObject && (value instanceof fields_js_1.FieldConstructor)) ? + value : { + enumerable: true, + configurable, + // @ts-ignore + ...resolver[types](value, receiver), + }; + // if (value instanceof FieldConstructor) { + // descriptor; + // debugger; + // } + const result = Reflect.defineProperty(receiver, propName, descriptor); + const record = ensureRecord(receiver); + record.fields.add(propName); + record.options = options; + return result; }; // line below 'href' is for util.inspect works, useful for v24 const props2skip = new Set([ - Symbol.toStringTag, - Symbol.iterator, - // Symbol.toPrimitive, - 'toString', - 'valueOf', - 'href' + Symbol.toStringTag, + Symbol.iterator, + // Symbol.toPrimitive, + 'toString', + 'valueOf', + 'href' ]); // const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]); const hasNodeInspect = (util_1.inspect && util_1.inspect.custom); // oxlint-disable-next-line no-unused-expressions (hasNodeInspect && (props2skip.add(util_1.inspect.custom))); const createHandlers = (options) => ({ - get(target, prop, receiver) { - const result = Reflect.get(target, prop, receiver); - if (result !== undefined) { - return result; - } - if (prop === 'toJSON') { - - return function () { - const entries = Object.entries(this); - return JSON.stringify(entries.reduce((obj, [key, value]) => { - // @ts-ignore - obj[key] = value.valueOf(); - return obj; - }, {})); - }; - } - if (prop === 'constructor') { - return undefined; - } - const { name } = receiver.constructor; - if (props2skip.has(prop)) { - const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; - return message; - } - // const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`; - // throw new Error(errorMessage); - }, - set(_, prop, value, receiver) { - const result = createProperty(prop, value, receiver, options); - return result; - }, - setPrototypeOf() { - throw new Error('Setting prototype is not allowed!'); - }, - // defineProperty(target: object, key: string, descriptor: object) { - defineProperty() { - throw new Error('Defining new Properties is not allowed!'); - // Reflect.defineProperty(target, key, descriptor); - }, - deleteProperty() { - throw new Error('Properties Deletion is not allowed!'); - }, - // getPrototypeOf() { - // debugger; - // throw new Error('Getting prototype is not allowed'); - // }, + get(target, prop, receiver) { + const result = Reflect.get(target, prop, receiver); + if (result !== undefined) { + return result; + } + if (prop === 'toJSON') { + // eslint-disable-next-line no-unused-vars + return function () { + const entries = Object.entries(this); + return JSON.stringify(entries.reduce((obj, [key, value]) => { + // @ts-ignore + obj[key] = value.valueOf(); + return obj; + }, {})); + }; + } + if (prop === 'constructor') { + return undefined; + } + const { name } = receiver.constructor; + if (props2skip.has(prop)) { + const message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`; + return message; + } + // const errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`; + // throw new Error(errorMessage); + }, + set(_, prop, value, receiver) { + const result = createProperty(prop, value, receiver, options); + return result; + }, + setPrototypeOf() { + throw new Error('Setting prototype is not allowed!'); + }, + // defineProperty(target: object, key: string, descriptor: object) { + defineProperty() { + throw new Error('Defining new Properties is not allowed!'); + // Reflect.defineProperty(target, key, descriptor); + }, + deleteProperty() { + throw new Error('Properties Deletion is not allowed!'); + }, + // getPrototypeOf() { + // debugger; + // throw new Error('Getting prototype is not allowed'); + // }, }); // user have to precisely define all props const baseTarget = (_proto) => { - const proto = typeof _proto === 'object' ? _proto : null; - const answer = Object.create(proto); - return answer; + const proto = typeof _proto === 'object' ? _proto : null; + const answer = Object.create(proto); + return answer; }; exports.baseTarget = baseTarget; exports.SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference'); const getTypeomaticaProxyReference = (_target, options) => { - const target = Object.create(_target); - const id = `TypeØmaticaProxyReference-${Math.random()}`; - Object.defineProperty(target, exports.SymbolTypeomaticaProxyReference, { - get() { - return id; - } - }); - const handlers = createHandlers(options); - const proxy = new Proxy(target, handlers); - return proxy; + const target = Object.create(_target); + const id = `TypeØmaticaProxyReference-${Math.random()}`; + Object.defineProperty(target, exports.SymbolTypeomaticaProxyReference, { + get() { + return id; + } + }); + const handlers = createHandlers(options); + const proxy = new Proxy(target, handlers); + return proxy; }; exports.BaseConstructorPrototype = function (_target, options) { - if (!new.target) { - const self = exports.BaseConstructorPrototype.bind(this, _target, options); - self.prototype = { - constructor: exports.BaseConstructorPrototype - }; - // @ts-ignore - return self; - } - // @ts-ignore - if (this[exports.SymbolTypeomaticaProxyReference]) { - // @ts-ignore - 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; - let constructors = false; - // @ts-ignore - // const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean; - // if (hasProxyReference) { - // throw new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!'); - // } - do { - proto = protoPointer; - protoPointer = Object.getPrototypeOf(proto); - if (exports.BaseConstructorPrototype.prototype === protoPointer) { - constructors = true; - break; - } - if (!protoPointer) - break; - const descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor'); - if (!descriptor) - continue; - const value = descriptor.value || descriptor.get; - // if (!value) continue; - protoConstrcutor = value; - } while (protoConstrcutor !== exports.BaseConstructorPrototype); - if (!constructors && protoConstrcutor !== exports.BaseConstructorPrototype) { - throw new Error('Unable to setup TypeØmatica handler!'); - } - Object.setPrototypeOf(proto, InstancePrototype); - if (freezeProtos) { - Object.freeze(classPrototype); - } - // @ts-ignore - return this; - + if (!new.target) { + const self = exports.BaseConstructorPrototype.bind(this, _target, options); + self.prototype = { + constructor: exports.BaseConstructorPrototype + }; + // @ts-ignore + return self; + } + // @ts-ignore + if (this[exports.SymbolTypeomaticaProxyReference]) { + // @ts-ignore + 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; + let constructors = false; + // @ts-ignore + // const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean; + // if (hasProxyReference) { + // throw new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!'); + // } + do { + proto = protoPointer; + protoPointer = Object.getPrototypeOf(proto); + if (exports.BaseConstructorPrototype.prototype === protoPointer) { + constructors = true; + break; + } + if (!protoPointer) + break; + const descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor'); + if (!descriptor) + continue; + const value = descriptor.value || descriptor.get; + // if (!value) continue; + protoConstrcutor = value; + } while (protoConstrcutor !== exports.BaseConstructorPrototype); + if (!constructors && protoConstrcutor !== exports.BaseConstructorPrototype) { + throw new Error('Unable to setup TypeØmatica handler!'); + } + Object.setPrototypeOf(proto, InstancePrototype); + if (freezeProtos) { + Object.freeze(classPrototype); + } + // @ts-ignore + return this; + /* eslint-disable no-unused-vars */ }; - +/* eslint-enable no-unused-vars */ 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); + 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); - 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); - } + 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); + 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]) { - return cstr; - } - const target = (0, exports.baseTarget)(_target); - const proxy = getTypeomaticaProxyReference(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) { - // debugger; - // const target = baseTarget(_target); - // const proxy = getTypeomaticaProxyReference(target); - // const _replacer = Object.create(proxy); - // const _proto = cstr.prototype; - // const proto = Object.create(Object.getPrototypeOf(_proto)); - // proto.iAmProto = true; - // Object.setPrototypeOf(cstr.prototype, proto); - // const descriptors = Object.getOwnPropertyDescriptors(_proto); - // Object.defineProperties(proto, descriptors); - // const replacer = Object.create(_replacer); - // Object.setPrototypeOf(proto, replacer); - // Object.setPrototypeOf(cstr.prototype, proto); - // const result = Reflect.construct(cstr, argumentsList, newTarget); - // debugger; - // Object.setPrototypeOf(cstr.prototype, _proto); - // debugger; - // return result; - // }, - // }); - // return MyClassProxy; - }; - return decorator; + const { frozenPrototypes: freezeProtos = true } = options || {}; + const decorator = function (cstr) { + // @ts-ignore + if (cstr.prototype[exports.SymbolTypeomaticaProxyReference]) { + return cstr; + } + const target = (0, exports.baseTarget)(_target); + const proxy = getTypeomaticaProxyReference(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) { + // debugger; + // const target = baseTarget(_target); + // const proxy = getTypeomaticaProxyReference(target); + // const _replacer = Object.create(proxy); + // const _proto = cstr.prototype; + // const proto = Object.create(Object.getPrototypeOf(_proto)); + // proto.iAmProto = true; + // Object.setPrototypeOf(cstr.prototype, proto); + // const descriptors = Object.getOwnPropertyDescriptors(_proto); + // Object.defineProperties(proto, descriptors); + // const replacer = Object.create(_replacer); + // Object.setPrototypeOf(proto, replacer); + // Object.setPrototypeOf(cstr.prototype, proto); + // const result = Reflect.construct(cstr, argumentsList, newTarget); + // debugger; + // Object.setPrototypeOf(cstr.prototype, _proto); + // debugger; + // return result; + // }, + // }); + // return MyClassProxy; + }; + return decorator; }; exports.SymbolInitialValue = fields_js_1.FieldConstructor.SymbolInitialValue; const FieldConstructorExport = fields_js_1.FieldConstructor; exports.FieldConstructor = FieldConstructorExport; exports.Strict = strict; +/** + * Fields that certainly passed through the define machinery for this + * instance. Returns a copy of the internal Set — safe for the caller + * to mutate. + */ +const getConstructedFields = (instance) => { + const record = constructionRecords.get(instance); + const result = record ? new Set(record.fields) : new Set(); + return result; +}; +exports.getConstructedFields = getConstructedFields; +const finaliseFields = (instance, names) => { + const record = ensureRecord(instance); + names.forEach((name) => { + if (record.fields.has(name)) { + // already passed through the machinery + return; + } + const descriptor = Reflect.getOwnPropertyDescriptor(instance, name); + if (!descriptor || !('value' in descriptor)) { + // nothing hidden under that name, or not a data field + return; + } + delete instance[name]; + // finalized fields stay configurable: they are the ones `unwrap` + // is allowed to turn back into plain value properties + createProperty(name, descriptor.value, instance, record.options, true); + }); +}; +/** + * Auto finalization: every hiddenly-added own field of the instance + * (class fields and other define-semantics writes that bypassed the + * proxy) is deleted and re-established through the define machinery. + * Sets the finalized flag — `true` means auto mode ran. + */ +const finalize = (instance) => { + const record = ensureRecord(instance); + finaliseFields(instance, Reflect.ownKeys(instance)); + record.finalized = true; +}; +exports.finalize = finalize; +/** + * Partial finalization: re-establish only the listed fields. + * Does NOT set the finalized flag — that flag means auto mode ran, + * everything else is the user's choice. + */ +const finalizeBy = (instance, fields) => { + finaliseFields(instance, fields); +}; +exports.finalizeBy = finalizeBy; +const isFinalized = (instance) => { + const record = constructionRecords.get(instance); + const result = record ? record.finalized : false; + return result; +}; +exports.isFinalized = isFinalized; +/** + * Turn a guarded field back into a plain value property. + * Allowed only for fields re-established by finalize/finalizeBy — + * they stay configurable by design. Fields guarded since construction + * are non-configurable: that lock is the essential design of the lib. + * Primitives are read back via .valueOf(); objects are placed as-is. + */ +const unwrap = (instance, field) => { + const descriptor = Reflect.getOwnPropertyDescriptor(instance, field); + if (!descriptor || !descriptor.configurable || typeof descriptor.get !== 'function') { + throw new TypeError(errors_js_1.ErrorsNames.FORBIDDEN_UNWRAP); + } + const current = instance[field]; + const currentValueOf = current?.valueOf; + const unwrapped = typeof currentValueOf === 'function' + ? current.valueOf() + : current; + Object.defineProperty(instance, field, { + value: unwrapped, + writable: true, + enumerable: true, + configurable: true + }); +}; +exports.unwrap = unwrap; /* istanbul ignore next */ function setupCommonJS() { - if (typeof module === 'undefined' || typeof module.exports === 'undefined') { - return; - } - Object.defineProperty(module, 'exports', { - get() { - return exports.BaseConstructorPrototype; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'BaseClass', { - get() { - return BaseClass; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'FieldConstructor', { - get() { - return fields_js_1.FieldConstructor; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'SymbolInitialValue', { - get() { - return exports.SymbolInitialValue; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', { - get() { - return exports.SymbolTypeomaticaProxyReference; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'baseTarget', { - get() { - return exports.baseTarget; - }, - enumerable: true - }); - Object.defineProperty(module.exports, 'Strict', { - get() { - return strict; - }, - enumerable: true - }); + if (typeof module === 'undefined' || typeof module.exports === 'undefined') { + return; + } + Object.defineProperty(module, 'exports', { + get() { + return exports.BaseConstructorPrototype; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'BaseClass', { + get() { + return BaseClass; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'FieldConstructor', { + get() { + return fields_js_1.FieldConstructor; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'SymbolInitialValue', { + get() { + return exports.SymbolInitialValue; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', { + get() { + return exports.SymbolTypeomaticaProxyReference; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'baseTarget', { + get() { + return exports.baseTarget; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'Strict', { + get() { + return strict; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'getConstructedFields', { + get() { + return exports.getConstructedFields; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalize', { + get() { + return exports.finalize; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalizeBy', { + get() { + return exports.finalizeBy; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'isFinalized', { + get() { + return exports.isFinalized; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'unwrap', { + get() { + return exports.unwrap; + }, + enumerable: true + }); } 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":"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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 +//# 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\ninterface ConstructionRecord {\n\tfields    : Set<string | symbol>;\n\toptions   : TypeomaticaOptions | undefined;\n\tfinalized : boolean;\n}\n\n// Fields that passed through the define machinery, per instance.\n// The postConstruction comparator (Thunderstruck design) diffs the\n// instance's own descriptors against this Set to find fields added\n// hiddenly — class fields and other define-semantics writes.\nconst constructionRecords = new WeakMap<object, ConstructionRecord>();\n\nconst ensureRecord = (instance: object): ConstructionRecord => {\n\tlet record = constructionRecords.get(instance);\n\tif (!record) {\n\t\trecord = {\n\t\t\tfields    : new Set(),\n\t\t\toptions   : undefined,\n\t\t\tfinalized : false\n\t\t};\n\t\tconstructionRecords.set(instance, record);\n\t}\n\treturn record;\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 | symbol, initialValue: unknown, receiver: object, options?: TypeomaticaOptions, configurable = false) => {\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\tconfigurable,\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\n\tconst record = ensureRecord(receiver);\n\trecord.fields.add(propName);\n\trecord.options = options;\n\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/**\n * Fields that certainly passed through the define machinery for this\n * instance. Returns a copy of the internal Set — safe for the caller\n * to mutate.\n */\nexport const getConstructedFields = (instance: object): Set<string | symbol> => {\n\tconst record = constructionRecords.get(instance);\n\tconst result = record ? new Set(record.fields) : new Set<string | symbol>();\n\treturn result;\n};\n\nconst finaliseFields = (instance: object, names: (string | symbol)[]): void => {\n\tconst record = ensureRecord(instance);\n\tnames.forEach((name) => {\n\t\tif (record.fields.has(name)) {\n\t\t\t// already passed through the machinery\n\t\t\treturn;\n\t\t}\n\t\tconst descriptor = Reflect.getOwnPropertyDescriptor(instance, name);\n\t\tif (!descriptor || !('value' in descriptor)) {\n\t\t\t// nothing hidden under that name, or not a data field\n\t\t\treturn;\n\t\t}\n\t\tdelete (instance as Record<PropertyKey, unknown>)[name];\n\t\t// finalized fields stay configurable: they are the ones `unwrap`\n\t\t// is allowed to turn back into plain value properties\n\t\tcreateProperty(name, descriptor.value, instance, record.options, true);\n\t});\n};\n\n/**\n * Auto finalization: every hiddenly-added own field of the instance\n * (class fields and other define-semantics writes that bypassed the\n * proxy) is deleted and re-established through the define machinery.\n * Sets the finalized flag — `true` means auto mode ran.\n */\nexport const finalize = (instance: object): void => {\n\tconst record = ensureRecord(instance);\n\tfinaliseFields(instance, Reflect.ownKeys(instance));\n\trecord.finalized = true;\n};\n\n/**\n * Partial finalization: re-establish only the listed fields.\n * Does NOT set the finalized flag — that flag means auto mode ran,\n * everything else is the user's choice.\n */\nexport const finalizeBy = (instance: object, fields: (string | symbol)[]): void => {\n\tfinaliseFields(instance, fields);\n};\n\nexport const isFinalized = (instance: object): boolean => {\n\tconst record = constructionRecords.get(instance);\n\tconst result = record ? record.finalized : false;\n\treturn result;\n};\n\n/**\n * Turn a guarded field back into a plain value property.\n * Allowed only for fields re-established by finalize/finalizeBy —\n * they stay configurable by design. Fields guarded since construction\n * are non-configurable: that lock is the essential design of the lib.\n * Primitives are read back via .valueOf(); objects are placed as-is.\n */\nexport const unwrap = (instance: object, field: string | symbol): void => {\n\tconst descriptor = Reflect.getOwnPropertyDescriptor(instance, field);\n\tif (!descriptor || !descriptor.configurable || typeof descriptor.get !== 'function') {\n\t\tthrow new TypeError(ErrorsNames.FORBIDDEN_UNWRAP);\n\t}\n\tconst current = (instance as Record<PropertyKey, unknown>)[field];\n\tconst currentValueOf = (current as { valueOf?: unknown })?.valueOf;\n\tconst unwrapped = typeof currentValueOf === 'function'\n\t\t? (current as { valueOf: () => unknown }).valueOf()\n\t\t: current;\n\tObject.defineProperty(instance, field, {\n\t\tvalue        : unwrapped,\n\t\twritable     : true,\n\t\tenumerable   : true,\n\t\tconfigurable : true\n\t});\n};\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\tObject.defineProperty(module.exports, 'getConstructedFields', {\n\t\tget() {\n\t\t\treturn getConstructedFields;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'finalize', {\n\t\tget() {\n\t\t\treturn finalize;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'finalizeBy', {\n\t\tget() {\n\t\t\treturn finalizeBy;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'isFinalized', {\n\t\tget() {\n\t\t\treturn isFinalized;\n\t\t},\n\t\tenumerable: true\n\t});\n\tObject.defineProperty(module.exports, 'unwrap', {\n\t\tget() {\n\t\t\treturn unwrap;\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/types/functions.js b/lib/types/functions.js index 2a8998b..6c06696 100644 --- a/lib/types/functions.js +++ b/lib/types/functions.js @@ -1,9 +1,9 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.functions = void 0; -const errors_js_1 = require('../errors.js'); +const errors_js_1 = require("../errors.js"); const functions = () => { - throw new TypeError(errors_js_1.ErrorsNames.RIP_FUNCTIONS); + throw new TypeError(errors_js_1.ErrorsNames.RIP_FUNCTIONS); }; exports.functions = functions; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUViLDRDQUEyQztBQUVwQyxNQUFNLFNBQVMsR0FBRyxHQUFHLEVBQUU7SUFDN0IsTUFBTSxJQUFJLFNBQVMsQ0FBQyx1QkFBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0FBQ2hELENBQUMsQ0FBQztBQUZXLFFBQUEsU0FBUyxhQUVwQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgRXJyb3JzTmFtZXMgfSBmcm9tICcuLi9lcnJvcnMuanMnO1xuXG5leHBvcnQgY29uc3QgZnVuY3Rpb25zID0gKCkgPT4ge1xuXHR0aHJvdyBuZXcgVHlwZUVycm9yKEVycm9yc05hbWVzLlJJUF9GVU5DVElPTlMpO1xufTsiXX0= \ No newline at end of file diff --git a/lib/types/index.js b/lib/types/index.js index 0340b49..fcbc94c 100644 --- a/lib/types/index.js +++ b/lib/types/index.js @@ -1,23 +1,23 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.isPrimitive = exports.special = exports.primitives = exports.objects = exports.nullish = exports.functions = void 0; -var functions_js_1 = require('./functions.js'); -Object.defineProperty(exports, 'functions', { enumerable: true, get: function () { return functions_js_1.functions; } }); -var nullish_js_1 = require('./nullish.js'); -Object.defineProperty(exports, 'nullish', { enumerable: true, get: function () { return nullish_js_1.nullish; } }); -var objects_js_1 = require('./objects.js'); -Object.defineProperty(exports, 'objects', { enumerable: true, get: function () { return objects_js_1.objects; } }); -var primitives_js_1 = require('./primitives.js'); -Object.defineProperty(exports, 'primitives', { enumerable: true, get: function () { return primitives_js_1.primitives; } }); -var special_js_1 = require('./special.js'); -Object.defineProperty(exports, 'special', { enumerable: true, get: function () { return special_js_1.special; } }); +var functions_js_1 = require("./functions.js"); +Object.defineProperty(exports, "functions", { enumerable: true, get: function () { return functions_js_1.functions; } }); +var nullish_js_1 = require("./nullish.js"); +Object.defineProperty(exports, "nullish", { enumerable: true, get: function () { return nullish_js_1.nullish; } }); +var objects_js_1 = require("./objects.js"); +Object.defineProperty(exports, "objects", { enumerable: true, get: function () { return objects_js_1.objects; } }); +var primitives_js_1 = require("./primitives.js"); +Object.defineProperty(exports, "primitives", { enumerable: true, get: function () { return primitives_js_1.primitives; } }); +var special_js_1 = require("./special.js"); +Object.defineProperty(exports, "special", { enumerable: true, get: function () { return special_js_1.special; } }); const PRIMITIVE_TYPES = [ - 'string', - 'number', - 'boolean', + 'string', + 'number', + 'boolean', ]; const isPrimitive = (value) => { - return PRIMITIVE_TYPES.includes(typeof value); + return PRIMITIVE_TYPES.includes(typeof value); }; exports.isPrimitive = isPrimitive; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYiwrQ0FBMkM7QUFBbEMseUdBQUEsU0FBUyxPQUFBO0FBQ2xCLDJDQUF1QztBQUE5QixxR0FBQSxPQUFPLE9BQUE7QUFDaEIsMkNBQXVDO0FBQTlCLHFHQUFBLE9BQU8sT0FBQTtBQUNoQixpREFBNkM7QUFBcEMsMkdBQUEsVUFBVSxPQUFBO0FBQ25CLDJDQUF1QztBQUE5QixxR0FBQSxPQUFPLE9BQUE7QUFFaEIsTUFBTSxlQUFlLEdBQUc7SUFDdkIsUUFBUTtJQUNSLFFBQVE7SUFDUixTQUFTO0NBQ1QsQ0FBQztBQUVLLE1BQU0sV0FBVyxHQUFHLENBQUMsS0FBYyxFQUFFLEVBQUU7SUFDN0MsT0FBTyxlQUFlLENBQUMsUUFBUSxDQUFDLE9BQU8sS0FBSyxDQUFDLENBQUM7QUFDL0MsQ0FBQyxDQUFDO0FBRlcsUUFBQSxXQUFXLGVBRXRCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5leHBvcnQgeyBmdW5jdGlvbnMgfSBmcm9tICcuL2Z1bmN0aW9ucy5qcyc7XG5leHBvcnQgeyBudWxsaXNoIH0gZnJvbSAnLi9udWxsaXNoLmpzJztcbmV4cG9ydCB7IG9iamVjdHMgfSBmcm9tICcuL29iamVjdHMuanMnO1xuZXhwb3J0IHsgcHJpbWl0aXZlcyB9IGZyb20gJy4vcHJpbWl0aXZlcy5qcyc7XG5leHBvcnQgeyBzcGVjaWFsIH0gZnJvbSAnLi9zcGVjaWFsLmpzJztcblxuY29uc3QgUFJJTUlUSVZFX1RZUEVTID0gW1xuXHQnc3RyaW5nJyxcblx0J251bWJlcicsXG5cdCdib29sZWFuJyxcbl07XG5cbmV4cG9ydCBjb25zdCBpc1ByaW1pdGl2ZSA9ICh2YWx1ZTogdW5rbm93bikgPT4ge1xuXHRyZXR1cm4gUFJJTUlUSVZFX1RZUEVTLmluY2x1ZGVzKHR5cGVvZiB2YWx1ZSk7XG59O1xuIl19 \ No newline at end of file diff --git a/lib/types/nullish.js b/lib/types/nullish.js index 3ab78f7..5111fb3 100644 --- a/lib/types/nullish.js +++ b/lib/types/nullish.js @@ -1,17 +1,17 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.nullish = void 0; -const errors_js_1 = require('../errors.js'); +const errors_js_1 = require("../errors.js"); const nullish = (value) => { - return { - get() { - return value; - }, - set() { - const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set() { + const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; exports.nullish = nullish; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9udWxsaXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsNENBQTJDO0FBRXBDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHO1lBQ0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsdUJBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUN2RCxNQUFNLEtBQUssQ0FBQztRQUNiLENBQUM7S0FDRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBVlcsUUFBQSxPQUFPLFdBVWxCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycy5qcyc7XG5cbmV4cG9ydCBjb25zdCBudWxsaXNoID0gKHZhbHVlOiBvYmplY3QpID0+IHtcblx0cmV0dXJuIHtcblx0XHRnZXQoKSB7XG5cdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0fSxcblx0XHRzZXQoKSB7XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/lib/types/objects.js b/lib/types/objects.js index f9bc639..54c1dc8 100644 --- a/lib/types/objects.js +++ b/lib/types/objects.js @@ -1,21 +1,21 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.objects = void 0; -const errors_js_1 = require('../errors.js'); +const errors_js_1 = require("../errors.js"); const objects = (value) => { - return { - get() { - return value; - }, - set(replacementValue) { - if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) { - value = replacementValue; - return value; - } - const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set(replacementValue) { + if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) { + value = replacementValue; + return value; + } + const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; exports.objects = objects; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9vYmplY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsNENBQTJDO0FBRXBDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXlCO1lBQzVCLElBQUksZ0JBQWdCLFlBQVksTUFBTSxJQUFJLGdCQUFnQixDQUFDLFdBQVcsS0FBSyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUM7Z0JBQzlGLEtBQUssR0FBRyxnQkFBZ0IsQ0FBQztnQkFDekIsT0FBTyxLQUFLLENBQUM7WUFDZCxDQUFDO1lBQ0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsdUJBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUN2RCxNQUFNLEtBQUssQ0FBQztRQUNiLENBQUM7S0FDRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBZFcsUUFBQSxPQUFPLFdBY2xCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycy5qcyc7XG5cbmV4cG9ydCBjb25zdCBvYmplY3RzID0gKHZhbHVlOiBvYmplY3QpID0+IHtcblx0cmV0dXJuIHtcblx0XHRnZXQoKSB7XG5cdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0fSxcblx0XHRzZXQocmVwbGFjZW1lbnRWYWx1ZTogdW5rbm93bikge1xuXHRcdFx0aWYgKHJlcGxhY2VtZW50VmFsdWUgaW5zdGFuY2VvZiBPYmplY3QgJiYgcmVwbGFjZW1lbnRWYWx1ZS5jb25zdHJ1Y3RvciA9PT0gdmFsdWUuY29uc3RydWN0b3IpIHtcblx0XHRcdFx0dmFsdWUgPSByZXBsYWNlbWVudFZhbHVlO1xuXHRcdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0XHR9XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/lib/types/primitives.js b/lib/types/primitives.js index 45aee7c..2e05bfc 100644 --- a/lib/types/primitives.js +++ b/lib/types/primitives.js @@ -1,64 +1,64 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.primitives = void 0; -const errors_js_1 = require('../errors.js'); +const errors_js_1 = require("../errors.js"); const primitives = (initialValue) => { - let value = Object(initialValue); - const initialType = typeof initialValue; - return { - get() { - const proxyAsValue = new Proxy(value, { - // get(target, prop, receiver) { - get(_, prop) { - if (prop === Symbol.toPrimitive) { - return function (hint) { - if (hint !== initialType) { - throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); - } - return value.valueOf(); - }; - } - if (prop === 'valueOf') { - return function () { - return value.valueOf(); - }; - } - // @ts-ignore - if (value[prop] instanceof Function) { - return value[prop].bind(value); - } - const answer = value[prop]; - return answer; - } - }); - return proxyAsValue; - }, - // get() { - // const preparedValue = { - // [Symbol.toPrimitive]() { - // return function () { - // throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - // }; - // } - // }; - // Reflect.setPrototypeOf(preparedValue, value); - // debugger; - // return preparedValue; - // }, - set(replacementValue) { - if (replacementValue instanceof value.constructor) { - value = replacementValue; - return value; - } - const prevalue = Object(replacementValue); - if (prevalue instanceof value.constructor) { - value = prevalue; - return value; - } - const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + let value = Object(initialValue); + const initialType = typeof initialValue; + return { + get() { + const proxyAsValue = new Proxy(value, { + // get(target, prop, receiver) { + get(_, prop) { + if (prop === Symbol.toPrimitive) { + return function (hint) { + if (hint !== initialType) { + throw new ReferenceError(errors_js_1.ErrorsNames.ACCESS_DENIED); + } + return value.valueOf(); + }; + } + if (prop === 'valueOf') { + return function () { + return value.valueOf(); + }; + } + // @ts-ignore + if (value[prop] instanceof Function) { + return value[prop].bind(value); + } + const answer = value[prop]; + return answer; + } + }); + return proxyAsValue; + }, + // get() { + // const preparedValue = { + // [Symbol.toPrimitive]() { + // return function () { + // throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + // }; + // } + // }; + // Reflect.setPrototypeOf(preparedValue, value); + // debugger; + // return preparedValue; + // }, + set(replacementValue) { + if (replacementValue instanceof value.constructor) { + value = replacementValue; + return value; + } + const prevalue = Object(replacementValue); + if (prevalue instanceof value.constructor) { + value = prevalue; + return value; + } + const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; exports.primitives = primitives; //# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/types/special.js b/lib/types/special.js index 7541a57..4185ad0 100644 --- a/lib/types/special.js +++ b/lib/types/special.js @@ -1,21 +1,21 @@ 'use strict'; -Object.defineProperty(exports, '__esModule', { value: true }); +Object.defineProperty(exports, "__esModule", { value: true }); exports.special = void 0; -const errors_js_1 = require('../errors.js'); +const errors_js_1 = require("../errors.js"); const special = (value) => { - return { - get() { - return value; - }, - set(replacementValue) { - if (typeof replacementValue === typeof value) { - value = replacementValue; - return value; - } - const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); - throw error; - } - }; + return { + get() { + return value; + }, + set(replacementValue) { + if (typeof replacementValue === typeof value) { + value = replacementValue; + return value; + } + const error = new TypeError(errors_js_1.ErrorsNames.TYPE_MISMATCH); + throw error; + } + }; }; exports.special = special; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlY2lhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9zcGVjaWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsNENBQTJDO0FBRXBDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXdCO1lBQzNCLElBQUksT0FBTyxnQkFBZ0IsS0FBSyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUM5QyxLQUFLLEdBQUcsZ0JBQWdCLENBQUM7Z0JBQ3pCLE9BQU8sS0FBSyxDQUFDO1lBQ2QsQ0FBQztZQUNELE1BQU0sS0FBSyxHQUFHLElBQUksU0FBUyxDQUFDLHVCQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDdkQsTUFBTSxLQUFLLENBQUM7UUFDYixDQUFDO0tBQ0QsQ0FBQztBQUNILENBQUMsQ0FBQztBQWRXLFFBQUEsT0FBTyxXQWNsQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgRXJyb3JzTmFtZXMgfSBmcm9tICcuLi9lcnJvcnMuanMnO1xuXG5leHBvcnQgY29uc3Qgc3BlY2lhbCA9ICh2YWx1ZTogb2JqZWN0KSA9PiB7XG5cdHJldHVybiB7XG5cdFx0Z2V0KCkge1xuXHRcdFx0cmV0dXJuIHZhbHVlO1xuXHRcdH0sXG5cdFx0c2V0KHJlcGxhY2VtZW50VmFsdWU6IG9iamVjdCkge1xuXHRcdFx0aWYgKHR5cGVvZiByZXBsYWNlbWVudFZhbHVlID09PSB0eXBlb2YgdmFsdWUpIHtcblx0XHRcdFx0dmFsdWUgPSByZXBsYWNlbWVudFZhbHVlO1xuXHRcdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0XHR9XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 3136adb..0d08a63 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "typeomatica", - "version": "0.3.59", + "version": "0.3.60", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "typeomatica", - "version": "0.3.59", + "version": "0.3.60", "license": "MIT", "devDependencies": { "@eslint/eslintrc": "^3.3.5", @@ -850,9 +850,9 @@ } }, "node_modules/@istanbuljs/load-nyc-config/node_modules/js-yaml": { - "version": "3.14.2", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz", - "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==", + "version": "3.15.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.15.1.tgz", + "integrity": "sha512-S99WuO3HlhO3XN41EtYUNl9zzXjoJx7QvmipxsJVxtCBT0YHEFy+iOJhjSvrmV12nYhWpZaM8lPHkJm0yUMbag==", "dev": true, "license": "MIT", "dependencies": { @@ -2060,16 +2060,16 @@ } }, "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz", - "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==", + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz", + "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==", "dev": true, "license": "MIT", "dependencies": { "balanced-match": "^4.0.2" }, "engines": { - "node": "18 || 20 || >=22" + "node": "20 || >=22" } }, "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { @@ -2825,9 +2825,9 @@ } }, "node_modules/brace-expansion": { - "version": "1.1.15", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz", - "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==", + "version": "1.1.18", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz", + "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==", "dev": true, "license": "MIT", "dependencies": { @@ -3890,9 +3890,9 @@ } }, "node_modules/glob/node_modules/brace-expansion": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz", - "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==", + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz", + "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==", "dev": true, "license": "MIT", "dependencies": { @@ -4860,9 +4860,9 @@ "license": "MIT" }, "node_modules/js-yaml": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz", - "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.1.tgz", + "integrity": "sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==", "dev": true, "funding": [ { @@ -5599,9 +5599,9 @@ "license": "MIT" }, "node_modules/nanoid": { - "version": "3.3.15", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz", - "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==", + "version": "3.3.18", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz", + "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==", "dev": true, "funding": [ { @@ -5987,9 +5987,9 @@ } }, "node_modules/postcss": { - "version": "8.5.15", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz", - "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==", + "version": "8.5.26", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz", + "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==", "dev": true, "funding": [ { @@ -6007,7 +6007,7 @@ ], "license": "MIT", "dependencies": { - "nanoid": "^3.3.12", + "nanoid": "^3.3.17", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" }, diff --git a/package.json b/package.json index f872add..e5db072 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "typeomatica", - "version": "0.3.59", + "version": "0.3.60", "description": "type logic against javascript metaprogramming", "engines": { "node": ">=16" diff --git a/src/errors.ts b/src/errors.ts index 54f8084..7a67906 100644 --- a/src/errors.ts +++ b/src/errors.ts @@ -5,5 +5,6 @@ export const ErrorsNames = { ACCESS_DENIED: 'Value Access Denied', RIP_FUNCTIONS: 'Functions are Restricted', FORBIDDEN_RE: 'Re-Assirnment is Forbidden', + FORBIDDEN_UNWRAP: 'Unwrap is allowed only for finalized fields', // MISSING_PROP: 'Attempt to Access to Undefined Prop', }; diff --git a/src/index.ts b/src/index.ts index 4411b55..fdb50c4 100644 --- a/src/index.ts +++ b/src/index.ts @@ -21,6 +21,31 @@ export interface TypeomaticaOptions { frozenPrototypes?: boolean; } +interface ConstructionRecord { + fields : Set; + options : TypeomaticaOptions | undefined; + finalized : boolean; +} + +// Fields that passed through the define machinery, per instance. +// The postConstruction comparator (Thunderstruck design) diffs the +// instance's own descriptors against this Set to find fields added +// hiddenly — class fields and other define-semantics writes. +const constructionRecords = new WeakMap(); + +const ensureRecord = (instance: object): ConstructionRecord => { + let record = constructionRecords.get(instance); + if (!record) { + record = { + fields : new Set(), + options : undefined, + finalized : false + }; + constructionRecords.set(instance, record); + } + return record; +}; + const createResolver = (options: TypeomaticaOptions = {}) => { const { strictAccessCheck = false } = options; @@ -58,7 +83,7 @@ const createResolver = (options: TypeomaticaOptions = {}) => { }, {}); }; -const createProperty = (propName: string, initialValue: unknown, receiver: object, options?: TypeomaticaOptions) => { +const createProperty = (propName: string | symbol, initialValue: unknown, receiver: object, options?: TypeomaticaOptions, configurable = false) => { const value = initialValue; const valueIsPrimitive = isPrimitive(initialValue); @@ -84,6 +109,7 @@ const createProperty = (propName: string, initialValue: unknown, receiver: objec const descriptor = (isObject && (value instanceof FieldConstructor)) ? value : { enumerable: true, + configurable, // @ts-ignore ...resolver[types](value, receiver), }; @@ -94,6 +120,11 @@ const createProperty = (propName: string, initialValue: unknown, receiver: objec // } const result = Reflect.defineProperty(receiver, propName, descriptor); + + const record = ensureRecord(receiver); + record.fields.add(propName); + record.options = options; + return result; }; @@ -384,6 +415,88 @@ const FieldConstructorExport = FieldConstructor; export { FieldConstructorExport as FieldConstructor }; export const Strict = strict; +/** + * Fields that certainly passed through the define machinery for this + * instance. Returns a copy of the internal Set — safe for the caller + * to mutate. + */ +export const getConstructedFields = (instance: object): Set => { + const record = constructionRecords.get(instance); + const result = record ? new Set(record.fields) : new Set(); + return result; +}; + +const finaliseFields = (instance: object, names: (string | symbol)[]): void => { + const record = ensureRecord(instance); + names.forEach((name) => { + if (record.fields.has(name)) { + // already passed through the machinery + return; + } + const descriptor = Reflect.getOwnPropertyDescriptor(instance, name); + if (!descriptor || !('value' in descriptor)) { + // nothing hidden under that name, or not a data field + return; + } + delete (instance as Record)[name]; + // finalized fields stay configurable: they are the ones `unwrap` + // is allowed to turn back into plain value properties + createProperty(name, descriptor.value, instance, record.options, true); + }); +}; + +/** + * Auto finalization: every hiddenly-added own field of the instance + * (class fields and other define-semantics writes that bypassed the + * proxy) is deleted and re-established through the define machinery. + * Sets the finalized flag — `true` means auto mode ran. + */ +export const finalize = (instance: object): void => { + const record = ensureRecord(instance); + finaliseFields(instance, Reflect.ownKeys(instance)); + record.finalized = true; +}; + +/** + * Partial finalization: re-establish only the listed fields. + * Does NOT set the finalized flag — that flag means auto mode ran, + * everything else is the user's choice. + */ +export const finalizeBy = (instance: object, fields: (string | symbol)[]): void => { + finaliseFields(instance, fields); +}; + +export const isFinalized = (instance: object): boolean => { + const record = constructionRecords.get(instance); + const result = record ? record.finalized : false; + return result; +}; + +/** + * Turn a guarded field back into a plain value property. + * Allowed only for fields re-established by finalize/finalizeBy — + * they stay configurable by design. Fields guarded since construction + * are non-configurable: that lock is the essential design of the lib. + * Primitives are read back via .valueOf(); objects are placed as-is. + */ +export const unwrap = (instance: object, field: string | symbol): void => { + const descriptor = Reflect.getOwnPropertyDescriptor(instance, field); + if (!descriptor || !descriptor.configurable || typeof descriptor.get !== 'function') { + throw new TypeError(ErrorsNames.FORBIDDEN_UNWRAP); + } + const current = (instance as Record)[field]; + const currentValueOf = (current as { valueOf?: unknown })?.valueOf; + const unwrapped = typeof currentValueOf === 'function' + ? (current as { valueOf: () => unknown }).valueOf() + : current; + Object.defineProperty(instance, field, { + value : unwrapped, + writable : true, + enumerable : true, + configurable : true + }); +}; + /* istanbul ignore next */ function setupCommonJS() { if (typeof module === 'undefined' || typeof module.exports === 'undefined') { @@ -432,6 +545,36 @@ function setupCommonJS() { }, enumerable: true }); + Object.defineProperty(module.exports, 'getConstructedFields', { + get() { + return getConstructedFields; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalize', { + get() { + return finalize; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'finalizeBy', { + get() { + return finalizeBy; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'isFinalized', { + get() { + return isFinalized; + }, + enumerable: true + }); + Object.defineProperty(module.exports, 'unwrap', { + get() { + return unwrap; + }, + enumerable: true + }); } setupCommonJS(); diff --git a/test/esm/class-fields.test.ts b/test/esm/class-fields.test.ts new file mode 100644 index 0000000..41856fe --- /dev/null +++ b/test/esm/class-fields.test.ts @@ -0,0 +1,63 @@ +import { describe, it, expect } from 'vitest'; + +import { + BaseClass, + finalize, + finalizeBy, + getConstructedFields, + isFinalized, + unwrap +} from 'typeomatica'; + +// The point of this suite: real class-field syntax. It only tests what it +// claims if the fields are installed with define semantics +// (useDefineForClassFields: true, native since ES2022) — see the local +// tsconfig.json in this directory. The Jest suite compiles class fields to +// constructor assignments instead and simulates the same with +// Object.defineProperty. + +class NativeFields extends BaseClass { + hidden = 42; + declare shown: number; + constructor () { + super(); + this.shown = 1; + } +} + +describe('native class fields (define semantics)', () => { + + it('class field initializers bypass the proxy and stay untracked', () => { + const i = new NativeFields(); + expect(getConstructedFields(i).has('shown')).toBe(true); + expect(getConstructedFields(i).has('hidden')).toBe(false); + expect(i.hidden).toBe(42); // plain own data property + }); + + it('finalize re-guards a native class field and preserves the value', () => { + const i = new NativeFields(); + finalize(i); + expect(isFinalized(i)).toBe(true); + expect(i.hidden.valueOf()).toBe(42); + expect(() => { + // @ts-ignore + i.hidden = 'nope'; + }).toThrow('Type Mismatch'); + }); + + it('finalizeBy partially re-guards; unwrap rolls it back', () => { + const i = new NativeFields(); + finalizeBy(i, ['hidden']); + expect(isFinalized(i)).toBe(false); + expect(() => { + // @ts-ignore + i.hidden = 'nope'; + }).toThrow('Type Mismatch'); + unwrap(i, 'hidden'); + expect(i.hidden).toBe(42); + // @ts-ignore + i.hidden = 'free again'; + expect(i.hidden).toBe('free again'); + }); + +}); diff --git a/test/esm/imports.test.ts b/test/esm/imports.test.ts index b21ab9c..57731a6 100644 --- a/test/esm/imports.test.ts +++ b/test/esm/imports.test.ts @@ -8,6 +8,10 @@ import BasePrototype, { SymbolInitialValue, SymbolTypeomaticaProxyReference, baseTarget, + finalize, + finalizeBy, + getConstructedFields, + isFinalized, TypeomaticaOptions } from 'typeomatica'; @@ -23,6 +27,10 @@ describe('ESM imports', () => { expect(typeof FieldConstructor).toBe('function'); expect(typeof Strict).toBe('function'); expect(typeof baseTarget).toBe('function'); + expect(typeof finalize).toBe('function'); + expect(typeof finalizeBy).toBe('function'); + expect(typeof getConstructedFields).toBe('function'); + expect(typeof isFinalized).toBe('function'); expect(typeof SymbolInitialValue).toBe('symbol'); expect(typeof SymbolTypeomaticaProxyReference).toBe('symbol'); }); diff --git a/test/index.ts b/test/index.ts index da3977c..b29c44c 100644 --- a/test/index.ts +++ b/test/index.ts @@ -11,7 +11,7 @@ const ogp = Object.getPrototypeOf; // go as you want for being meaningfull // or meaningless const BasePrototype = require('..'); -const { BaseClass, FieldConstructor, SymbolInitialValue, Strict, SymbolTypeomaticaProxyReference, baseTarget } = BasePrototype; +const { BaseClass, FieldConstructor, SymbolInitialValue, Strict, SymbolTypeomaticaProxyReference, baseTarget, getConstructedFields, finalize, finalizeBy, isFinalized, unwrap } = BasePrototype; const givenTags = new Map(); let givenTagsInvocations = 0; @@ -1078,3 +1078,164 @@ describe(`check duplications, skipped ${skip}`, () => { } } }); + + +describe('construction fields tracking + finalize (Thunderstruck step 1)', () => { + + // NOTE: ts-jest compiles class fields to constructor assignments + // (useDefineForClassFields: false), so class-field syntax would NOT + // bypass the proxy here. A truly hidden field is established with + // define semantics — exactly what native ES2022 class fields do. + + class TrackedProbe extends BaseClass { + declare shown: number; + declare name: string; + constructor() { + super(); + this.shown = 1; + this.name = 'first'; + } + } + + const addHiddenField = (instance: object, value: unknown) => { + Object.defineProperty(instance, 'hidden', { + value, + writable: true, + enumerable: true, + configurable: true + }); + }; + + test('fields assigned through the proxy are recorded per instance', () => { + const i = new TrackedProbe(); + addHiddenField(i, 42); + const fields = getConstructedFields(i); + expect(fields.has('shown')).toBe(true); + expect(fields.has('name')).toBe(true); + expect(fields.has('hidden')).toBe(false); + }); + + test('getConstructedFields returns a copy; untracked objects give an empty set', () => { + const i = new TrackedProbe(); + const fields = getConstructedFields(i); + fields.add('intruder'); + expect(getConstructedFields(i).has('intruder')).toBe(false); + expect(getConstructedFields({}).size).toBe(0); + }); + + test('finalize re-establishes hidden fields through the machinery', () => { + const i = new TrackedProbe(); + addHiddenField(i, 42); + expect(isFinalized(i)).toBe(false); + + // hidden is a plain own data property: unguarded writes pass + // @ts-ignore + i.hidden = 'anything goes'; + + finalize(i); + expect(isFinalized(i)).toBe(true); + + // the last value is preserved, now read through the primitives guard + // @ts-ignore + expect(i.hidden.valueOf()).toBe('anything goes'); + expect(() => { + // @ts-ignore + i.hidden = 123; + }).toThrow('Type Mismatch'); + + // same-type writes still pass after finalize + // @ts-ignore + i.hidden = 'guarded now'; + // @ts-ignore + expect(i.hidden.valueOf()).toBe('guarded now'); + }); + + test('finalizeBy guards only the listed fields and leaves finalized false', () => { + const i = new TrackedProbe(); + addHiddenField(i, 42); + finalizeBy(i, ['hidden']); + expect(isFinalized(i)).toBe(false); + // @ts-ignore + expect(i.hidden.valueOf()).toBe(42); + expect(() => { + // @ts-ignore + i.hidden = 'nope'; + }).toThrow('Type Mismatch'); + }); + + test('finalizeBy skips unknown names without touching anything', () => { + const i = new TrackedProbe(); + addHiddenField(i, 42); + expect(() => finalizeBy(i, ['nonexistent'])).not.toThrow(); + // still a plain own data property, unproxied read + // @ts-ignore + expect(i.hidden).toBe(42); + }); + + test('finalize leaves untracked own accessors as they are', () => { + const i = new TrackedProbe(); + Object.defineProperty(i, 'manual', { + get() { return 'manual value'; }, + configurable: true + }); + finalize(i); + // @ts-ignore + expect(i.manual).toBe('manual value'); + expect(isFinalized(i)).toBe(true); + }); + + test('isFinalized is false for objects typeomatica never saw', () => { + expect(isFinalized({})).toBe(false); + }); + + test('unwrap turns a finalized primitive field back into a plain value', () => { + const i = new TrackedProbe(); + addHiddenField(i, 42); + finalize(i); + // @ts-ignore + expect(i.hidden.valueOf()).toBe(42); + unwrap(i, 'hidden'); + // @ts-ignore + expect(i.hidden).toBe(42); + // @ts-ignore + i.hidden = 'free again'; + // @ts-ignore + expect(i.hidden).toBe('free again'); + }); + + test('unwrap places an object field as-is', () => { + const i = new TrackedProbe(); + addHiddenField(i, { deep: true }); + finalize(i); + // @ts-ignore + const before = i.hidden; + unwrap(i, 'hidden'); + // @ts-ignore + expect(i.hidden).toBe(before); + // @ts-ignore + expect(i.hidden.deep).toBe(true); + }); + + test('unwrap places a nullish field as-is', () => { + const i = new TrackedProbe(); + addHiddenField(i, null); + finalize(i); + unwrap(i, 'hidden'); + // @ts-ignore + expect(i.hidden).toBe(null); + }); + + test('unwrap refuses fields guarded since construction', () => { + const i = new TrackedProbe(); + finalize(i); + expect(() => unwrap(i, 'shown')).toThrow('Unwrap is allowed only for finalized fields'); + }); + + test('unwrap refuses missing and never-guarded fields', () => { + const i = new TrackedProbe(); + expect(() => unwrap(i, 'nonexistent')).toThrow('Unwrap is allowed only for finalized fields'); + addHiddenField(i, 42); + expect(() => unwrap(i, 'hidden')).toThrow('Unwrap is allowed only for finalized fields'); + }); + +});