typeomatica 0.2.9 → 0.3.0

package/lib/fields.d.ts

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

package/lib/fields.js

@@ -1,16 +1,13 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldConstructor = exports.SymbolInitialValue = void 0;
-exports.SymbolInitialValue = Symbol('Initial Value');
+exports.FieldConstructor = void 0;
 const errors_1 = require("./errors");
+const SymbolInitialValue = Symbol('Initial Value');
 class FieldConstructor {
-    constructor(value) {
-        this[exports.SymbolInitialValue] = value;
-    }
     get get() {
         const self = this;
         return function () {
-            return self[exports.SymbolInitialValue];
+            return self[SymbolInitialValue];
         };
     }
     get set() {
@@ -18,6 +15,12 @@ class FieldConstructor {
             throw new TypeError(errors_1.ErrorsNames.FORBIDDEN_RE);
         };
     }
+    constructor(value) {
+        this[SymbolInitialValue] = value;
+    }
+    static get SymbolInitialValue() {
+        return SymbolInitialValue;
+    }
 }
 exports.FieldConstructor = FieldConstructor;
 Object.freeze(FieldConstructor.prototype);

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 declare const BaseConstructor: ObjectConstructor;
 export declare class BaseClass extends BaseConstructor {
 }
-export declare type IDEF<T, P = {}, R = {}> = {
+export type IDEF<T, P = {}, R = {}> = {
     new (...args: unknown[]): T;
     (this: T, ...args: unknown[]): R;
     prototype: P;

package/lib/index.js

@@ -19,14 +19,16 @@ const resolver = Object.entries({
                 if (invocationThis !== receiver) {
                     throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
                 }
-                return handler.get();
+                const result = handler.get();
+                return result;
             },
             set(replacementValue) {
                 const invocationThis = this;
                 if (invocationThis !== receiver) {
                     throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
                 }
-                return handler.set(replacementValue);
+                const result = handler.set(replacementValue);
+                return result;
             }
         };
     };
@@ -42,13 +44,8 @@ const createProperty = (propName, initialValue, receiver) => {
     const descriptor = (isObject && (value instanceof fields_1.FieldConstructor)) ?
         value
         : Object.assign({ enumerable: true }, resolver[type](value, receiver));
-    try {
-        const result = Reflect.defineProperty(receiver, propName, descriptor);
-        return result;
-    }
-    catch (error) {
-        throw error;
-    }
+    const result = Reflect.defineProperty(receiver, propName, descriptor);
+    return result;
 };
 const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);
 const util = require('util');
@@ -81,11 +78,11 @@ const handlers = {
 const BaseTarget = Object.create(null);
 const BaseConstructor = function (InstanceTarget = BaseTarget) {
     if (!new.target) {
-        const constructor = BaseConstructor.bind(this, InstanceTarget);
-        constructor.prototype = {
+        const self = BaseConstructor.bind(this, InstanceTarget);
+        self.prototype = {
             constructor: BaseConstructor
         };
-        return constructor;
+        return self;
     }
     const InstancePrototype = new Proxy(InstanceTarget, handlers);
     let protoPointer = this;

package/lib/types/primitives.js

@@ -25,7 +25,8 @@ const primitives = (initialValue) => {
                     if (value[prop] instanceof Function) {
                         return value[prop].bind(value);
                     }
-                    return value[prop];
+                    const answer = value[prop];
+                    return answer;
                 }
             });
             return proxyAsValue;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typeomatica",
-	"version": "0.2.9",
+	"version": "0.3.0",
 	"description": "type logic against javascript metaprogramming",
 	"engines": {
 		"node": ">=14"
@@ -30,16 +30,16 @@
 		"url": "git+https://github.com/wentout/typeomatica.git"
 	},
 	"devDependencies": {
-		"@types/jest": "^29.2.5",
-		"@types/node": "^18.11.18",
-		"eslint": "^8.31.0",
+		"@types/jest": "^29.5.0",
+		"@types/node": "^18.15.5",
+		"eslint": "^8.36.0",
 		"husky": "^8.0.3",
-		"jest": "^29.3.1",
+		"jest": "^29.5.0",
 		"json5": "^2.2.3",
-		"lint-staged": "^13.1.0",
+		"lint-staged": "^13.2.0",
 		"set-value": "^4.1.0",
-		"ts-jest": "^29.0.3",
+		"ts-jest": "^29.0.5",
 		"ts-node": "^10.9.1",
-		"typescript": "^4.9.4"
+		"typescript": "^5.0.2"
 	}
 }

package/src/fields.ts

@@ -1,9 +1,9 @@
 'use strict';
 
-export const SymbolInitialValue = Symbol('Initial Value');
-
 import { ErrorsNames } from './errors'
 
+const SymbolInitialValue = Symbol('Initial Value');
+
 interface FieldDefinition  {
 	[SymbolInitialValue]: unknown
 	// get?: unknown
@@ -33,6 +33,9 @@ export class FieldConstructor implements FieldDefinition {
 	constructor (value: unknown) {
 		this[SymbolInitialValue] = value;
 	}
+	static get SymbolInitialValue () {
+		return SymbolInitialValue;
+	}
 }
 
 // Object.assign(FieldConstructor.prototype, {

package/src/index.ts

@@ -29,14 +29,16 @@ const resolver = Object.entries({
 				if (invocationThis !== receiver) {
 					throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
 				}
-				return handler.get();
+				const result = handler.get();
+				return result;
 			},
 			set(replacementValue: unknown) {
 				const invocationThis = this;
 				if (invocationThis !== receiver) {
 					throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
 				}
-				return handler.set(replacementValue);
+				const result = handler.set(replacementValue);
+				return result;
 			}
 		}
 	};
@@ -79,13 +81,8 @@ const createProperty = (propName: string, initialValue: unknown, receiver: objec
 	// 	debugger;
 	// }
 
-	try {
-		const result = Reflect.defineProperty(receiver, propName, descriptor);
-		return result;
-	} catch (error) {
-		// debugger;
-		throw error;
-	}
+	const result = Reflect.defineProperty(receiver, propName, descriptor);
+	return result;
 
 };
 
@@ -133,11 +130,11 @@ const BaseTarget = Object.create(null);
 // @ts-ignore
 const BaseConstructor = function (this: object, InstanceTarget = BaseTarget) {
 	if (!new.target) {
-		const constructor = BaseConstructor.bind(this, InstanceTarget);
-		constructor.prototype = {
+		const self = BaseConstructor.bind(this, InstanceTarget);
+		self.prototype = {
 			constructor: BaseConstructor
 		};
-		return constructor;
+		return self;
 	}
 
 	const InstancePrototype = new Proxy(InstanceTarget, handlers);

package/src/types/primitives.ts

@@ -31,7 +31,8 @@ export const primitives = (initialValue: object) => {
 						return value[prop].bind(value);
 					}
 
-					return value[prop];
+					const answer = value[prop];
+					return answer;
 				}
 			});
 			return proxyAsValue;

package/test/index.ts

@@ -10,16 +10,31 @@ const BasePrototype = require('..');
 // @ts-ignore
 import { BaseClass, IDEF, FieldConstructor } from '..';
 
+const { SymbolInitialValue } = FieldConstructor;
+
+interface IBase {
+	get getterField(): string
+	set setterField(value: string)
+	numberValue: number
+	stringValue: string
+	booleanValue: boolean
+	objectValue: object
+}
+
 class Base extends BasePrototype({
 	additionalProp: 321,
 	someMethod() {
 		return this.numberValue.valueOf();
 	},
-}) {
+}) implements IBase {
 	numberValue = 123;
+	stringValue: string
+	booleanValue: boolean
+	objectValue: object
 
 	get getterField() {
-		return '123';
+		const answer = `${this.stringValue}`;
+		return answer;
 	}
 
 	set setterField(value: string) {
@@ -138,7 +153,20 @@ const myField = new MyFieldConstructor('initial value');
 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 };
+class MadeFieldClass extends BaseClass {
+	myField = myField as unknown | string
+	get [SymbolInitialValue] () {
+		const self = this;
+		return (fieldName: 'myField') => {
+			if (fieldName !== 'myField') {
+				return self[fieldName];
+			}
+			// @ts-ignore
+			const answer = myField[SymbolInitialValue];
+			return  answer;
+		};
+	}
+};
 class SecondMadeFieldClass extends BaseClass { myField = myField as unknown | string };
 const madeFieldInstance = new MadeFieldClass;
 const secondMadeFieldInstance = new MadeFieldClass;
@@ -152,12 +180,36 @@ const madeReSet = new MadeReSet;
 describe('props tests', () => {
 
 	test('base instance has props', () => {
+		var gf: string;
+		var sv: string;
 		expect(Object.keys(baseInstance)).toEqual(["numberValue", "stringValue", "booleanValue", "objectValue"]);
+
+		gf = baseInstance.getterField;
+		expect(gf).toEqual('123');
+		sv = baseInstance.stringValue;
+		expect(sv.valueOf()).toEqual('123');
+
+
+		baseInstance.setterField = '12345';
+
+		gf = baseInstance.getterField;
+		expect(gf).toEqual('12345');
+		sv = baseInstance.stringValue;
+		expect(sv.valueOf()).toEqual('12345');
+
+		baseInstance.setterField = '123';
+
+		gf = baseInstance.getterField;
+		expect(gf).toEqual('123');
+		sv = baseInstance.stringValue;
+		expect(`${sv}`).toEqual('123');
 	});
 
 	test('simple instance works & strings too', () => {
 		expect(simpleInstance.stringProp.toString()).toBe('123');
 		expect(simpleInstance.stringProp.length).toBe(3);
+
+
 		expect(/String$/.test(simpleInstance.stringProp.constructor.name)).toBe(true);
 		expect(() => {
 
@@ -179,6 +231,7 @@ describe('props tests', () => {
 	test('fails boolean arithmetics', () => {
 		expect(() => {
 
+			// @ts-ignore
 			baseInstance.booleanValue + 5;
 
 		}).toThrow(new ReferenceError('Value Access Denied'));
@@ -191,12 +244,13 @@ describe('props tests', () => {
 
 		// warning!
 		// booleanValue does not rely on baseInstance anymore!
+		// @ts-ignore
 		booleanValue = new Boolean(false);
 
 		let value = baseInstance.booleanValue.valueOf();
 		expect(value).toEqual(true);
 
-
+		// @ts-ignore
 		baseInstance.booleanValue = new Boolean(false);
 		value = baseInstance.booleanValue.valueOf();
 		expect(value).toEqual(false);
@@ -214,6 +268,7 @@ describe('props tests', () => {
 
 	test('correct object assignment', () => {
 		baseInstance.objectValue = { a: 123 };
+		// @ts-ignore
 		expect(baseInstance.objectValue.a).toEqual(123);
 	});
 
@@ -222,6 +277,17 @@ describe('props tests', () => {
 	});
 
 	test('correct custom field assignment', () => {
+		madeFieldInstance.myField = 'replaced';
+		// @ts-ignore
+		const initialValue = madeFieldInstance[SymbolInitialValue]('myField');
+		expect(initialValue).toEqual('initial value');
+		expect(secondMadeFieldInstance.myField).toEqual('replaced');
+		expect(thirdMadeFieldInstance.myField).toEqual('replaced');
+
+		madeFieldInstance.myField = 'replaced secondary';
+		expect(secondMadeFieldInstance.myField).toEqual('replaced secondary');
+		expect(thirdMadeFieldInstance.myField).toEqual('replaced secondary');
+
 		madeFieldInstance.myField = 'replaced';
 		expect(secondMadeFieldInstance.myField).toEqual('replaced');
 		expect(thirdMadeFieldInstance.myField).toEqual('replaced');
@@ -276,7 +342,7 @@ describe('props tests', () => {
 	test('wrong assignment to objects', () => {
 
 		expect(() => {
-
+			// @ts-ignore
 			baseInstance.objectValue = 123;
 
 		}).toThrow(new TypeError('Type Mismatch'));
@@ -321,7 +387,7 @@ describe('props tests', () => {
 
 	test('wrong assignment', () => {
 		expect(() => {
-
+			// @ts-ignore
 			baseInstance.booleanValue = 123;
 
 		}).toThrow(new TypeError('Type Mismatch'));

package/tsconfig.jest.json

@@ -28,7 +28,11 @@
 		]
 	},
 	"include": [
-		"./src/**/*.ts",
-		"./test/**/*"
+		"./test/**/*.ts"
+	],
+	"exclude": [
+		"./lib/**/*",
+		"./coverage/**/*",
+		"./node_modules/**/*",
 	]
 }