typeomatica 0.2.3 → 0.2.8

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm test

package/jest.config.js

@@ -4,7 +4,7 @@ module.exports = {
 	testMatch: ['**/test/**/index.ts', '**/test/**/addition.js'],
 	globals: {
 		'ts-jest': {
-			tsconfig: './tsconfig.spec.json'
+			tsconfig: './test/tsconfig.json'
 		}
 	},
 };

package/lib/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const ErrorsNames: {
+    TYPE_MISMATCH: string;
+    ACCESS_DENIED: string;
+    MISSING_PROP: string;
+    RIP_FUNCTIONS: string;
+    FORBIDDEN_RE: string;
+};

package/lib/errors.js

@@ -0,0 +1,10 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorsNames = void 0;
+exports.ErrorsNames = {
+    TYPE_MISMATCH: 'Type Mismatch',
+    ACCESS_DENIED: 'Value Access Denied',
+    MISSING_PROP: 'Attempt to Access to Undefined Prop',
+    RIP_FUNCTIONS: 'Functions are Restricted',
+    FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
+};

package/lib/fields.d.ts

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

package/lib/fields.js

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

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,113 +1,15 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseClass = void 0;
-const ErrorsNames = {
-    TYPE_MISMATCH: 'Type Mismatch',
-    ACCESS_DENIED: 'Value Access Denied',
-    MISSING_PROP: 'Attempt to Access to Undefined Prop',
-    RIP_FUNCTIONS: 'Functions are Restricted'
-};
-const PRIMITIVE_TYPES = [
-    'string',
-    'number',
-    'boolean',
-];
-const isPrimitive = (value) => {
-    return PRIMITIVE_TYPES.includes(typeof value);
-};
-const primitives = (initialValue) => {
-    let value = Object(initialValue);
-    const initialType = typeof initialValue;
-    return {
-        get() {
-            const proxyAsValue = new Proxy(value, {
-                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();
-                        };
-                    }
-                    if (value[prop] instanceof Function) {
-                        return value[prop].bind(value);
-                    }
-                    return value[prop];
-                }
-            });
-            return proxyAsValue;
-        },
-        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;
-        }
-    };
-};
-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;
-        }
-    };
-};
-const nullish = (value) => {
-    return {
-        get() {
-            return value;
-        },
-        set() {
-            const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
-            throw error;
-        }
-    };
-};
-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;
-        }
-    };
-};
-const functions = () => {
-    throw new TypeError(ErrorsNames.RIP_FUNCTIONS);
-};
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const fields_1 = require("./fields");
 const resolver = Object.entries({
-    primitives,
-    special,
-    nullish,
-    objects,
-    functions
+    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);
@@ -115,14 +17,14 @@ const resolver = Object.entries({
             get() {
                 const invocationThis = this;
                 if (invocationThis !== receiver) {
-                    throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
+                    throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
                 }
                 return handler.get();
             },
             set(replacementValue) {
                 const invocationThis = this;
                 if (invocationThis !== receiver) {
-                    throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
+                    throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
                 }
                 return handler.set(replacementValue);
             }
@@ -132,15 +34,26 @@ const resolver = Object.entries({
 }, {});
 const createProperty = (propName, initialValue, receiver) => {
     const value = initialValue;
-    const valueIsPrimitive = isPrimitive(initialValue);
+    const valueIsPrimitive = (0, types_1.isPrimitive)(initialValue);
     const isObject = typeof initialValue === 'object';
     const isFunction = initialValue instanceof Function;
     const isNull = initialValue === null;
     const type = valueIsPrimitive ? 'primitives' : (isObject ? (isNull ? 'nullish' : 'objects') : (isFunction ? 'functions' : 'special'));
-    const descriptor = resolver[type](value, receiver);
-    const result = Reflect.defineProperty(receiver, propName, Object.assign(Object.assign({}, descriptor), { enumerable: true }));
-    return result;
+    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 props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);
+const util = require('util');
+const hasNodeInspect = (util && util.inspect && util.inspect.custom);
+hasNodeInspect && (props2skip.add(util.inspect.custom));
 const handlers = {
     get(target, prop, receiver) {
         const result = Reflect.get(target, prop, receiver);
@@ -155,7 +68,10 @@ const handlers = {
                 }, {}));
             };
         }
-        throw new Error(`${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ]`);
+        if (props2skip.has(prop)) {
+            return undefined;
+        }
+        throw new Error(`${errors_1.ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] of ${receiver.constructor.name}`);
     },
     set(_, prop, value, receiver) {
         const result = createProperty(prop, value, receiver);
@@ -196,3 +112,9 @@ Object.defineProperty(module.exports, 'BaseClass', {
     },
     enumerable: true
 });
+Object.defineProperty(module.exports, 'FieldConstructor', {
+    get() {
+        return fields_1.FieldConstructor;
+    },
+    enumerable: true
+});

package/lib/types/functions.d.ts

@@ -0,0 +1 @@
+export declare const functions: () => never;

package/lib/types/functions.js

@@ -0,0 +1,8 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functions = void 0;
+const errors_1 = require("../errors");
+const functions = () => {
+    throw new TypeError(errors_1.ErrorsNames.RIP_FUNCTIONS);
+};
+exports.functions = functions;

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export { functions } from './functions';
+export { nullish } from './nullish';
+export { objects } from './objects';
+export { primitives } from './primitives';
+export { special } from './special';
+export declare const isPrimitive: (value: unknown) => boolean;

package/lib/types/index.js

@@ -0,0 +1,22 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitive = exports.special = exports.primitives = exports.objects = exports.nullish = exports.functions = void 0;
+var functions_1 = require("./functions");
+Object.defineProperty(exports, "functions", { enumerable: true, get: function () { return functions_1.functions; } });
+var nullish_1 = require("./nullish");
+Object.defineProperty(exports, "nullish", { enumerable: true, get: function () { return nullish_1.nullish; } });
+var objects_1 = require("./objects");
+Object.defineProperty(exports, "objects", { enumerable: true, get: function () { return objects_1.objects; } });
+var primitives_1 = require("./primitives");
+Object.defineProperty(exports, "primitives", { enumerable: true, get: function () { return primitives_1.primitives; } });
+var special_1 = require("./special");
+Object.defineProperty(exports, "special", { enumerable: true, get: function () { return special_1.special; } });
+const PRIMITIVE_TYPES = [
+    'string',
+    'number',
+    'boolean',
+];
+const isPrimitive = (value) => {
+    return PRIMITIVE_TYPES.includes(typeof value);
+};
+exports.isPrimitive = isPrimitive;

package/lib/types/nullish.d.ts

@@ -0,0 +1,4 @@
+export declare const nullish: (value: object) => {
+    get(): object;
+    set(): never;
+};

package/lib/types/nullish.js

@@ -0,0 +1,16 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nullish = void 0;
+const errors_1 = require("../errors");
+const nullish = (value) => {
+    return {
+        get() {
+            return value;
+        },
+        set() {
+            const error = new TypeError(errors_1.ErrorsNames.TYPE_MISMATCH);
+            throw error;
+        }
+    };
+};
+exports.nullish = nullish;

package/lib/types/objects.d.ts

@@ -0,0 +1,4 @@
+export declare const objects: (value: object) => {
+    get(): object;
+    set(replacementValue: unknown): object;
+};

package/lib/types/objects.js

@@ -0,0 +1,20 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objects = void 0;
+const errors_1 = require("../errors");
+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_1.ErrorsNames.TYPE_MISMATCH);
+            throw error;
+        }
+    };
+};
+exports.objects = objects;

package/lib/types/primitives.d.ts

@@ -0,0 +1,4 @@
+export declare const primitives: (initialValue: object) => {
+    get(): any;
+    set(replacementValue: unknown): any;
+};

package/lib/types/primitives.js

@@ -0,0 +1,48 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitives = void 0;
+const errors_1 = require("../errors");
+const primitives = (initialValue) => {
+    let value = Object(initialValue);
+    const initialType = typeof initialValue;
+    return {
+        get() {
+            const proxyAsValue = new Proxy(value, {
+                get(_, prop) {
+                    if (prop === Symbol.toPrimitive) {
+                        return function (hint) {
+                            if (hint !== initialType) {
+                                throw new ReferenceError(errors_1.ErrorsNames.ACCESS_DENIED);
+                            }
+                            return value.valueOf();
+                        };
+                    }
+                    if (prop === 'valueOf') {
+                        return function () {
+                            return value.valueOf();
+                        };
+                    }
+                    if (value[prop] instanceof Function) {
+                        return value[prop].bind(value);
+                    }
+                    return value[prop];
+                }
+            });
+            return proxyAsValue;
+        },
+        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_1.ErrorsNames.TYPE_MISMATCH);
+            throw error;
+        }
+    };
+};
+exports.primitives = primitives;

package/lib/types/special.d.ts

@@ -0,0 +1,4 @@
+export declare const special: (value: object) => {
+    get(): object;
+    set(replacementValue: object): object;
+};

package/lib/types/special.js

@@ -0,0 +1,20 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.special = void 0;
+const errors_1 = require("../errors");
+const special = (value) => {
+    return {
+        get() {
+            return value;
+        },
+        set(replacementValue) {
+            if (typeof replacementValue === typeof value) {
+                value = replacementValue;
+                return value;
+            }
+            const error = new TypeError(errors_1.ErrorsNames.TYPE_MISMATCH);
+            throw error;
+        }
+    };
+};
+exports.special = special;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typeomatica",
-	"version": "0.2.3",
+	"version": "0.2.8",
 	"description": "type logic against javascript metaprogramming",
 	"main": "lib/index.js",
 	"scripts": {
@@ -9,7 +9,9 @@
 		"lint": "npx eslint --fix --ignore-path .gitignore ./lib",
 		"test": "npx jest",
 		"test:cov": "npx jest --collectCoverage",
-		"debug": "npx --node-arg=--inspect-brk jest"
+		"debug": "node --inspect-brk ./node_modules/jest/bin/jest.js --runInBand",
+		"debug:old": "npx --node-options=--inspect-brk jest",
+		"prepare": "husky install"
 	},
 	"keywords": [
 		"strict",
@@ -25,16 +27,16 @@
 		"url": "git+https://github.com/wentout/typeomatica.git"
 	},
 	"devDependencies": {
-		"@types/jest": "^26.0.23",
-		"@types/node": "^14.14.44",
-		"eslint": "^7.26.0",
-		"husky": "^3.1.0",
-		"jest": "^26.6.3",
-		"lint-staged": "^10.5.4",
-		"ts-jest": "^26.5.6",
-		"ts-node": "^9.1.1",
+		"@types/jest": "^27.0.1",
+		"@types/node": "^16.9.2",
+		"eslint": "^7.32.0",
+		"husky": "^8.0.0",
+		"jest": "^27.2.0",
+		"lint-staged": "^11.1.2",
+		"set-value": "^4.1.0",
+		"ts-jest": "^27.0.5",
+		"ts-node": "^10.2.1",
 		"tslint": "^6.1.3",
-		"typescript": "^4.2.4",
-		"typologica": "0.0.77"
+		"typescript": "^4.4.3"
 	}
 }

package/src/errors.ts

@@ -0,0 +1,9 @@
+'use strict';
+
+export const ErrorsNames = {
+	TYPE_MISMATCH: 'Type Mismatch',
+	ACCESS_DENIED: 'Value Access Denied',
+	MISSING_PROP: 'Attempt to Access to Undefined Prop',
+	RIP_FUNCTIONS: 'Functions are Restricted',
+	FORBIDDEN_RE: 'Re-Assirnment is Forbidden'
+};

package/src/fields.ts

@@ -0,0 +1,73 @@
+'use strict';
+
+export const SymbolInitialValue = Symbol('Initial Value');
+
+import { ErrorsNames } from './errors'
+
+interface FieldDefinition  {
+	[SymbolInitialValue]: unknown
+	// get?: unknown
+	// set?: unknown
+	// configurable: boolean,
+	// enumerable: boolean,
+	// writable: boolean
+}
+
+// export const FieldConstructor = function (this: FieldDefinition, value: unknown) {
+// 	this[SymbolInitialValue] = value;
+// } as ObjectConstructor;
+
+export class FieldConstructor implements FieldDefinition {
+	[SymbolInitialValue]: unknown
+	public get get () {
+		const self = this;
+		return function (this: FieldDefinition) {
+			return self[SymbolInitialValue];
+		}
+	}
+	public get set () {
+		return function () {
+			throw new TypeError(ErrorsNames.FORBIDDEN_RE);
+		}
+	}
+	constructor (value: unknown) {
+		this[SymbolInitialValue] = value;
+	}
+}
+
+// Object.assign(FieldConstructor.prototype, {
+// 	configurable: false,
+// 	enumerable: false,
+// 	// writable: false
+// })
+
+// Object.defineProperty(FieldConstructor.prototype, 'get', {
+// 	get() {
+// 		return this[symbolValue];
+// 	},
+// 	// @ts-ignore
+// 	set(value: unknown) {
+// 		throw new Error('broken behaviour: assignment to getter');
+// 	},
+// 	configurable: false,
+// 	enumerable: true,
+// 	// writable: false
+// });
+
+// Object.defineProperty(FieldConstructor.prototype, 'set', {
+// 	get() {
+// 		return function (this: FieldDefinition, value: unknown) {
+// 			this[symbolValue] = value;
+// 		}
+// 	},
+// 	// @ts-ignore
+// 	set(value: unknown) {
+// 		throw new Error('broken behaviour: assignment to setter');
+// 	},
+// 	configurable: false,
+// 	enumerable: true,
+// 	// writable: false
+// });
+
+Object.freeze(FieldConstructor.prototype);
+Object.seal(FieldConstructor.prototype);

package/src/index.ts

@@ -1,136 +1,17 @@
 'use strict';
 
-const ErrorsNames = {
-	TYPE_MISMATCH: 'Type Mismatch',
-	ACCESS_DENIED: 'Value Access Denied',
-	MISSING_PROP: 'Attempt to Access to Undefined Prop',
-	RIP_FUNCTIONS: 'Functions are Restricted'
-};
-
-const PRIMITIVE_TYPES = [
-	'string',
-	'number',
-	'boolean',
-];
-
-const isPrimitive = (value: unknown) => {
-	return PRIMITIVE_TYPES.includes(typeof value);
-};
-
-const primitives = (initialValue: object) => {
-	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: string) {
-							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);
-					}
-
-					return value[prop];
-				}
-			});
-			return proxyAsValue;
-		},
-		// get() {
-		// 	const preparedValue = {
-		// 		[Symbol.toPrimitive]() {
-		// 			return function () {
-		// 				throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
-		// 			};
-		// 		}
-		// 	};
-		// 	Reflect.setPrototypeOf(preparedValue, value);
-		// 	debugger;
-		// 	return preparedValue;
-		// },
-		set(replacementValue: unknown) {
-			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;
-		}
-	};
-};
-
-const special = (value: object) => {
-	return {
-		get() {
-			return value;
-		},
-		set(replacementValue: object) {
-			if (typeof replacementValue === typeof value) {
-				value = replacementValue;
-				return value;
-
-			}
-			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
-			throw error;
-		}
-	}
-};
-
-const nullish = (value: object) => {
-	return {
-		get() {
-			return value;
-		},
-		set() {
-			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
-			throw error;
-		}
-	}
-};
+import { ErrorsNames } from './errors';
 
-const objects = (value: object) => {
-	return {
-		get() {
-			return value;
-		},
-		set(replacementValue: unknown) {
-			if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) {
-				value = replacementValue;
-				return value;
-			}
-			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
-			throw error;
-		}
-	}
-};
+import {
+	functions,
+	nullish,
+	objects,
+	primitives,
+	special,
+	isPrimitive
+} from './types';
 
-const functions = () => {
-	throw new TypeError(ErrorsNames.RIP_FUNCTIONS);
-};
+import { FieldConstructor } from './fields';
 
 const resolver = Object.entries({
 	primitives,
@@ -163,7 +44,8 @@ const resolver = Object.entries({
 	return obj;
 }, {});
 
-const createProperty = (propName: string, initialValue: any, receiver: object) => {
+
+const createProperty = (propName: string, initialValue: unknown, receiver: object) => {
 
 	const value = initialValue;
 	const valueIsPrimitive = isPrimitive(initialValue);
@@ -171,23 +53,47 @@ const createProperty = (propName: string, initialValue: any, receiver: object) =
 	const isFunction = initialValue instanceof Function;
 	const isNull = initialValue === null;
 
+	/**
+	 * special: undefined or BigInt or Symbol
+	 * 	or other non constructible type
+	 */
+
 	const type = valueIsPrimitive ? 'primitives' : (
 		isObject ? (
 			isNull ? 'nullish' : 'objects'
 		) : (
-			isFunction ? 'functions' : 'special'));
+			isFunction ? 'functions' : 'special'
+		)
+	);
+
+	const descriptor = (isObject && (value instanceof FieldConstructor)) ?
+		value
+		:
+		{
+			enumerable: true,
+			// @ts-ignore
+			...resolver[type](value, receiver),
+		};
 
-	// @ts-ignore
-	const descriptor = resolver[type](value, receiver);
+	// if (value instanceof FieldConstructor) {
+	// 	descriptor;
+	// 	debugger;
+	// }
 
-	const result = Reflect.defineProperty(receiver, propName, {
-		...descriptor,
-		enumerable: true
-	});
+	try {
+		const result = Reflect.defineProperty(receiver, propName, descriptor);
+		return result;
+	} catch (error) {
+		// debugger;
+		throw error;
+	}
 
-	return result;
 };
 
+const props2skip = new Set([Symbol.toStringTag, Symbol.iterator]);
+const util = require('util');
+const hasNodeInspect = (util && util.inspect && util.inspect.custom);
+hasNodeInspect && (props2skip.add(util.inspect.custom));
 
 const handlers = {
 	get(target: object, prop: string | symbol, receiver: object) {
@@ -204,7 +110,11 @@ const handlers = {
 				}, {}));
 			}
 		}
-		throw new Error(`${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ]`);
+		// @ts-ignore
+		if (props2skip.has(prop)) {
+			return undefined;
+		}
+		throw new Error(`${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ] of ${receiver.constructor.name}`);
 	},
 	set(_: object, prop: string, value: unknown, receiver: object) {
 		const result = createProperty(prop, value, receiver);
@@ -221,12 +131,6 @@ const BaseTarget = Object.create(null);
 
 // const BasePrototype = new Proxy(BaseTarget, handlers);
 
-export type IDEF<T, P = {}, R = {}> = {
-	new(...args: any[]): T;
-	(this: T, ...args: any[]): R;
-	prototype: P;
-};
-
 // @ts-ignore
 const BaseConstructor = function (this: object, InstanceTarget = BaseTarget) {
 	if (!new.target) {
@@ -261,10 +165,24 @@ Object.defineProperty(module, 'exports', {
 
 // @ts-ignore
 export class BaseClass extends BaseConstructor { };
+// export { FieldConstructor } from './fields';
 
 Object.defineProperty(module.exports, 'BaseClass', {
 	get() {
 		return BaseClass;
 	},
 	enumerable: true
-});
+});
+Object.defineProperty(module.exports, 'FieldConstructor', {
+	get() {
+		return FieldConstructor;
+	},
+	enumerable: true
+});
+
+
+export type IDEF<T, P = {}, R = {}> = {
+	new(...args: unknown[]): T;
+	(this: T, ...args: unknown[]): R;
+	prototype: P;
+};

package/src/types/functions.ts

@@ -0,0 +1,7 @@
+'use strict';
+
+import { ErrorsNames } from '../errors';
+
+export const functions = () => {
+	throw new TypeError(ErrorsNames.RIP_FUNCTIONS);
+};

package/src/types/index.ts

@@ -0,0 +1,17 @@
+'use strict';
+
+export { functions } from './functions';
+export { nullish } from './nullish';
+export { objects } from './objects';
+export { primitives } from './primitives';
+export { special } from './special';
+
+const PRIMITIVE_TYPES = [
+	'string',
+	'number',
+	'boolean',
+];
+
+export const isPrimitive = (value: unknown) => {
+	return PRIMITIVE_TYPES.includes(typeof value);
+};

package/src/types/nullish.ts

@@ -0,0 +1,15 @@
+'use strict';
+
+import { ErrorsNames } from '../errors';
+
+export const nullish = (value: object) => {
+	return {
+		get() {
+			return value;
+		},
+		set() {
+			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
+			throw error;
+		}
+	}
+};

package/src/types/objects.ts

@@ -0,0 +1,19 @@
+'use strict';
+
+import { ErrorsNames } from '../errors';
+
+export const objects = (value: object) => {
+	return {
+		get() {
+			return value;
+		},
+		set(replacementValue: unknown) {
+			if (replacementValue instanceof Object && replacementValue.constructor === value.constructor) {
+				value = replacementValue;
+				return value;
+			}
+			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
+			throw error;
+		}
+	}
+};

package/src/types/primitives.ts

@@ -0,0 +1,68 @@
+'use strict';
+
+import { ErrorsNames } from '../errors';
+
+export const primitives = (initialValue: object) => {
+	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: string) {
+							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);
+					}
+
+					return value[prop];
+				}
+			});
+			return proxyAsValue;
+		},
+		// get() {
+		// 	const preparedValue = {
+		// 		[Symbol.toPrimitive]() {
+		// 			return function () {
+		// 				throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
+		// 			};
+		// 		}
+		// 	};
+		// 	Reflect.setPrototypeOf(preparedValue, value);
+		// 	debugger;
+		// 	return preparedValue;
+		// },
+		set(replacementValue: unknown) {
+			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;
+		}
+	};
+};

package/src/types/special.ts

@@ -0,0 +1,19 @@
+'use strict';
+
+import { ErrorsNames } from '../errors';
+
+export const special = (value: object) => {
+	return {
+		get() {
+			return value;
+		},
+		set(replacementValue: object) {
+			if (typeof replacementValue === typeof value) {
+				value = replacementValue;
+				return value;
+			}
+			const error = new TypeError(ErrorsNames.TYPE_MISMATCH);
+			throw error;
+		}
+	}
+};

package/test/index.ts

@@ -5,7 +5,10 @@
 // or meaningless
 
 const BasePrototype = require('..');
-import { BaseClass, IDEF } from '..';
+// @ts-ignore
+import { BaseClass, IDEF, FieldConstructor } from '..';
+
+debugger;
 
 class Base extends BasePrototype({
 	additionalProp: 321,
@@ -14,14 +17,22 @@ class Base extends BasePrototype({
 	},
 }) {
 	numberValue = 123;
+
+	get getterField() {
+		return '123';
+	}
+
+	set setterField(value: string) {
+		this.stringValue = value;
+	}
+
 	constructor() {
 		super();
 		this.stringValue = '123';
 		this.booleanValue = true;
 		this.objectValue = {};
 	}
-};
-
+}
 const baseInstance = new Base;
 
 const upperInstance = Object.create(baseInstance);
@@ -29,7 +40,6 @@ const upperInstance = Object.create(baseInstance);
 class SimpleBase extends BaseClass {
 	stringProp = '123';
 };
-
 const simpleInstance = new SimpleBase;
 
 type MyFunctionalConstructorInstance = {
@@ -37,6 +47,7 @@ type MyFunctionalConstructorInstance = {
 };
 
 const MyFunctionalConstructor = function () {
+	// @ts-ignore
 	this.stringProp = '123';
 } as IDEF<MyFunctionalConstructorInstance>;
 
@@ -44,7 +55,8 @@ Reflect.setPrototypeOf(MyFunctionalConstructor.prototype, new BasePrototype);
 
 const myFunctionalInstance = new MyFunctionalConstructor();
 
-class TripleExtend extends Base { };
+class SecondaryExtend extends Base { second = 123 };
+class TripleExtend extends SecondaryExtend { };
 const tiripleExtendInstance = new TripleExtend;
 
 class NetworkedExtention extends BasePrototype(tiripleExtendInstance) { };
@@ -59,6 +71,84 @@ const extendedSetInstance = new ExtendedSet;
 
 const MUTATION_VALUE = -2;
 
+
+class MyFieldConstructorNoRe extends FieldConstructor {
+	_value: string
+	constructor(value: string) {
+		super(value);
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		this._value = value;
+	}
+}
+class MyFieldConstructorReGet extends MyFieldConstructorNoRe {
+	constructor(value: string) {
+		super(value);
+		const self = this;
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		Reflect.defineProperty(this, 'get', {
+			get() {
+				return function () {
+					return self._value;
+				}
+			},
+			enumerable: true
+		});
+	}
+}
+class MyFieldConstructorReSet extends MyFieldConstructorNoRe {
+	constructor(value: string) {
+		super(value);
+		const self = this;
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		Reflect.defineProperty(this, 'set', {
+			get() {
+				return function (value: string) {
+					self._value = value;
+				}
+			},
+			enumerable: true
+		});
+	}
+}
+class MyFieldConstructor extends MyFieldConstructorReGet {
+	constructor(value: string) {
+		super(value);
+		const self = this;
+		Reflect.defineProperty(this, 'enumerable', {
+			value: true
+		});
+		Reflect.defineProperty(this, 'set', {
+			get() {
+				return function (value: string) {
+					self._value = value;
+				}
+			},
+			enumerable: true
+		});
+	}
+}
+
+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 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 }
+const madeReGet = new MadeReGet;
+const madeReSet = new MadeReSet;
+
 describe('props tests', () => {
 
 	test('base instance has props', () => {
@@ -127,6 +217,62 @@ describe('props tests', () => {
 		expect(baseInstance.objectValue.a).toEqual(123);
 	});
 
+	test('correct custom field creation', () => {
+		expect(madeFieldInstance.myField).toEqual('initial value');
+	});
+
+	test('correct custom field assignment', () => {
+		madeFieldInstance.myField = 'replaced';
+		expect(secondMadeFieldInstance.myField).toEqual('replaced');
+		expect(thirdMadeFieldInstance.myField).toEqual('replaced');
+	});
+
+	test('correct custom field no-re-assignment', () => {
+		expect(madeReGet.myField).toEqual('initial value for get check');
+		expect(() => {
+
+			madeReGet.myField = 'replaced';
+
+		}).toThrow(new TypeError('Re-Assirnment is Forbidden'));
+	});
+
+	test('correct custom field setter only', () => {
+		madeReSet.myField = 'replaced';
+		expect(madeReSet.myField).toEqual('initial value for set check');
+	});
+
+	test('takes error on wrong field definition', () => {
+		expect(() => {
+			class WrongFieldConstructor extends FieldConstructor {
+				value: number
+				constructor(value: number) {
+					super(value)
+					this.value = value;
+				}
+			}
+			const wrongField = new WrongFieldConstructor(123);
+			class WithWrongField extends BaseClass {
+				erroredField = wrongField
+			}
+			new WithWrongField;
+
+		}).toThrow();
+	});
+
+	test('correct custom missing prop search creation', () => {
+		// @ts-ignore
+		expect(madeFieldInstance[Symbol.toStringTag]).toEqual(undefined);
+		// @ts-ignore
+		expect(madeFieldInstance[Symbol.iterator]).toEqual(undefined);
+		const util = require('util');
+		// @ts-ignore
+		expect(madeFieldInstance[util.inspect.custom]).toEqual(undefined);
+		// @ts-ignore
+		const inspected = util.inspect(madeFieldInstance);
+		const expected = 'MadeFieldClass { myField: [Getter/Setter] }';
+		expect(expected).toEqual(expected);
+	});
+
 	test('wrong assignment to objects', () => {
 
 		expect(() => {
@@ -249,7 +395,7 @@ describe('props tests', () => {
 
 			baseInstance.missingValue > 1;
 
-		}).toThrow(new TypeError('Attempt to Access to Undefined Prop: [ missingValue ]'));
+		}).toThrow(new TypeError('Attempt to Access to Undefined Prop: [ missingValue ] of Base'));
 	});
 
 });
@@ -368,9 +514,10 @@ describe('deep extend works', () => {
 	test('class extended three times construction', () => {
 
 		expect(tiripleExtendInstance).toBeInstanceOf(Base);
-		expect(tiripleExtendInstance).toBeInstanceOf(TripleExtend);
+		expect(tiripleExtendInstance).toBeInstanceOf(SecondaryExtend);
 		expect(tiripleExtendInstance).toBeInstanceOf(TripleExtend);
 		expect(`${tiripleExtendInstance.stringValue}`).toEqual('123');
+		expect(tiripleExtendInstance.second).toBeInstanceOf(Number);
 
 	});
 

package/{tsconfig.spec.json → test/tsconfig.json}

@@ -22,9 +22,9 @@
 		"removeComments": true,
 		"experimentalDecorators": true,
 		"forceConsistentCasingInFileNames": true,
-        "types": [
-            "jest",
-            "node"
-        ]
-    },
+		"types": [
+			"jest",
+			"node"
+		]
+	},
 }