diff --git a/README.md b/README.md index f91bae5..2a3e176 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Type ø matica +# TypeØmatica [![Coverage Status](https://coveralls.io/repos/github/wentout/typeomatica/badge.svg?branch=main)](https://coveralls.io/github/wentout/typeomatica?branch=main) @@ -8,37 +8,383 @@ [**$ npm install typeomatica**](https://www.npmjs.com/package/typeomatica) - This package is a part of [mnemonica](https://www.npmjs.com/package/mnemonica) project. -Strict Types checker for objects which represent Data Types. +**Strict Runtime Type Checker for JavaScript Objects** + +TypeØmatica uses JavaScript Proxies to enforce type safety at runtime, exactly as TypeScript expects at compile time. Once a property is assigned a value, its type is locked and cannot be changed. + +--- + +## Quick Start + +```typescript +import { BaseClass } from 'typeomatica'; + +class User extends BaseClass { + name: string = 'default'; + age: number = 0; +} + +const user = new User(); + +// ✓ Valid assignments +user.name = 'John'; +user.age = 25; + +// ✗ Runtime error (even if TypeScript is bypassed with @ts-ignore) +user.age = '25'; // TypeError: Type Mismatch +``` + +--- + +## Table of Contents + +- [What is TypeØmatica?](#what-is-typeomatica) +- [Installation](#installation) +- [Core Concepts](#core-concepts) +- [API Reference](#api-reference) +- [Usage Patterns](#usage-patterns) +- [Type Examples](#type-examples) +- [Working with Wrapped Values](#working-with-wrapped-values) +- [Error Reference](#error-reference) +- [Integration with Mnemonica](#integration-with-mnemonica) + +--- + +## What is TypeØmatica? + +TypeØmatica provides strict runtime type checking for JavaScript objects using Proxy-based interception. It ensures that once a property is initialized with a type, that type cannot be violated at runtime. + +**Key Features:** +- Runtime type enforcement (complements TypeScript's compile-time checks) +- Proxy-based property interception +- Type locking after initial assignment +- Prevents prototype mutation, property redefinition, and deletion + +--- + +## Installation + +```bash +npm install typeomatica +``` + +--- + +## Core Concepts + +### How It Works + +TypeØmatica wraps objects with JavaScript Proxies that intercept: +- `get` - Property reads +- `set` - Property writes (with type validation) +- `setPrototypeOf` - Blocks prototype changes +- `defineProperty` - Blocks property redefinition +- `deleteProperty` - Blocks property deletion + +### Type Categories + +| Category | Types | Behavior | +|----------|-------|----------| +| `primitives` | string, number, boolean, bigint, symbol, undefined | Type-locked accessors | +| `nullish` | null | Only null allowed | +| `objects` | object, arrays, dates | Same constructor type required | +| `functions` | methods | Restricted on data types | + +--- + +## API Reference + +### BaseClass + +The primary class for strict-type objects. + +```typescript +import { BaseClass } from 'typeomatica'; + +class MyClass extends BaseClass { + field: string = 'value'; + constructor() { + super(); + } +} +``` + +### BasePrototype + +Functional equivalent of `BaseClass`. + +```typescript +import { BasePrototype } from 'typeomatica'; + +const Base = BasePrototype({ initialProp: 123 }); +class MyClass extends Base { } +``` + +### @Strict() Decorator + +Apply strict typing without extending BaseClass. + +```typescript +import { Strict } from 'typeomatica'; + +@Strict({ deep: true }) +class MyClass { + field: number = 0; +} +``` + +**Decorator Arguments:** +- First argument: Base prototype or options object +- Second argument: Options object + +### Options Interface + +```typescript +interface TypeomaticaOptions { + strictAccessCheck?: boolean; // default: false +} +``` + +**Options:** +- `strictAccessCheck: true` - Enables strict receiver checking (throws `ACCESS_DENIED` error when property is accessed from wrong context) +- `deep: true` - Enable recursive property checking (when using BasePrototype with initial values) + +### Usage with Options + +```typescript +// With BaseClass - strict access checking enabled +class SecureData extends BaseClass { + secret: string = ''; + constructor() { + super(undefined, { strictAccessCheck: true }); + } +} + +// With BasePrototype - strict access checking enabled +const SecureBase = BasePrototype({ data: '' }, { strictAccessCheck: true }); +class User extends SecureBase { + name: string = ''; +} + +// With @Strict decorator - strict access checking enabled +@Strict(undefined, { strictAccessCheck: true }) +class Product { + price: number = 0; +} +``` + +### Symbol Exports + +```typescript +import { + SymbolTypeomaticaProxyReference, // Access proxy internals + SymbolInitialValue // Access original values +} from 'typeomatica'; +``` + +--- -# how it works +## Usage Patterns -see `test/index.ts` +### Pattern 1: Extending BaseClass -```js +```typescript +import { BaseClass } from 'typeomatica'; -class SimpleBase extends BasePrototype { - stringProp = '123'; -}; +class User extends BaseClass { + name: string = ''; + age: number = 0; + active: boolean = true; +} -// nect code line will work properly -simpleInstance.stringProp = '321'; +const user = new User(); +user.name = 'John'; // ✓ Works +user.age = 25; // ✓ Works -// but next code line will throw TypeError('Type Mismatch') // @ts-ignore -simpleInstance.stringProp = 123; +user.age = '25'; // ✗ TypeError: Type Mismatch +``` + +### Pattern 2: @Strict Decorator + +```typescript +import { Strict } from 'typeomatica'; + +@Strict({ deep: true }) +class Product { + id: number = 0; + title: string = ''; + price: number = 0; +} +const product = new Product(); +product.price = 29.99; // ✓ Works +// @ts-ignore +product.price = '$29.99'; // ✗ TypeError: Type Mismatch ``` -That is it. It will be impossible to assign anything else except of: +### Pattern 3: BaseClass as Prototype + +```typescript +import { BaseClass } from 'typeomatica'; + +class UserData { + name: string = 'default'; + age: number = 0; +} + +// Inject type checking into prototype chain +Object.setPrototypeOf(UserData.prototype, new BaseClass({ deep: true })); -```js -typeof something === 'string' +const user = new UserData(); +user.name = 'John'; // ✓ Works +// @ts-ignore +user.name = 123; // ✗ TypeError: Type Mismatch ``` -to `stringProp` in runtime. +--- + +## Type Examples + +### Primitives + +```typescript +import { BaseClass } from 'typeomatica'; + +class Primitives extends BaseClass { + str: string = 'hello'; + num: number = 42; + bool: boolean = true; + bigint: bigint = BigInt(100); +} + +const p = new Primitives(); +p.str = 'world'; // ✓ Works +p.num = 100; // ✓ Works +// @ts-ignore +p.str = 123; // ✗ TypeError: Type Mismatch +``` + +### Null and Undefined + +```typescript +class Nullable extends BaseClass { + nullValue: null = null; + undefinedValue: undefined = undefined; +} + +const n = new Nullable(); +n.nullValue = null; // ✓ Works +// @ts-ignore +n.nullValue = undefined; // ✗ TypeError: Type Mismatch +``` + +### Objects + +```typescript +class WithObject extends BaseClass { + data: object = {}; + list: number[] = []; +} + +const w = new WithObject(); +w.data = { a: 1 }; // ✓ Works +w.list = [1, 2, 3]; // ✓ Works +// @ts-ignore +w.data = 123; // ✗ TypeError: Type Mismatch +// @ts-ignore +w.data = new Set(); // ✗ TypeError: Type Mismatch (Set !== Object) +``` + +--- + +## Working with Wrapped Values + +TypeØmatica wraps primitives to enforce type safety. Use `valueOf()` for operations. + +### Numeric Operations + +```typescript +class Calc extends BaseClass { + count: number = 10; +} + +const calc = new Calc(); + +// ✗ Direct arithmetic throws +const result = calc.count + 5; // ReferenceError: Value Access Denied + +// ✓ Use valueOf() +const result = calc.count.valueOf() + 5; // 15 +const sum = 3 + +calc.count; // 13 +``` + +### String Operations + +```typescript +class Text extends BaseClass { + message: string = 'hello'; +} + +const text = new Text(); +text.message.valueOf().toUpperCase(); // 'HELLO' +text.message.valueOf().length; // 5 +``` + +--- + +## Error Reference + +| Error Message | Error Type | When Thrown | +|---------------|------------|-------------| +| `Type Mismatch` | TypeError | Wrong type assigned to property | +| `Value Access Denied` | ReferenceError | Property accessed from wrong context (only when `strictAccessCheck: true`) | +| `Attempt to Access to Undefined Prop` | Error | Reading non-existent property | +| `Functions are Restricted` | TypeError | Function assigned to data property | +| `Re-Assirnment is Forbidden` | TypeError | Modifying read-only custom field | +| `Setting prototype is not allowed` | Error | Calling `Object.setPrototypeOf()` | +| `Defining new Properties is not allowed` | Error | Calling `Object.defineProperty()` | +| `Properties Deletion is not allowed` | Error | Calling `delete` on property | + +--- + +## Integration with Mnemonica + +TypeØmatica integrates seamlessly with [mnemonica](https://www.npmjs.com/package/mnemonica) for combined prototype inheritance and runtime type safety. + +```typescript +import { decorate } from 'mnemonica'; +import { BaseClass, Strict } from 'typeomatica'; + +@decorate() +@Strict() +class Entity extends BaseClass { + id: string = ''; + createdAt: Date = new Date(); +} + +// Works with mnemonica's inheritance system +const User = Entity.define('User', function(this: { email: string }) { + this.email = ''; +}); + +const user = new User(); +// @ts-ignore +user.email = 123; // ✗ TypeError: Type Mismatch +``` + +**Decorator Order Matters:** +- `@Strict()` must come AFTER `@decorate()` (inner decorator) +- Decorators apply bottom-to-top + +For complete integration documentation, see [mnemonica's TypeØmatica guide](https://github.com/wentout/mnemonica/blob/main/core/TypeØmatica.md). + +--- + +## License + +MIT -As we describe Data Types — please take a peek for tests directory: -[HERE](https://github.com/wentout/typeomatica/blob/main/test/index.ts). +Copyright (c) 2019-2024 https://github.com/wentout diff --git a/lib/errors.js b/lib/errors.js index ae61c5b..ceda5aa 100644 --- a/lib/errors.js +++ b/lib/errors.js @@ -8,3 +8,4 @@ exports.ErrorsNames = { RIP_FUNCTIONS: 'Functions are Restricted', FORBIDDEN_RE: 'Re-Assirnment is Forbidden' }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUVBLFFBQUEsV0FBVyxHQUFHO0lBQzFCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsWUFBWSxFQUFFLHFDQUFxQztJQUNuRCxhQUFhLEVBQUUsMEJBQTBCO0lBQ3pDLFlBQVksRUFBRSw0QkFBNEI7Q0FDMUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuZXhwb3J0IGNvbnN0IEVycm9yc05hbWVzID0ge1xuXHRUWVBFX01JU01BVENIOiAnVHlwZSBNaXNtYXRjaCcsXG5cdEFDQ0VTU19ERU5JRUQ6ICdWYWx1ZSBBY2Nlc3MgRGVuaWVkJyxcblx0TUlTU0lOR19QUk9QOiAnQXR0ZW1wdCB0byBBY2Nlc3MgdG8gVW5kZWZpbmVkIFByb3AnLFxuXHRSSVBfRlVOQ1RJT05TOiAnRnVuY3Rpb25zIGFyZSBSZXN0cmljdGVkJyxcblx0Rk9SQklEREVOX1JFOiAnUmUtQXNzaXJubWVudCBpcyBGb3JiaWRkZW4nXG59OyJdfQ== \ No newline at end of file diff --git a/lib/fields.js b/lib/fields.js index c033045..7d2da44 100644 --- a/lib/fields.js +++ b/lib/fields.js @@ -26,3 +26,4 @@ class FieldConstructor { exports.FieldConstructor = FieldConstructor; Object.freeze(FieldConstructor.prototype); Object.seal(FieldConstructor.prototype); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/lib/index.d.ts b/lib/index.d.ts index 21ad5f0..011b208 100644 --- a/lib/index.d.ts +++ b/lib/index.d.ts @@ -1,11 +1,14 @@ +export interface TypeomaticaOptions { + strictAccessCheck?: boolean; +} export declare const baseTarget: (_proto?: object) => any; export declare const SymbolTypeomaticaProxyReference: unique symbol; export declare const BaseConstructorPrototype: { - new (_target?: T): T; - (_target?: S extends infer S_1 ? S_1 : {}): S; + new (_target?: T, options?: TypeomaticaOptions): T; + (_target?: S extends infer S_1 ? S_1 : {}, options?: TypeomaticaOptions): S; }; export declare class BaseClass { - constructor(_target?: object); + constructor(_target?: object, options?: TypeomaticaOptions); } export declare const SymbolInitialValue: symbol; -export declare const Strict: (_target?: object) => (cstr: T) => T; +export declare const Strict: (_target?: object, options?: TypeomaticaOptions) => (cstr: T) => T; diff --git a/lib/index.js b/lib/index.js index 6c453ba..5dbdf1e 100644 --- a/lib/index.js +++ b/lib/index.js @@ -4,43 +4,47 @@ exports.Strict = exports.SymbolInitialValue = exports.BaseClass = exports.BaseCo const errors_1 = require("./errors"); const types_1 = require("./types"); const fields_1 = require("./fields"); -const resolver = Object.entries({ - primitives: types_1.primitives, - special: types_1.special, - nullish: types_1.nullish, - objects: types_1.objects, - functions: types_1.functions -}).reduce((obj, [key, _handler]) => { - obj[key] = function (initialValue, receiver) { - const handler = _handler(initialValue); - return { - get() { - const invocationThis = this; - if (invocationThis !== receiver) { - throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED); +const createResolver = (options = {}) => { + const { strictAccessCheck = false } = options; + return Object.entries({ + primitives: types_1.primitives, + special: types_1.special, + nullish: types_1.nullish, + objects: types_1.objects, + functions: types_1.functions + }).reduce((obj, [key, _handler]) => { + obj[key] = function (initialValue, receiver) { + const handler = _handler(initialValue); + return { + get() { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED); + } + const result = handler.get(); + return result; + }, + set(replacementValue) { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED); + } + const result = handler.set(replacementValue); + return result; } - const result = handler.get(); - return result; - }, - set(replacementValue) { - const invocationThis = this; - if (invocationThis !== receiver) { - throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED); - } - const result = handler.set(replacementValue); - return result; - } + }; }; - }; - return obj; -}, {}); -const createProperty = (propName, initialValue, receiver) => { + return obj; + }, {}); +}; +const createProperty = (propName, initialValue, receiver, options) => { const value = initialValue; const valueIsPrimitive = (0, types_1.isPrimitive)(initialValue); const isObject = typeof initialValue === 'object'; const isFunction = initialValue instanceof Function; const isNull = initialValue === null; const types = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special')); + const resolver = createResolver(options); const descriptor = (isObject && (value instanceof fields_1.FieldConstructor)) ? value : @@ -61,7 +65,7 @@ const props2skip = new Set([ const util = require('util'); const hasNodeInspect = (util && util.inspect && util.inspect.custom); (hasNodeInspect && (props2skip.add(util.inspect.custom))); -const handlers = { +const createHandlers = (options) => ({ get(target, prop, receiver) { const result = Reflect.get(target, prop, receiver); if (result !== undefined) { @@ -85,7 +89,7 @@ const handlers = { throw new Error(errorMessage); }, set(_, prop, value, receiver) { - const result = createProperty(prop, value, receiver); + const result = createProperty(prop, value, receiver, options); return result; }, setPrototypeOf() { @@ -97,8 +101,7 @@ const handlers = { deleteProperty() { throw new Error('Properties Deletion is not allowed!'); }, -}; -Object.freeze(handlers); +}); const baseTarget = (_proto) => { const proto = typeof _proto === 'object' ? _proto : null; const answer = Object.create(proto); @@ -106,7 +109,7 @@ const baseTarget = (_proto) => { }; exports.baseTarget = baseTarget; exports.SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference'); -const getTypeomaticaProxyReference = (_target) => { +const getTypeomaticaProxyReference = (_target, options) => { const target = Object.create(_target); const id = `TypeØmaticaProxyReference-${Math.random()}`; Object.defineProperty(target, exports.SymbolTypeomaticaProxyReference, { @@ -114,12 +117,13 @@ const getTypeomaticaProxyReference = (_target) => { return id; } }); + const handlers = createHandlers(options); const proxy = new Proxy(target, handlers); return proxy; }; -exports.BaseConstructorPrototype = function (_target) { +exports.BaseConstructorPrototype = function (_target, options) { if (!new.target) { - const self = exports.BaseConstructorPrototype.bind(this, _target); + const self = exports.BaseConstructorPrototype.bind(this, _target, options); self.prototype = { constructor: exports.BaseConstructorPrototype }; @@ -129,7 +133,7 @@ exports.BaseConstructorPrototype = function (_target) { return this; } const target = (0, exports.baseTarget)(_target); - const InstancePrototype = getTypeomaticaProxyReference(target); + const InstancePrototype = getTypeomaticaProxyReference(target, options); let proto; let protoPointer = this; let protoConstrcutor; @@ -162,12 +166,12 @@ Object.defineProperty(module, 'exports', { enumerable: true }); class BaseClass { - constructor(_target) { + constructor(_target, options) { if (this[exports.SymbolTypeomaticaProxyReference]) { return this; } const target = (0, exports.baseTarget)(_target); - const proxy = getTypeomaticaProxyReference(target); + const proxy = getTypeomaticaProxyReference(target, options); let proto = this; let protoPointer; let found = false; @@ -183,13 +187,13 @@ class BaseClass { } } exports.BaseClass = BaseClass; -const strict = function (_target) { +const strict = function (_target, options) { const decorator = function (cstr) { if (cstr.prototype[exports.SymbolTypeomaticaProxyReference]) { return cstr; } const target = (0, exports.baseTarget)(_target); - const proxy = getTypeomaticaProxyReference(target); + const proxy = getTypeomaticaProxyReference(target, options); const _replacer = Object.create(proxy); Object.setPrototypeOf(cstr.prototype, _replacer); return cstr; @@ -236,3 +240,4 @@ Object.defineProperty(module.exports, 'Strict', { }); Object.freeze(exports.BaseConstructorPrototype); Object.freeze(exports.BaseConstructorPrototype.prototype); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// oxlint-disable typescript/no-this-alias\n/* eslint-disable no-debugger */\n'use strict';\n\nimport { ErrorsNames } from './errors';\n\nimport {\n\tfunctions,\n\tnullish,\n\tobjects,\n\tprimitives,\n\tspecial,\n\tisPrimitive\n} from './types';\n\nimport { FieldConstructor } from './fields';\n\nexport interface TypeomaticaOptions {\n\tstrictAccessCheck?: boolean;\n}\n\nconst createResolver = (options: TypeomaticaOptions = {}) => {\n\tconst { strictAccessCheck = false } = options;\n\t\n\treturn Object.entries({\n\t\tprimitives,\n\t\tspecial,\n\t\tnullish,\n\t\tobjects,\n\t\tfunctions\n\t}).reduce((obj: object, [key, _handler]) => {\n\t\t// @ts-ignore\n\t\tobj[key] = function (initialValue: object, receiver: object) {\n\t\t\tconst handler = _handler(initialValue);\n\t\t\treturn {\n\t\t\t\tget() {\n\t\t\t\t\tconst invocationThis = this;\n\t\t\t\t\tif (strictAccessCheck && invocationThis !== receiver) {\n\t\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t\t}\n\t\t\t\t\tconst result = handler.get();\n\t\t\t\t\treturn result;\n\t\t\t\t},\n\t\t\t\tset(replacementValue: unknown) {\n\t\t\t\t\tconst invocationThis = this;\n\t\t\t\t\tif (strictAccessCheck && invocationThis !== receiver) {\n\t\t\t\t\t\tthrow new ReferenceError(ErrorsNames.ACCESS_DENIED);\n\t\t\t\t\t}\n\t\t\t\t\tconst result = handler.set(replacementValue);\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\t\t\t};\n\t\t};\n\n\t\treturn obj;\n\t}, {});\n};\n\nconst createProperty = (propName: string, initialValue: unknown, receiver: object, options?: TypeomaticaOptions) => {\n\n\tconst value = initialValue;\n\tconst valueIsPrimitive = isPrimitive(initialValue);\n\tconst isObject = typeof initialValue === 'object';\n\tconst isFunction = initialValue instanceof Function;\n\tconst isNull = initialValue === null;\n\n\t/**\n\t * special: undefined or BigInt or Symbol\n\t * \tor other non constructible type\n\t */\n\n\tconst types = valueIsPrimitive ? 'primitives' : (\n\t\tisObject ? (\n\t\t\tisNull ? 'nullish' : 'objects'\n\t\t) : (\n\t\t\tisFunction ? 'functions' : 'special'\n\t\t)\n\t);\n\n\tconst resolver = createResolver(options);\n\n\tconst descriptor = (isObject && (value instanceof FieldConstructor)) ?\n\t\tvalue\n\t\t:\n\t\t{\n\t\t\tenumerable: true,\n\t\t\t// @ts-ignore\n\t\t\t...resolver[types](value, receiver),\n\t\t};\n\n\t// if (value instanceof FieldConstructor) {\n\t// \tdescriptor;\n\t// \tdebugger;\n\t// }\n\n\tconst result = Reflect.defineProperty(receiver, propName, descriptor);\n\treturn result;\n\n};\n\n// line below 'href' is for util.inspect works, useful for v24\nconst props2skip = new Set([\n\tSymbol.toStringTag,\n\tSymbol.iterator,\n\t// Symbol.toPrimitive,\n\t'toString',\n\t'valueOf',\n\t'href'\n]);\n// const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);\nconst util = require('util');\nconst hasNodeInspect = (util && util.inspect && util.inspect.custom);\n// oxlint-disable-next-line no-unused-expressions\n(hasNodeInspect && (props2skip.add(util.inspect.custom)));\n\nconst createHandlers = (options?: TypeomaticaOptions) => ({\n\tget(target: object, prop: string | symbol, receiver: object) {\n\t\tconst result = Reflect.get(target, prop, receiver);\n\t\tif (result !== undefined) {\n\t\t\treturn result;\n\t\t}\n\t\tif (prop === 'toJSON') {\n\t\t\t// eslint-disable-next-line no-unused-vars\n\t\t\treturn function (this: typeof target) {\n\t\t\t\tconst entries = Object.entries(this);\n\t\t\t\treturn JSON.stringify(entries.reduce((obj, [key, value]) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tobj[key] = value.valueOf();\n\t\t\t\t\treturn obj;\n\t\t\t\t}, {}));\n\t\t\t};\n\t\t}\n\t\tconst { name } = receiver.constructor;\n\t\tif (props2skip.has(prop)) {\n\t\t\tconst message = `${name} lacks definition of [ ${String(prop).valueOf()} ]`;\n\t\t\treturn message;\n\t\t}\n\t\tconst errorMessage = `${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] for ${name}`;\n\t\tthrow new Error(errorMessage);\n\t},\n\tset(_: object, prop: string, value: unknown, receiver: object) {\n\t\tconst result = createProperty(prop, value, receiver, options);\n\t\treturn result;\n\t},\n\tsetPrototypeOf() {\n\t\t\tthrow new Error('Setting prototype is not allowed!');\n\t},\n\t// defineProperty(target: object, key: string, descriptor: object) {\n\tdefineProperty() {\n\t\t\tthrow new Error('Defining new Properties is not allowed!');\n\t\t// Reflect.defineProperty(target, key, descriptor);\n\t},\n\tdeleteProperty() {\n\t\t\tthrow new Error('Properties Deletion is not allowed!');\n\t},\n\t// getPrototypeOf() {\n\t// \tdebugger;\n\t// \tthrow new Error('Getting prototype is not allowed');\n\t// },\n});\n\n// user have to precisely define all props\nexport const baseTarget = (_proto?: object) => {\n\tconst proto = typeof _proto === 'object' ? _proto : null;\n\tconst answer = Object.create(proto);\n\treturn answer;\n};\n\nexport const SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference');\nconst getTypeomaticaProxyReference = (_target: object, options?: TypeomaticaOptions) => {\n\tconst target = Object.create(_target);\n\tconst id = `TypeØmaticaProxyReference-${Math.random()}`;\n\tObject.defineProperty(target, SymbolTypeomaticaProxyReference, {\n\t\tget() {\n\t\t\treturn id;\n\t\t}\n\t});\n\tconst handlers = createHandlers(options);\n\tconst proxy = new Proxy(target, handlers);\n\treturn proxy;\n};\n\n\nexport const BaseConstructorPrototype = function <T extends object, S extends T>(this: S extends T ? S : {}, _target?: T, options?: TypeomaticaOptions ): T {\n\tif (!new.target) {\n\n\t\tconst self: {\n\t\t\tprototype: {\n\t\t\t\tconstructor: typeof BaseConstructorPrototype\n\t\t\t}\n\t\t\t//@ts-ignore\n\t\t} = BaseConstructorPrototype.bind(this, _target, options);\n\n\t\tself.prototype = {\n\t\t\tconstructor: BaseConstructorPrototype\n\t\t};\n\n\t\t// @ts-ignore\n\t\treturn self;\n\n\t}\n\n\t// @ts-ignore\n\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t// @ts-ignore\n\t\treturn this;\n\t}\n\n\tconst target = baseTarget(_target) as object;\n\n\tconst InstancePrototype = getTypeomaticaProxyReference(target, options);\n\n\tlet proto;\n\tlet protoPointer = this as object;\n\tlet protoConstrcutor;\n\n\tlet constructors = false;\n\n\t// @ts-ignore\n\t// const hasProxyReference = protoPointer[SymbolTypeomaticaProxyReference] as unknown as boolean;\n\t// if (hasProxyReference) {\n\t// \tthrow new Error('Multiple TypeØmatica instantiations are not allowed for the same Prototype Chain!');\n\t// }\n\n\tdo {\n\t\tproto = protoPointer;\n\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\tif (BaseConstructorPrototype.prototype === protoPointer) {\n\t\t\tconstructors = true;\n\t\t\tbreak;\n\t\t}\n\t\tif (!protoPointer) break;\n\t\tconst descriptor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor');\n\t\tif (!descriptor) continue;\n\t\tconst value = descriptor.value || descriptor.get;\n\t\t// if (!value) continue;\n\t\tprotoConstrcutor = value;\n\t} while (protoConstrcutor !== BaseConstructorPrototype);\n\n\tif (!constructors && protoConstrcutor !== BaseConstructorPrototype) {\n\t\tthrow new Error('Unable to setup TypeØmatica handler!');\n\t}\n\n\tObject.setPrototypeOf(proto, InstancePrototype);\n\t// @ts-ignore\n\treturn this;\n\n} as {\n\tnew<T extends object | {}>(_target?: T, options?: TypeomaticaOptions): T\n\t<T extends object | {}, S extends T>(_target?: S extends infer S ? S : {}, options?: TypeomaticaOptions): S\n};\n\nObject.defineProperty(module, 'exports', {\n\tget() {\n\t\treturn BaseConstructorPrototype;\n\t},\n\tenumerable: true\n});\n\nexport class BaseClass {\n\tconstructor(_target?: object, options?: TypeomaticaOptions) {\n\t\t// @ts-ignore\n\t\tif (this[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn this;\n\t\t}\n\n\t\tconst target = baseTarget(_target) as object;\n\t\tconst proxy = getTypeomaticaProxyReference(target, options);\n\t\tlet proto: object | null = this;\n\t\tlet protoPointer: object | null;\n\t\tlet found: boolean = false;\n\t\tdo {\n\t\t\tprotoPointer = Object.getPrototypeOf(proto);\n\t\t\t// if (protoPointer[SymbolTypeomaticaProxyReference]) {\n\t\t\t// \tthrow new Error('Double TypeØmatica extension is not allowed!');\n\t\t\t// }\n\t\t\tif (protoPointer === Object.prototype) {\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t/*\n\t\t\t// it can be, that protoPointer === null\n\t\t\t// though too hard to implement this test\n\t\t\t*/\n\t\t\tproto = protoPointer;\n\t\t} while (!found);\n\t\tObject.setPrototypeOf(proto, proxy);\n\t}\n}\n\n\nconst strict = function (_target?: object, options?: TypeomaticaOptions) {\n\tconst decorator = function<T>(cstr: T): T {\n\n\t\t// @ts-ignore\n\t\tif (cstr.prototype[SymbolTypeomaticaProxyReference]) {\n\t\t\treturn cstr;\n\t\t}\n\n\t\tconst target = baseTarget(_target);\n\t\tconst proxy = getTypeomaticaProxyReference(target, options);\n\t\tconst _replacer = Object.create(proxy);\n\n\t\t// @ts-ignore\n\t\tObject.setPrototypeOf(cstr.prototype, _replacer);\n\n\t\treturn cstr;\n\n\n\t\t// const MyClassProxy = new Proxy(cstr, {\n\t\t// \tconstruct(_, argumentsList, newTarget) {\n\t\t// \t\tdebugger;\n\t\t// \t\tconst target = baseTarget(_target);\n\t\t// \t\tconst proxy = getTypeomaticaProxyReference(target);\n\t\t// \t\tconst _replacer = Object.create(proxy);\n\n\t\t// \t\tconst _proto = cstr.prototype;\n\n\t\t// \t\tconst proto = Object.create(Object.getPrototypeOf(_proto));\n\t\t// \t\tproto.iAmProto = true;\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\n\t\t// \t\tconst descriptors = Object.getOwnPropertyDescriptors(_proto);\n\t\t// \t\tObject.defineProperties(proto, descriptors);\n\n\t\t// \t\tconst replacer = Object.create(_replacer);\n\t\t// \t\tObject.setPrototypeOf(proto, replacer);\n\n\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, proto);\n\t\t// \t\tconst result = Reflect.construct(cstr, argumentsList, newTarget);\n\n\t\t// \t\tdebugger;\n\t\t// \t\tObject.setPrototypeOf(cstr.prototype, _proto);\n\t\t// \t\tdebugger;\n\n\t\t// \t\treturn result;\n\t\t// \t},\n\t\t// });\n\t\t// return MyClassProxy;\n\t};\n\n\treturn decorator;\n\n};\nexport const { SymbolInitialValue } = FieldConstructor;\nexport const Strict = strict;\n\nObject.defineProperty(module.exports, 'BaseClass', {\n\tget() {\n\t\treturn BaseClass;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'FieldConstructor', {\n\tget() {\n\t\treturn FieldConstructor;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolInitialValue', {\n\tget() {\n\t\treturn SymbolInitialValue;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'SymbolTypeomaticaProxyReference', {\n\tget() {\n\t\treturn SymbolTypeomaticaProxyReference;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'baseTarget', {\n\tget() {\n\t\treturn baseTarget;\n\t},\n\tenumerable: true\n});\nObject.defineProperty(module.exports, 'Strict', {\n\tget() {\n\t\treturn strict;\n\t},\n\tenumerable: true\n});\n\nObject.freeze(BaseConstructorPrototype);\nObject.freeze(BaseConstructorPrototype.prototype);\n"]} \ No newline at end of file diff --git a/lib/types/functions.js b/lib/types/functions.js index e68ef6c..6138a3a 100644 --- a/lib/types/functions.js +++ b/lib/types/functions.js @@ -6,3 +6,4 @@ const functions = () => { throw new TypeError(errors_1.ErrorsNames.RIP_FUNCTIONS); }; exports.functions = functions; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7OztBQUViLHNDQUF3QztBQUVqQyxNQUFNLFNBQVMsR0FBRyxHQUFHLEVBQUU7SUFDN0IsTUFBTSxJQUFJLFNBQVMsQ0FBQyxvQkFBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0FBQ2hELENBQUMsQ0FBQztBQUZXLFFBQUEsU0FBUyxhQUVwQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgRXJyb3JzTmFtZXMgfSBmcm9tICcuLi9lcnJvcnMnO1xuXG5leHBvcnQgY29uc3QgZnVuY3Rpb25zID0gKCkgPT4ge1xuXHR0aHJvdyBuZXcgVHlwZUVycm9yKEVycm9yc05hbWVzLlJJUF9GVU5DVElPTlMpO1xufTsiXX0= \ No newline at end of file diff --git a/lib/types/index.js b/lib/types/index.js index fe918e7..bcb8339 100644 --- a/lib/types/index.js +++ b/lib/types/index.js @@ -20,3 +20,4 @@ const isPrimitive = (value) => { return PRIMITIVE_TYPES.includes(typeof value); }; exports.isPrimitive = isPrimitive; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYix5Q0FBd0M7QUFBL0Isc0dBQUEsU0FBUyxPQUFBO0FBQ2xCLHFDQUFvQztBQUEzQixrR0FBQSxPQUFPLE9BQUE7QUFDaEIscUNBQW9DO0FBQTNCLGtHQUFBLE9BQU8sT0FBQTtBQUNoQiwyQ0FBMEM7QUFBakMsd0dBQUEsVUFBVSxPQUFBO0FBQ25CLHFDQUFvQztBQUEzQixrR0FBQSxPQUFPLE9BQUE7QUFFaEIsTUFBTSxlQUFlLEdBQUc7SUFDdkIsUUFBUTtJQUNSLFFBQVE7SUFDUixTQUFTO0NBQ1QsQ0FBQztBQUVLLE1BQU0sV0FBVyxHQUFHLENBQUMsS0FBYyxFQUFFLEVBQUU7SUFDN0MsT0FBTyxlQUFlLENBQUMsUUFBUSxDQUFDLE9BQU8sS0FBSyxDQUFDLENBQUM7QUFDL0MsQ0FBQyxDQUFDO0FBRlcsUUFBQSxXQUFXLGVBRXRCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5leHBvcnQgeyBmdW5jdGlvbnMgfSBmcm9tICcuL2Z1bmN0aW9ucyc7XG5leHBvcnQgeyBudWxsaXNoIH0gZnJvbSAnLi9udWxsaXNoJztcbmV4cG9ydCB7IG9iamVjdHMgfSBmcm9tICcuL29iamVjdHMnO1xuZXhwb3J0IHsgcHJpbWl0aXZlcyB9IGZyb20gJy4vcHJpbWl0aXZlcyc7XG5leHBvcnQgeyBzcGVjaWFsIH0gZnJvbSAnLi9zcGVjaWFsJztcblxuY29uc3QgUFJJTUlUSVZFX1RZUEVTID0gW1xuXHQnc3RyaW5nJyxcblx0J251bWJlcicsXG5cdCdib29sZWFuJyxcbl07XG5cbmV4cG9ydCBjb25zdCBpc1ByaW1pdGl2ZSA9ICh2YWx1ZTogdW5rbm93bikgPT4ge1xuXHRyZXR1cm4gUFJJTUlUSVZFX1RZUEVTLmluY2x1ZGVzKHR5cGVvZiB2YWx1ZSk7XG59O1xuIl19 \ No newline at end of file diff --git a/lib/types/nullish.js b/lib/types/nullish.js index 70a9ebc..26d2d1a 100644 --- a/lib/types/nullish.js +++ b/lib/types/nullish.js @@ -14,3 +14,4 @@ const nullish = (value) => { }; }; exports.nullish = nullish; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbGlzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9udWxsaXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsc0NBQXdDO0FBRWpDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHO1lBQ0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsb0JBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUN2RCxNQUFNLEtBQUssQ0FBQztRQUNiLENBQUM7S0FDRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBVlcsUUFBQSxPQUFPLFdBVWxCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycyc7XG5cbmV4cG9ydCBjb25zdCBudWxsaXNoID0gKHZhbHVlOiBvYmplY3QpID0+IHtcblx0cmV0dXJuIHtcblx0XHRnZXQoKSB7XG5cdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0fSxcblx0XHRzZXQoKSB7XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/lib/types/objects.js b/lib/types/objects.js index fd142a9..3075617 100644 --- a/lib/types/objects.js +++ b/lib/types/objects.js @@ -18,3 +18,4 @@ const objects = (value) => { }; }; exports.objects = objects; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9vYmplY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsc0NBQXdDO0FBRWpDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXlCO1lBQzVCLElBQUksZ0JBQWdCLFlBQVksTUFBTSxJQUFJLGdCQUFnQixDQUFDLFdBQVcsS0FBSyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUM7Z0JBQzlGLEtBQUssR0FBRyxnQkFBZ0IsQ0FBQztnQkFDekIsT0FBTyxLQUFLLENBQUM7WUFDZCxDQUFDO1lBQ0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxTQUFTLENBQUMsb0JBQVcsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUN2RCxNQUFNLEtBQUssQ0FBQztRQUNiLENBQUM7S0FDRCxDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBZFcsUUFBQSxPQUFPLFdBY2xCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNOYW1lcyB9IGZyb20gJy4uL2Vycm9ycyc7XG5cbmV4cG9ydCBjb25zdCBvYmplY3RzID0gKHZhbHVlOiBvYmplY3QpID0+IHtcblx0cmV0dXJuIHtcblx0XHRnZXQoKSB7XG5cdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0fSxcblx0XHRzZXQocmVwbGFjZW1lbnRWYWx1ZTogdW5rbm93bikge1xuXHRcdFx0aWYgKHJlcGxhY2VtZW50VmFsdWUgaW5zdGFuY2VvZiBPYmplY3QgJiYgcmVwbGFjZW1lbnRWYWx1ZS5jb25zdHJ1Y3RvciA9PT0gdmFsdWUuY29uc3RydWN0b3IpIHtcblx0XHRcdFx0dmFsdWUgPSByZXBsYWNlbWVudFZhbHVlO1xuXHRcdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0XHR9XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/lib/types/primitives.js b/lib/types/primitives.js index 4753ce5..034cd1f 100644 --- a/lib/types/primitives.js +++ b/lib/types/primitives.js @@ -47,3 +47,4 @@ const primitives = (initialValue) => { }; }; 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 ed7c56b..bdbb388 100644 --- a/lib/types/special.js +++ b/lib/types/special.js @@ -18,3 +18,4 @@ const special = (value) => { }; }; exports.special = special; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlY2lhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9zcGVjaWFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsc0NBQXdDO0FBRWpDLE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBYSxFQUFFLEVBQUU7SUFDeEMsT0FBTztRQUNOLEdBQUc7WUFDRixPQUFPLEtBQUssQ0FBQztRQUNkLENBQUM7UUFDRCxHQUFHLENBQUMsZ0JBQXdCO1lBQzNCLElBQUksT0FBTyxnQkFBZ0IsS0FBSyxPQUFPLEtBQUssRUFBRSxDQUFDO2dCQUM5QyxLQUFLLEdBQUcsZ0JBQWdCLENBQUM7Z0JBQ3pCLE9BQU8sS0FBSyxDQUFDO1lBQ2QsQ0FBQztZQUNELE1BQU0sS0FBSyxHQUFHLElBQUksU0FBUyxDQUFDLG9CQUFXLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDdkQsTUFBTSxLQUFLLENBQUM7UUFDYixDQUFDO0tBQ0QsQ0FBQztBQUNILENBQUMsQ0FBQztBQWRXLFFBQUEsT0FBTyxXQWNsQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgRXJyb3JzTmFtZXMgfSBmcm9tICcuLi9lcnJvcnMnO1xuXG5leHBvcnQgY29uc3Qgc3BlY2lhbCA9ICh2YWx1ZTogb2JqZWN0KSA9PiB7XG5cdHJldHVybiB7XG5cdFx0Z2V0KCkge1xuXHRcdFx0cmV0dXJuIHZhbHVlO1xuXHRcdH0sXG5cdFx0c2V0KHJlcGxhY2VtZW50VmFsdWU6IG9iamVjdCkge1xuXHRcdFx0aWYgKHR5cGVvZiByZXBsYWNlbWVudFZhbHVlID09PSB0eXBlb2YgdmFsdWUpIHtcblx0XHRcdFx0dmFsdWUgPSByZXBsYWNlbWVudFZhbHVlO1xuXHRcdFx0XHRyZXR1cm4gdmFsdWU7XG5cdFx0XHR9XG5cdFx0XHRjb25zdCBlcnJvciA9IG5ldyBUeXBlRXJyb3IoRXJyb3JzTmFtZXMuVFlQRV9NSVNNQVRDSCk7XG5cdFx0XHR0aHJvdyBlcnJvcjtcblx0XHR9XG5cdH07XG59OyJdfQ== \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 33498a0..01036b5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "typeomatica", - "version": "0.3.55", + "version": "0.3.57", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "typeomatica", - "version": "0.3.55", + "version": "0.3.57", "license": "MIT", "devDependencies": { "@eslint/eslintrc": "^3.3.3", diff --git a/package.json b/package.json index e4e42c8..332312b 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "typeomatica", - "version": "0.3.55", + "version": "0.3.57", "description": "type logic against javascript metaprogramming", "engines": { "node": ">=16" diff --git a/src/index.ts b/src/index.ts index 1140236..8a5cc64 100644 --- a/src/index.ts +++ b/src/index.ts @@ -15,40 +15,48 @@ import { import { FieldConstructor } from './fields'; -const resolver = Object.entries({ - primitives, - special, - nullish, - objects, - functions -}).reduce((obj: object, [key, _handler]) => { - // @ts-ignore - obj[key] = function (initialValue: object, receiver: object) { - const handler = _handler(initialValue); - return { - get() { - const invocationThis = this; - if (invocationThis !== receiver) { - throw new ReferenceError(ErrorsNames.ACCESS_DENIED); - } - const result = handler.get(); - return result; - }, - set(replacementValue: unknown) { - const invocationThis = this; - if (invocationThis !== receiver) { - throw new ReferenceError(ErrorsNames.ACCESS_DENIED); +export interface TypeomaticaOptions { + strictAccessCheck?: boolean; +} + +const createResolver = (options: TypeomaticaOptions = {}) => { + const { strictAccessCheck = false } = options; + + return Object.entries({ + primitives, + special, + nullish, + objects, + functions + }).reduce((obj: object, [key, _handler]) => { + // @ts-ignore + obj[key] = function (initialValue: object, receiver: object) { + 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: unknown) { + const invocationThis = this; + if (strictAccessCheck && invocationThis !== receiver) { + throw new ReferenceError(ErrorsNames.ACCESS_DENIED); + } + const result = handler.set(replacementValue); + return result; } - const result = handler.set(replacementValue); - return result; - } + }; }; - }; - return obj; -}, {}); + return obj; + }, {}); +}; -const createProperty = (propName: string, initialValue: unknown, receiver: object) => { +const createProperty = (propName: string, initialValue: unknown, receiver: object, options?: TypeomaticaOptions) => { const value = initialValue; const valueIsPrimitive = isPrimitive(initialValue); @@ -69,6 +77,8 @@ const createProperty = (propName: string, initialValue: unknown, receiver: objec ) ); + const resolver = createResolver(options); + const descriptor = (isObject && (value instanceof FieldConstructor)) ? value : @@ -103,7 +113,7 @@ const hasNodeInspect = (util && util.inspect && util.inspect.custom); // oxlint-disable-next-line no-unused-expressions (hasNodeInspect && (props2skip.add(util.inspect.custom))); -const handlers = { +const createHandlers = (options?: TypeomaticaOptions) => ({ get(target: object, prop: string | symbol, receiver: object) { const result = Reflect.get(target, prop, receiver); if (result !== undefined) { @@ -129,27 +139,25 @@ const handlers = { throw new Error(errorMessage); }, set(_: object, prop: string, value: unknown, receiver: object) { - const result = createProperty(prop, value, receiver); + const result = createProperty(prop, value, receiver, options); return result; }, setPrototypeOf() { - throw new Error('Setting prototype is not allowed!'); + 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!'); + throw new Error('Defining new Properties is not allowed!'); // Reflect.defineProperty(target, key, descriptor); }, deleteProperty() { - throw new Error('Properties Deletion is not allowed!'); + throw new Error('Properties Deletion is not allowed!'); }, // getPrototypeOf() { // debugger; // throw new Error('Getting prototype is not allowed'); // }, -}; - -Object.freeze(handlers); +}); // user have to precisely define all props export const baseTarget = (_proto?: object) => { @@ -159,7 +167,7 @@ export const baseTarget = (_proto?: object) => { }; export const SymbolTypeomaticaProxyReference = Symbol('TypeØmaticaProxyReference'); -const getTypeomaticaProxyReference = (_target: object) => { +const getTypeomaticaProxyReference = (_target: object, options?: TypeomaticaOptions) => { const target = Object.create(_target); const id = `TypeØmaticaProxyReference-${Math.random()}`; Object.defineProperty(target, SymbolTypeomaticaProxyReference, { @@ -167,12 +175,13 @@ const getTypeomaticaProxyReference = (_target: object) => { return id; } }); + const handlers = createHandlers(options); const proxy = new Proxy(target, handlers); return proxy; }; -export const BaseConstructorPrototype = function (this: S extends T ? S : {}, _target?: T ): T { +export const BaseConstructorPrototype = function (this: S extends T ? S : {}, _target?: T, options?: TypeomaticaOptions ): T { if (!new.target) { const self: { @@ -180,7 +189,7 @@ export const BaseConstructorPrototype = function constructor: typeof BaseConstructorPrototype } //@ts-ignore - } = BaseConstructorPrototype.bind(this, _target); + } = BaseConstructorPrototype.bind(this, _target, options); self.prototype = { constructor: BaseConstructorPrototype @@ -199,7 +208,7 @@ export const BaseConstructorPrototype = function const target = baseTarget(_target) as object; - const InstancePrototype = getTypeomaticaProxyReference(target); + const InstancePrototype = getTypeomaticaProxyReference(target, options); let proto; let protoPointer = this as object; @@ -237,8 +246,8 @@ export const BaseConstructorPrototype = function return this; } as { - new(_target?: T): T - (_target?: S extends infer S ? S : {}): S + new(_target?: T, options?: TypeomaticaOptions): T + (_target?: S extends infer S ? S : {}, options?: TypeomaticaOptions): S }; Object.defineProperty(module, 'exports', { @@ -249,14 +258,14 @@ Object.defineProperty(module, 'exports', { }); export class BaseClass { - constructor(_target?: object) { + constructor(_target?: object, options?: TypeomaticaOptions) { // @ts-ignore if (this[SymbolTypeomaticaProxyReference]) { return this; } const target = baseTarget(_target) as object; - const proxy = getTypeomaticaProxyReference(target); + const proxy = getTypeomaticaProxyReference(target, options); let proto: object | null = this; let protoPointer: object | null; let found: boolean = false; @@ -280,7 +289,7 @@ export class BaseClass { } -const strict = function (_target?: object) { +const strict = function (_target?: object, options?: TypeomaticaOptions) { const decorator = function(cstr: T): T { // @ts-ignore @@ -289,7 +298,7 @@ const strict = function (_target?: object) { } const target = baseTarget(_target); - const proxy = getTypeomaticaProxyReference(target); + const proxy = getTypeomaticaProxyReference(target, options); const _replacer = Object.create(proxy); // @ts-ignore diff --git a/test/index.ts b/test/index.ts index 44bfe5c..1e928f5 100644 --- a/test/index.ts +++ b/test/index.ts @@ -73,7 +73,7 @@ class Base extends BasePrototype({ someMethod() { return this.numberValue.valueOf(); }, -}) implements IBase { +}, { strictAccessCheck: true }) implements IBase { numberValue = 123; stringValue: string; booleanValue: boolean; @@ -115,7 +115,7 @@ class SimpleBase extends BaseClass { // ES2022 propString: string; constructor() { - super(); + super(undefined, { strictAccessCheck: true }); this.propString = '123'; } } @@ -144,7 +144,7 @@ class TripleExtend extends SecondaryExtend { } const tiripleExtendInstance = addTag(new TripleExtend); // eslint-disable-next-line new-cap -class NetworkedExtention extends BasePrototype(tiripleExtendInstance) { } +class NetworkedExtention extends BasePrototype(tiripleExtendInstance, { strictAccessCheck: true }) { } const networkedInstance = addTag(new NetworkedExtention); @@ -227,6 +227,9 @@ const myFieldReSet = new MyFieldConstructorReSet('initial value for set check'); class MadeFieldClass extends BaseClass { myField = myField as unknown | string; + constructor() { + super(undefined, { strictAccessCheck: true }); + } get [SymbolInitialValue]() { const self = this; return (fieldName: 'myField') => { @@ -239,13 +242,28 @@ class MadeFieldClass extends BaseClass { }; } } -class SecondMadeFieldClass extends BaseClass { myField = myField as unknown | string; } +class SecondMadeFieldClass extends BaseClass { + myField = myField as unknown | string; + constructor() { + super(undefined, { strictAccessCheck: true }); + } +} const madeFieldInstance = addTag(new MadeFieldClass); const secondMadeFieldInstance = addTag(new MadeFieldClass); const thirdMadeFieldInstance = addTag(new SecondMadeFieldClass); -class MadeReGet extends BaseClass { myField = myFieldReGet as unknown | string; } -class MadeReSet extends BaseClass { myField = myFieldReSet as unknown | string; } +class MadeReGet extends BaseClass { + myField = myFieldReGet as unknown | string; + constructor() { + super(undefined, { strictAccessCheck: true }); + } +} +class MadeReSet extends BaseClass { + myField = myFieldReSet as unknown | string; + constructor() { + super(undefined, { strictAccessCheck: true }); + } +} const madeReGet = addTag(new MadeReGet); const madeReSet = addTag(new MadeReSet); @@ -420,6 +438,9 @@ describe('props tests', () => { const wrongField = new WrongFieldConstructor(123); class WithWrongField extends BaseClass { erroredField = wrongField; + constructor() { + super(undefined, { strictAccessCheck: true }); + } } new WithWrongField; diff --git a/tsconfig.json b/tsconfig.json index e5d5223..dce48a3 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -10,6 +10,10 @@ "extendedDiagnostics": true, "forceConsistentCasingInFileNames": true, + + "inlineSourceMap": true, + "inlineSources": true, + "noFallthroughCasesInSwitch": true, "noImplicitReturns": true, "noImplicitThis": true,