typeomatica 0.3.2 → 0.3.3

package/.eslintrc.js

@@ -1,26 +1,23 @@
 module.exports = {
+	parser: '@typescript-eslint/parser',
 	env: {
 		node: true,
 		es6: true,
 	},
-	extends: ['eslint:recommended'],
+	extends: [
+		'eslint:recommended',
+		'plugin:@typescript-eslint/eslint-recommended'
+	],
 	parserOptions: {
 		ecmaVersion: 2018,
+		sourceType: 'module'
 	},
 	rules: {
-		'indent': ['error', 'tab'],
-		'key-spacing': [
-			'warn',
-			{
-				beforeColon: true,
-				afterColon: true,
-				align: 'colon',
-			},
-		],
+		indent: ['error', 'tab'],
 		'linebreak-style': ['error', 'unix'],
 		quotes: ['error', 'single'],
 		semi: ['error', 'always'],
-		'no-unused-vars': 'warn',
+		// 'no-unused-vars': 'warn',
 		'no-shadow': [
 			'error',
 			{
@@ -29,13 +26,13 @@ module.exports = {
 				allow: [],
 			},
 		],
-		'space-before-function-paren': [
-			'warn', {
-				'anonymous': 'always',
-				'named': 'always',
-				'asyncArrow': 'always'
-			}
-		],
+		// 'space-before-function-paren': [
+		// 	'warn', {
+		// 		'anonymous': 'always',
+		// 		'named': 'always',
+		// 		'asyncArrow': 'always'
+		// 	}
+		// ],
 		'prefer-template': 'warn',
 		'prefer-spread': 'warn',
 		'no-useless-concat': 'warn',
@@ -60,7 +57,6 @@ module.exports = {
 				position: 'above',
 			},
 		],
-		quotes: ['error', 'single'],
 		yoda: 'warn',
 	},
 	'overrides': [

package/.github/workflows/node.js.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [16.x, 18.x]
 
     steps:
     - uses: actions/checkout@v2
@@ -34,10 +34,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@master
-    - name: Use Node.js 14.x
+    - name: Use Node.js 16.x
       uses: actions/setup-node@master
       with:
-        node-version: 14.x
+        node-version: 16.x
 
     - name: npm install
       run: npm install

package/lib/fields.d.ts

@@ -4,7 +4,7 @@ interface FieldDefinition {
 }
 export declare class FieldConstructor implements FieldDefinition {
     [SymbolInitialValue]: unknown;
-    get get(): (this: FieldDefinition) => unknown;
+    get get(): () => unknown;
     get set(): () => never;
     constructor(value: unknown);
     static get SymbolInitialValue(): symbol;

package/lib/index.d.ts

@@ -1,9 +1,8 @@
-declare const BaseConstructor: ObjectConstructor;
-export declare class BaseClass extends BaseConstructor {
+type Proto<P, T> = Pick<P, Exclude<keyof P, keyof T>> & T;
+export declare const BaseConstructorPrototype: <P extends object, S extends Proto<T, P>, T extends {
+    (): P;
+    new (): { [key in keyof S]: S[key]; };
+}>(this: T, InstanceTarget?: P) => T;
+export declare class BaseClass extends BaseConstructorPrototype {
 }
-export type IDEF<T, P = {}, R = {}> = {
-    new (...args: unknown[]): T;
-    (this: T, ...args: unknown[]): R;
-    prototype: P;
-};
-export {};
+export { FieldConstructor } from './fields';

package/lib/index.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseClass = void 0;
+exports.FieldConstructor = exports.BaseClass = exports.BaseConstructorPrototype = void 0;
 const errors_1 = require("./errors");
 const types_1 = require("./types");
 const fields_1 = require("./fields");
@@ -59,7 +59,8 @@ const handlers = {
         }
         if (prop === 'toJSON') {
             return function () {
-                return JSON.stringify(Object.entries(this).reduce((obj, [key, value]) => {
+                const entries = Object.entries(this);
+                return JSON.stringify(entries.reduce((obj, [key, value]) => {
                     obj[key] = value.valueOf();
                     return obj;
                 }, {}));
@@ -76,11 +77,11 @@ const handlers = {
     },
 };
 const BaseTarget = Object.create(null);
-const BaseConstructor = function (InstanceTarget = BaseTarget) {
+const BaseConstructorPrototype = function (InstanceTarget = BaseTarget) {
     if (!new.target) {
-        const self = BaseConstructor.bind(this, InstanceTarget);
+        const self = exports.BaseConstructorPrototype.bind(this, InstanceTarget);
         self.prototype = {
-            constructor: BaseConstructor
+            constructor: exports.BaseConstructorPrototype
         };
         return self;
     }
@@ -90,19 +91,22 @@ const BaseConstructor = function (InstanceTarget = BaseTarget) {
     do {
         protoPointer = Reflect.getPrototypeOf(protoPointer);
         protoConstrcutor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor').value;
-    } while (protoConstrcutor !== BaseConstructor);
+    } while (protoConstrcutor !== exports.BaseConstructorPrototype);
     Reflect.setPrototypeOf(protoPointer, InstancePrototype);
+    return this;
 };
+exports.BaseConstructorPrototype = BaseConstructorPrototype;
 Object.defineProperty(module, 'exports', {
     get() {
-        return BaseConstructor;
+        return exports.BaseConstructorPrototype;
     },
     enumerable: true
 });
-class BaseClass extends BaseConstructor {
+class BaseClass extends exports.BaseConstructorPrototype {
 }
 exports.BaseClass = BaseClass;
-;
+var fields_2 = require("./fields");
+Object.defineProperty(exports, "FieldConstructor", { enumerable: true, get: function () { return fields_2.FieldConstructor; } });
 Object.defineProperty(module.exports, 'BaseClass', {
     get() {
         return BaseClass;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typeomatica",
-	"version": "0.3.2",
+	"version": "0.3.3",
 	"description": "type logic against javascript metaprogramming",
 	"engines": {
 		"node": ">=14"
@@ -30,17 +30,18 @@
 		"url": "git+https://github.com/wentout/typeomatica.git"
 	},
 	"devDependencies": {
-		"@types/jest": "^29.5.3",
-		"@types/node": "^18.17.4",
-		"eslint": "^8.46.0",
+		"@types/jest": "^29.5.5",
+		"@types/node": "^18.18.4",
+		"@typescript-eslint/eslint-plugin": "^6.7.4",
+		"@typescript-eslint/parser": "^6.7.4",
+		"eslint": "^8.51.0",
 		"husky": "^8.0.3",
-		"jest": "^29.6.2",
+		"jest": "^29.7.0",
 		"json5": "^2.2.3",
-		"lint-staged": "^13.2.3",
+		"lint-staged": "^13.3.0",
 		"set-value": "^4.1.0",
 		"ts-jest": "^29.1.1",
 		"ts-node": "^10.9.1",
-		"typescript": "^5.1.6",
-		"yarn": "^2.4.3"
+		"typescript": "^5.2.2"
 	}
 }

package/src/fields.ts

@@ -1,6 +1,6 @@
 'use strict';
 
-import { ErrorsNames } from './errors'
+import { ErrorsNames } from './errors';
 
 const SymbolInitialValue = Symbol('Initial Value');
 
@@ -18,17 +18,17 @@ interface FieldDefinition  {
 // } as ObjectConstructor;
 
 export class FieldConstructor implements FieldDefinition {
-	[SymbolInitialValue]: unknown
+	[SymbolInitialValue]: unknown;
 	public get get () {
 		const self = this;
-		return function (this: FieldDefinition) {
+		return function (/* this: FieldDefinition */) {
 			return self[SymbolInitialValue];
-		}
+		};
 	}
 	public get set () {
 		return function () {
 			throw new TypeError(ErrorsNames.FORBIDDEN_RE);
-		}
+		};
 	}
 	constructor (value: unknown) {
 		this[SymbolInitialValue] = value;

package/src/index.ts

@@ -40,7 +40,7 @@ const resolver = Object.entries({
 				const result = handler.set(replacementValue);
 				return result;
 			}
-		}
+		};
 	};
 
 	return obj;
@@ -98,13 +98,15 @@ const handlers = {
 			return result;
 		}
 		if (prop === 'toJSON') {
+			// eslint-disable-next-line no-unused-vars
 			return function (this: typeof target) {
-				return JSON.stringify(Object.entries(this).reduce((obj, [key, value]) => {
+				const entries = Object.entries(this);
+				return JSON.stringify(entries.reduce((obj, [key, value]) => {
 					// @ts-ignore
 					obj[key] = value.valueOf();
 					return obj;
 				}, {}));
-			}
+			};
 		}
 		// @ts-ignore
 		if (props2skip.has(prop)) {
@@ -125,43 +127,72 @@ const handlers = {
 // user have to precisely define all props
 const BaseTarget = Object.create(null);
 
-// const BasePrototype = new Proxy(BaseTarget, handlers);
+type Proto<P, T> = Pick<P, Exclude<keyof P, keyof T>> & T;
 
-// @ts-ignore
-const BaseConstructor = function (this: object, InstanceTarget = BaseTarget) {
+
+export const BaseConstructorPrototype = function <
+	P extends object,
+	S extends Proto<T, P>,
+	T extends {
+		(): P
+		new (): {
+			[key in keyof S]: S[key]
+		}
+	},
+>(
+	this: T,
+	InstanceTarget: P = BaseTarget
+): T {
 	if (!new.target) {
-		const self = BaseConstructor.bind(this, InstanceTarget);
+
+		const self: {
+			prototype: {
+				constructor: typeof BaseConstructorPrototype
+			}
+		} = BaseConstructorPrototype.bind(this, InstanceTarget);
+
 		self.prototype = {
-			constructor: BaseConstructor
+			constructor: BaseConstructorPrototype
 		};
-		return self;
+
+		return self as T;
+
 	}
 
 	const InstancePrototype = new Proxy(InstanceTarget, handlers);
 
-	let protoPointer = this;
+	let protoPointer = this as object;
 	let protoConstrcutor;
 	do {
 		protoPointer = Reflect.getPrototypeOf(protoPointer) as object;
 		protoConstrcutor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor')!.value;
-	} while (protoConstrcutor !== BaseConstructor);
+	} while (protoConstrcutor !== BaseConstructorPrototype);
+
 	Reflect.setPrototypeOf(protoPointer, InstancePrototype);
+	return this;
 
-} as ObjectConstructor;
-// } as IDEF;
+};
 
-// Reflect.setPrototypeOf(BaseConstructor.prototype, BasePrototype);
+// as ObjectConstructor & {
+// 	(): void
+// 	// eslint-disable-next-line no-unused-vars
+// 	new<T>(param?: T extends object ? T : {}): {
+// 		[key in keyof T]: T[key]
+// 	}
+// };
 
 Object.defineProperty(module, 'exports', {
 	get() {
-		return BaseConstructor;
+		return BaseConstructorPrototype;
 	},
 	enumerable: true
 });
 
+
+// eslint-disable-next-line new-cap
 // @ts-ignore
-export class BaseClass extends BaseConstructor { };
-// export { FieldConstructor } from './fields';
+export class BaseClass extends BaseConstructorPrototype { }
+export { FieldConstructor } from './fields';
 
 Object.defineProperty(module.exports, 'BaseClass', {
 	get() {
@@ -175,10 +206,3 @@ Object.defineProperty(module.exports, 'FieldConstructor', {
 	},
 	enumerable: true
 });
-
-
-export type IDEF<T, P = {}, R = {}> = {
-	new(...args: unknown[]): T;
-	(this: T, ...args: unknown[]): R;
-	prototype: P;
-};

package/test/addition.js

@@ -2,42 +2,43 @@
 
 const BasePrototype = require('..');
 
+// eslint-disable-next-line new-cap
 class Base extends BasePrototype({
-    additionalProp: 321,
+	additionalProp: 321,
 }) {
-    numberValue = 123;
-    constructor() {
-        super();
-        this.stringValue = '123';
-        this.booleanValue = true;
-        this.objectValue = {};
-    }
-};
+	numberValue = 123;
+	constructor() {
+		super();
+		this.stringValue = '123';
+		this.booleanValue = true;
+		this.objectValue = {};
+	}
+}
 
 const baseInstance = new Base;
 
 describe('props tests', () => {
 
-    test('base instance has props', () => {
-        expect(Object.keys(baseInstance)).toEqual(["numberValue", "stringValue", "booleanValue", "objectValue"]);
-    });
-
-    test('JavaScript class fields allow re-definition', () => {
-        baseInstance.numberValue = '123';
-        expect(baseInstance.numberValue).toEqual('123');
-    });
-
-    test('everything the rest is the same', () => {
-        expect(baseInstance.additionalProp).toEqual(321);
-        expect(() => {
-            baseInstance.stringValue = 123;
-        }).toThrow(new TypeError('Type Mismatch'));
-        expect(() => {
-            baseInstance.booleanValue = 123;
-        }).toThrow(new TypeError('Type Mismatch'));
-        expect(() => {
-            baseInstance.objectValue = null;
-        }).toThrow(new TypeError('Type Mismatch'));
-    });
+	test('base instance has props', () => {
+		expect(Object.keys(baseInstance)).toEqual(['numberValue', 'stringValue', 'booleanValue', 'objectValue']);
+	});
+
+	test('JavaScript class fields allow re-definition', () => {
+		baseInstance.numberValue = '123';
+		expect(baseInstance.numberValue).toEqual('123');
+	});
+
+	test('everything the rest is the same', () => {
+		expect(baseInstance.additionalProp).toEqual(321);
+		expect(() => {
+			baseInstance.stringValue = 123;
+		}).toThrow(new TypeError('Type Mismatch'));
+		expect(() => {
+			baseInstance.booleanValue = 123;
+		}).toThrow(new TypeError('Type Mismatch'));
+		expect(() => {
+			baseInstance.objectValue = null;
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
 
 });

package/test/index.ts

@@ -5,15 +5,14 @@ import { describe, expect, test } from '@jest/globals';
 // BasePrototype & BaseClass are the same function
 // go as you want for being meaningfull
 // or meaningless
-
 const BasePrototype = require('..');
-// @ts-ignore
-import { BaseClass, IDEF, FieldConstructor } from '..';
+import { BaseClass, FieldConstructor } from '..';
 
 const { SymbolInitialValue } = FieldConstructor;
 
 interface IBase {
 	get getterField(): string
+	// eslint-disable-next-line no-unused-vars
 	set setterField(value: string)
 	numberValue: number
 	stringValue: string
@@ -21,6 +20,27 @@ interface IBase {
 	objectValue: object
 }
 
+let decoratedSomeProp = 0;
+// const s = BasePrototype({ someProp: 123 });
+// console.log(s);
+
+
+// eslint-disable-next-line new-cap
+@BasePrototype({ someProp: 123 })
+class DecoratedByBase {
+	someProp!: number;
+}
+
+class ExtendedDecoratedByBase extends DecoratedByBase {
+	someProp: number;
+	constructor() {
+		super();
+		this.someProp = 321;
+		decoratedSomeProp = this.someProp;
+	}
+}
+
+// eslint-disable-next-line new-cap
 class Base extends BasePrototype({
 	additionalProp: 321,
 	someMethod() {
@@ -28,9 +48,9 @@ class Base extends BasePrototype({
 	},
 }) implements IBase {
 	numberValue = 123;
-	stringValue: string
-	booleanValue: boolean
-	objectValue: object
+	stringValue: string;
+	booleanValue: boolean;
+	objectValue: object;
 
 	get getterField() {
 		const answer = `${this.stringValue}`;
@@ -46,6 +66,18 @@ class Base extends BasePrototype({
 		this.stringValue = '123';
 		this.booleanValue = true;
 		this.objectValue = {};
+		// ES2022
+		// Object.defineProperty(this, 'getterField', {
+		// 	get() {
+		// 		const answer = `${this.stringValue}`;
+		// 		return answer;
+		// 	}
+		// });
+		// Object.defineProperty(this, 'setterField', {
+		// 	set(value: string) {
+		// 		this.stringValue = value;
+		// 	}
+		// });
 	}
 }
 const baseInstance = new Base;
@@ -54,32 +86,45 @@ const upperInstance = Object.create(baseInstance);
 
 class SimpleBase extends BaseClass {
 	stringProp = '123';
-};
+	// ES2022
+	// stringProp: string;
+	// constructor() {
+	// 	super();
+	// 	this.stringProp = '123';
+	// }
+}
 const simpleInstance = new SimpleBase;
 
-type MyFunctionalConstructorInstance = {
-	stringProp: string
-};
+interface IFCstr<S> {
+	(): void
+	new(): {
+		[key in keyof S]: S[key]
+	}
+}
 
-const MyFunctionalConstructor = function () {
-	// @ts-ignore
+type TmyFunctionalInstance = { stringProp: string }
+// eslint-disable-next-line no-unused-vars
+const MyFunctionalConstructor = function (this: TmyFunctionalInstance) {
 	this.stringProp = '123';
-} as IDEF<MyFunctionalConstructorInstance>;
+} as IFCstr<TmyFunctionalInstance>;
 
 Reflect.setPrototypeOf(MyFunctionalConstructor.prototype, new BasePrototype);
 
 const myFunctionalInstance = new MyFunctionalConstructor();
 
-class SecondaryExtend extends Base { second = 123 };
-class TripleExtend extends SecondaryExtend { };
+class SecondaryExtend extends Base { second = 123; }
+class TripleExtend extends SecondaryExtend { }
 const tiripleExtendInstance = new TripleExtend;
 
-class NetworkedExtention extends BasePrototype(tiripleExtendInstance) { };
+// eslint-disable-next-line new-cap
+class NetworkedExtention extends BasePrototype(tiripleExtendInstance) { }
 
 const networkedInstance = new NetworkedExtention;
 
-class ExtendedArray extends BasePrototype([1, 2, 3]) { };
-class ExtendedSet extends BasePrototype(new Set([1, 2, 3])) { };
+// eslint-disable-next-line new-cap
+class ExtendedArray extends BasePrototype([1, 2, 3]) { }
+// eslint-disable-next-line new-cap
+class ExtendedSet extends BasePrototype(new Set([1, 2, 3])) { }
 
 const extendedArrayInstance = new ExtendedArray;
 const extendedSetInstance = new ExtendedSet;
@@ -88,7 +133,7 @@ const MUTATION_VALUE = -2;
 
 
 class MyFieldConstructorNoRe extends FieldConstructor {
-	_value: string
+	_value: string;
 	constructor(value: string) {
 		super(value);
 		Reflect.defineProperty(this, 'enumerable', {
@@ -108,7 +153,7 @@ class MyFieldConstructorReGet extends MyFieldConstructorNoRe {
 			get() {
 				return function () {
 					return self._value;
-				}
+				};
 			},
 			enumerable: true
 		});
@@ -123,9 +168,9 @@ class MyFieldConstructorReSet extends MyFieldConstructorNoRe {
 		});
 		Reflect.defineProperty(this, 'set', {
 			get() {
-				return function (value: string) {
-					self._value = value;
-				}
+				return function (_value: string) {
+					self._value = _value;
+				};
 			},
 			enumerable: true
 		});
@@ -140,9 +185,9 @@ class MyFieldConstructor extends MyFieldConstructorReGet {
 		});
 		Reflect.defineProperty(this, 'set', {
 			get() {
-				return function (value: string) {
-					self._value = value;
-				}
+				return function (_value: string) {
+					self._value = _value;
+				};
 			},
 			enumerable: true
 		});
@@ -154,35 +199,49 @@ const myFieldReGet = new MyFieldConstructorReGet('initial value for get check');
 const myFieldReSet = new MyFieldConstructorReSet('initial value for set check');
 
 class MadeFieldClass extends BaseClass {
-	myField = myField as unknown | string
-	get [SymbolInitialValue] () {
+	myField = myField as unknown | string;
+	get [SymbolInitialValue]() {
 		const self = this;
 		return (fieldName: 'myField') => {
 			if (fieldName !== 'myField') {
 				return self[fieldName];
 			}
-			// @ts-ignore
+			//@ts-ignore
 			const answer = myField[SymbolInitialValue];
-			return  answer;
+			return answer;
 		};
 	}
-};
-class SecondMadeFieldClass extends BaseClass { myField = myField as unknown | string };
+}
+class SecondMadeFieldClass extends BaseClass { myField = myField as unknown | string; }
 const madeFieldInstance = new MadeFieldClass;
 const secondMadeFieldInstance = new MadeFieldClass;
 const thirdMadeFieldInstance = 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; }
+class MadeReSet extends BaseClass { myField = myFieldReSet as unknown | string; }
 const madeReGet = new MadeReGet;
 const madeReSet = new MadeReSet;
 
 describe('props tests', () => {
 
+	test('decorators works', () => {
+		const rgp = Reflect.getPrototypeOf;
+		// eslint-disable-next-line no-debugger
+		// debugger;
+		const decorated = new DecoratedByBase;
+		const exdecorated = new ExtendedDecoratedByBase;
+		expect(decoratedSomeProp.valueOf()).toEqual(321);
+		expect(exdecorated.someProp.valueOf()).toEqual(321);
+		expect(decorated.someProp.valueOf()).toEqual(123);
+		const proto = rgp(decorated);
+		//@ts-ignore;
+		expect(proto.someProp).toEqual(123);
+	});
+
 	test('base instance has props', () => {
-		var gf: string;
-		var sv: string;
-		expect(Object.keys(baseInstance)).toEqual(["numberValue", "stringValue", "booleanValue", "objectValue"]);
+		let gf: string;
+		let sv: string;
+		expect(Object.keys(baseInstance)).toEqual(['numberValue', 'stringValue', 'booleanValue', 'objectValue']);
 
 		gf = baseInstance.getterField;
 		expect(gf).toEqual('123');
@@ -213,6 +272,8 @@ describe('props tests', () => {
 		expect(/String$/.test(simpleInstance.stringProp.constructor.name)).toBe(true);
 		expect(() => {
 
+			// eslint-disable-next-line no-debugger
+			debugger;
 			// @ts-ignore
 			simpleInstance.stringProp = 123;
 
@@ -310,15 +371,15 @@ describe('props tests', () => {
 	test('takes error on wrong field definition', () => {
 		expect(() => {
 			class WrongFieldConstructor extends FieldConstructor {
-				value: number
+				value: number;
 				constructor(value: number) {
-					super(value)
+					super(value);
 					this.value = value;
 				}
 			}
 			const wrongField = new WrongFieldConstructor(123);
 			class WithWrongField extends BaseClass {
-				erroredField = wrongField
+				erroredField = wrongField;
 			}
 			new WithWrongField;
 
@@ -336,7 +397,7 @@ describe('props tests', () => {
 		// @ts-ignore
 		const inspected = util.inspect(madeFieldInstance);
 		const expected = 'MadeFieldClass { myField: [Getter/Setter] }';
-		expect(expected).toEqual(expected);
+		expect(inspected).toEqual(expected);
 	});
 
 	test('wrong assignment to objects', () => {
@@ -619,4 +680,4 @@ describe('deep extend works', () => {
 		}).toThrow(new TypeError('Method Set.prototype.has called on incompatible receiver [object Object]'));
 
 	});
-});
+});

package/tsconfig.jest.json

@@ -35,4 +35,4 @@
 		"./coverage/**/*",
 		"./node_modules/**/*",
 	]
-}
+}