typeomatica 0.2.5

package/.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+trim_trailing_whitespace = false
+indent_style = tab
+end_of_line = lf
+insert_final_newline = true
+
+[{package*.json,*.yml}]
+indent_style = space
+indent_size = 2

package/.eslintrc.js

@@ -0,0 +1,76 @@
+module.exports = {
+	env: {
+		node: true,
+		es6: true,
+	},
+	extends: ['eslint:recommended'],
+	parserOptions: {
+		ecmaVersion: 2018,
+	},
+	rules: {
+		'indent': ['error', 'tab'],
+		'key-spacing': [
+			'warn',
+			{
+				beforeColon: true,
+				afterColon: true,
+				align: 'colon',
+			},
+		],
+		'linebreak-style': ['error', 'unix'],
+		quotes: ['error', 'single'],
+		semi: ['error', 'always'],
+		'no-unused-vars': 'warn',
+		'no-shadow': [
+			'error',
+			{
+				builtinGlobals: true,
+				hoist: 'all',
+				allow: [],
+			},
+		],
+		'space-before-function-paren': [
+			'warn', {
+				'anonymous': 'always',
+				'named': 'always',
+				'asyncArrow': 'always'
+			}
+		],
+		'prefer-template': 'warn',
+		'prefer-spread': 'warn',
+		'no-useless-concat': 'warn',
+		'prefer-rest-params': 'warn',
+		'prefer-destructuring': 'warn',
+		'no-useless-computed-key': 'warn',
+		'no-useless-constructor': 'warn',
+		'no-useless-rename': 'warn',
+		'no-this-before-super': 'warn',
+		'no-new-symbol': 'warn',
+		'no-duplicate-imports': 'warn',
+		'no-confusing-arrow': 'warn',
+		'no-multi-assign': 'warn',
+		'no-lonely-if': 'warn',
+		'newline-per-chained-call': 'warn',
+		'new-cap': 'warn',
+		'func-name-matching': 'error',
+		// 'consistent-this' : 'error',
+		'line-comment-position': [
+			'warn',
+			{
+				position: 'above',
+			},
+		],
+		quotes: ['error', 'single'],
+		yoda: 'warn',
+	},
+	'overrides': [
+		{
+			'files': ['lib/**/*.js'],
+			'rules': {
+				'prefer-rest-params': 0,
+				'no-redeclare': 0
+			}
+		}
+	]
+
+};

package/.gitattributes

@@ -0,0 +1,22 @@
+
+# Automatically normalize line endings for all text-based files
+# http://git-scm.com/docs/gitattributes#_end_of_line_conversion
+
+# For the following file types, normalize line endings to LF on
+# checkin and prevent conversion to CRLF when they are checked out
+# (this is required in order to prevent newline related issues like,
+# for example, after the build script is run)
+*.html  text eol=lf
+*.css   text eol=lf
+*.less  text eol=lf
+*.scss  text eol=lf
+*.sss   text eol=lf
+*.sass  text eol=lf
+*.js    text eol=lf
+*.json  text eol=lf
+*.yml   text eol=lf
+*.yaml  text eol=lf
+*.md    text eol=lf
+*.sh    text eol=lf
+*.txt   text eol=lf
+*.xml   text eol=lf

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

@@ -0,0 +1,62 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test
+
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@master
+    - name: Use Node.js 12.x
+      uses: actions/setup-node@master
+      with:
+        node-version: 12.x
+
+    - name: npm install
+      run: npm install
+
+    - name: Test
+      run: npm run test:cov
+
+    - name: Coveralls Parallel
+      uses: coverallsapp/github-action@master
+      with:
+        github-token: ${{ secrets.github_token }}
+        parallel: true
+
+  finish:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: Coveralls Finished
+      uses: coverallsapp/github-action@master
+      with:
+        github-token: ${{ secrets.github_token }}
+        parallel-finished: true

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Mythographica → went.out@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# Type ø matica
+
+[![Coverage Status](https://coveralls.io/repos/github/wentout/typeomatica/badge.svg?branch=main)](https://coveralls.io/github/wentout/typeomatica?branch=main)
+
+![NPM](https://img.shields.io/npm/l/typeomatica)
+![GitHub package.json version](https://img.shields.io/github/package-json/v/wentout/typeomatica)
+![GitHub last commit](https://img.shields.io/github/last-commit/wentout/typeomatica)
+
+[**$ npm install <u>typeomatica</u>**](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.
+
+# how it works
+
+see `test/index.ts`
+
+```js
+
+class SimpleBase extends BasePrototype {
+	stringProp = '123';
+};
+
+// nect code line will work properly
+simpleInstance.stringProp = '321';
+
+// but next code line will throw TypeError('Type Mismatch')
+// @ts-ignore
+simpleInstance.stringProp = 123;
+
+```
+
+That is it. It will be impossible to assign anything else except of:
+
+```js 
+typeof something === 'string'
+```
+
+to `stringProp` in runtime.
+
+As we describe Data Types &mdash; please take a peek for tests directory:
+[HERE](https://github.com/wentout/typeomatica/blob/main/test/index.ts).

package/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+	preset: 'ts-jest',
+	testEnvironment: 'node',
+	testMatch: ['**/test/**/index.ts', '**/test/**/addition.js'],
+	globals: {
+		'ts-jest': {
+			tsconfig: './test/tsconfig.json'
+		}
+	},
+};

package/lib/index.d.ts

@@ -0,0 +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 {};

package/lib/index.js

@@ -0,0 +1,198 @@
+'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 resolver = Object.entries({
+    primitives,
+    special,
+    nullish,
+    objects,
+    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(ErrorsNames.ACCESS_DENIED);
+                }
+                return handler.get();
+            },
+            set(replacementValue) {
+                const invocationThis = this;
+                if (invocationThis !== receiver) {
+                    throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
+                }
+                return handler.set(replacementValue);
+            }
+        };
+    };
+    return obj;
+}, {});
+const createProperty = (propName, initialValue, receiver) => {
+    const value = initialValue;
+    const valueIsPrimitive = 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 handlers = {
+    get(target, prop, receiver) {
+        const result = Reflect.get(target, prop, receiver);
+        if (result !== undefined) {
+            return result;
+        }
+        if (prop === 'toJSON') {
+            return function () {
+                return JSON.stringify(Object.entries(this).reduce((obj, [key, value]) => {
+                    obj[key] = value.valueOf();
+                    return obj;
+                }, {}));
+            };
+        }
+        throw new Error(`${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ]`);
+    },
+    set(_, prop, value, receiver) {
+        const result = createProperty(prop, value, receiver);
+        return result;
+    },
+};
+const BaseTarget = Object.create(null);
+const BaseConstructor = function (InstanceTarget = BaseTarget) {
+    if (!new.target) {
+        const constructor = BaseConstructor.bind(this, InstanceTarget);
+        constructor.prototype = {
+            constructor: BaseConstructor
+        };
+        return constructor;
+    }
+    const InstancePrototype = new Proxy(InstanceTarget, handlers);
+    let protoPointer = this;
+    let protoConstrcutor;
+    do {
+        protoPointer = Reflect.getPrototypeOf(protoPointer);
+        protoConstrcutor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor').value;
+    } while (protoConstrcutor !== BaseConstructor);
+    Reflect.setPrototypeOf(protoPointer, InstancePrototype);
+};
+Object.defineProperty(module, 'exports', {
+    get() {
+        return BaseConstructor;
+    },
+    enumerable: true
+});
+class BaseClass extends BaseConstructor {
+}
+exports.BaseClass = BaseClass;
+;
+Object.defineProperty(module.exports, 'BaseClass', {
+    get() {
+        return BaseClass;
+    },
+    enumerable: true
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "typeomatica",
+	"version": "0.2.5",
+	"description": "type logic against javascript metaprogramming",
+	"main": "lib/index.js",
+	"scripts": {
+		"build": "rm -rf ./lib && npx tsc --pretty",
+		"buildlint": "rm -rf ./lib && npx tsc --pretty && npm run lint",
+		"lint": "npx eslint --fix --ignore-path .gitignore ./lib",
+		"test": "npx jest",
+		"test:cov": "npx jest --collectCoverage",
+		"debug": "npx --node-arg=--inspect-brk jest"
+	},
+	"keywords": [
+		"strict",
+		"types",
+		"runtime",
+		"javascript",
+		"metaprogramming"
+	],
+	"author": "went.out@gmail.com",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/wentout/typeomatica.git"
+	},
+	"devDependencies": {
+		"@types/jest": "^27.0.1",
+		"@types/node": "^16.9.2",
+		"eslint": "^7.32.0",
+		"husky": "^7.0.2",
+		"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.4.3"
+	}
+}

package/src/index.ts

@@ -0,0 +1,270 @@
+'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;
+		}
+	}
+};
+
+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;
+		}
+	}
+};
+
+const functions = () => {
+	throw new TypeError(ErrorsNames.RIP_FUNCTIONS);
+};
+
+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);
+				}
+				return handler.get();
+			},
+			set(replacementValue: unknown) {
+				const invocationThis = this;
+				if (invocationThis !== receiver) {
+					throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
+				}
+				return handler.set(replacementValue);
+			}
+		}
+	};
+
+	return obj;
+}, {});
+
+const createProperty = (propName: string, initialValue: any, receiver: object) => {
+
+	const value = initialValue;
+	const valueIsPrimitive = 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'));
+
+	// @ts-ignore
+	const descriptor = resolver[type](value, receiver);
+
+	const result = Reflect.defineProperty(receiver, propName, {
+		...descriptor,
+		enumerable: true
+	});
+
+	return result;
+};
+
+
+const handlers = {
+	get(target: object, prop: string | symbol, receiver: object) {
+		const result = Reflect.get(target, prop, receiver);
+		if (result !== undefined) {
+			return result;
+		}
+		if (prop === 'toJSON') {
+			return function (this: typeof target) {
+				return JSON.stringify(Object.entries(this).reduce((obj, [key, value]) => {
+					// @ts-ignore
+					obj[key] = value.valueOf();
+					return obj;
+				}, {}));
+			}
+		}
+		throw new Error(`${ErrorsNames.MISSING_PROP}: [ ${String(prop).valueOf()} ]`);
+	},
+	set(_: object, prop: string, value: unknown, receiver: object) {
+		const result = createProperty(prop, value, receiver);
+		return result;
+	},
+	// defineProperty(target: object, key: string, descriptor: object) {
+	// 	Reflect.defineProperty(target, key, descriptor);
+	// 	return true;
+	// }
+};
+
+// user have to precisely define all props
+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) {
+		const constructor = BaseConstructor.bind(this, InstanceTarget);
+		constructor.prototype = {
+			constructor: BaseConstructor
+		};
+		return constructor;
+	}
+
+	const InstancePrototype = new Proxy(InstanceTarget, handlers);
+
+	let protoPointer = this;
+	let protoConstrcutor;
+	do {
+		protoPointer = Reflect.getPrototypeOf(protoPointer) as object;
+		protoConstrcutor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor')!.value;
+	} while (protoConstrcutor !== BaseConstructor);
+	Reflect.setPrototypeOf(protoPointer, InstancePrototype);
+
+} as ObjectConstructor;
+// } as IDEF;
+
+// Reflect.setPrototypeOf(BaseConstructor.prototype, BasePrototype);
+
+Object.defineProperty(module, 'exports', {
+	get() {
+		return BaseConstructor;
+	},
+	enumerable: true
+});
+
+// @ts-ignore
+export class BaseClass extends BaseConstructor { };
+
+Object.defineProperty(module.exports, 'BaseClass', {
+	get() {
+		return BaseClass;
+	},
+	enumerable: true
+});

package/test/__snapshots__/index.ts.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`props tests correct JSON.stringify 1`] = `"\\"{\\\\\\"numberValue\\\\\\":123,\\\\\\"stringValue\\\\\\":\\\\\\"123\\\\\\",\\\\\\"booleanValue\\\\\\":false,\\\\\\"objectValue\\\\\\":{}}\\""`;

package/test/addition.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const BasePrototype = require('..');
+
+class Base extends BasePrototype({
+    additionalProp: 321,
+}) {
+    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'));
+    });
+
+});

package/test/index.ts

@@ -0,0 +1,410 @@
+'use strict';
+
+// BasePrototype & BaseClass are the same function
+// go as you want for being meaningfull
+// or meaningless
+
+const BasePrototype = require('..');
+import { BaseClass, IDEF } from '..';
+
+class Base extends BasePrototype({
+	additionalProp: 321,
+	someMethod() {
+		return this.numberValue.valueOf();
+	},
+}) {
+	numberValue = 123;
+	constructor() {
+		super();
+		this.stringValue = '123';
+		this.booleanValue = true;
+		this.objectValue = {};
+	}
+};
+
+const baseInstance = new Base;
+
+const upperInstance = Object.create(baseInstance);
+
+class SimpleBase extends BaseClass {
+	stringProp = '123';
+};
+const simpleInstance = new SimpleBase;
+
+type MyFunctionalConstructorInstance = {
+	stringProp: string
+};
+
+const MyFunctionalConstructor = function () {
+	this.stringProp = '123';
+} as IDEF<MyFunctionalConstructorInstance>;
+
+Reflect.setPrototypeOf(MyFunctionalConstructor.prototype, new BasePrototype);
+
+const myFunctionalInstance = new MyFunctionalConstructor();
+
+class SecondaryExtend extends Base { second = 123 };
+class TripleExtend extends SecondaryExtend { };
+const tiripleExtendInstance = new TripleExtend;
+
+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])) { };
+
+const extendedArrayInstance = new ExtendedArray;
+const extendedSetInstance = new ExtendedSet;
+
+const MUTATION_VALUE = -2;
+
+describe('props tests', () => {
+
+	test('base instance has props', () => {
+		expect(Object.keys(baseInstance)).toEqual(["numberValue", "stringValue", "booleanValue", "objectValue"]);
+	});
+
+	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(() => {
+
+			// @ts-ignore
+			simpleInstance.stringProp = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+	test('correct boolean comparison with type coercion', () => {
+		expect(() => {
+
+			const { booleanValue } = baseInstance;
+			booleanValue != false;
+
+		}).toThrow(new TypeError('Value Access Denied'));
+	});
+
+	test('fails boolean arithmetics', () => {
+		expect(() => {
+
+			baseInstance.booleanValue + 5;
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+	});
+
+	test('correct boolean assignment', () => {
+
+		let { booleanValue } = baseInstance;
+		expect(booleanValue.valueOf()).toEqual(true);
+
+		// warning!
+		// booleanValue does not rely on baseInstance anymore!
+		booleanValue = new Boolean(false);
+
+		let value = baseInstance.booleanValue.valueOf();
+		expect(value).toEqual(true);
+
+
+		baseInstance.booleanValue = new Boolean(false);
+		value = baseInstance.booleanValue.valueOf();
+		expect(value).toEqual(false);
+
+	});
+
+	test('correct JSON.stringify', () => {
+		const stringifyResult = JSON.stringify(baseInstance);
+		expect(stringifyResult).toMatchSnapshot();
+	});
+
+	test('correct boolean constructor', () => {
+		expect(baseInstance.booleanValue).toBeInstanceOf(Boolean);
+	});
+
+	test('correct object assignment', () => {
+		baseInstance.objectValue = { a: 123 };
+		expect(baseInstance.objectValue.a).toEqual(123);
+	});
+
+	test('wrong assignment to objects', () => {
+
+		expect(() => {
+
+			baseInstance.objectValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+
+		expect(() => {
+
+			baseInstance.objectValue = new Set();
+
+		}).toThrow(new TypeError('Type Mismatch'));
+
+	});
+
+	test('fails number arithmetics', () => {
+		expect(() => {
+
+			baseInstance.numberValue + 5;
+
+		}).toThrow();
+	});
+
+	test('correct number arithmetics using .valueOf()', () => {
+
+		baseInstance.numberValue = MUTATION_VALUE;
+
+		const result = baseInstance.numberValue.valueOf() + 5;
+		expect(result).toStrictEqual(3);
+
+	});
+
+	test('correct number arithmetics using hinting for Symbol.toPrimitive (hint)', () => {
+
+		const result = 3 + +baseInstance.numberValue;
+		expect(result).toStrictEqual(1);
+
+	});
+
+	test('correct number value', () => {
+		expect(baseInstance.numberValue.toString()).toStrictEqual(MUTATION_VALUE.toString());
+		expect(/Number$/.test(baseInstance.numberValue.constructor.name)).toBe(true);
+	});
+
+
+	test('wrong assignment', () => {
+		expect(() => {
+
+			baseInstance.booleanValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+	test('correct null value', () => {
+		baseInstance.nullValue = null;
+		expect(baseInstance.nullValue).toEqual(null);
+	});
+
+	test('any assignment to null value', () => {
+		expect(() => {
+
+			baseInstance.nullValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+
+	test('correct undefined value', () => {
+		baseInstance.undefinedValue = undefined;
+		expect(baseInstance.undefinedValue).toEqual(undefined);
+	});
+
+	test('wrong assignment to undefined value', () => {
+		expect(() => {
+
+			baseInstance.undefinedValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+	test('correct BigInt value', () => {
+		baseInstance.BigIntValue = BigInt(1);
+		expect(baseInstance.BigIntValue).toEqual(BigInt(1));
+	});
+
+	test('correct assignment to BigInt value', () => {
+		baseInstance.BigIntValue = BigInt(2);
+		expect(baseInstance.BigIntValue).toEqual(BigInt(2));
+	});
+
+	test('wrong assignment to BigInt value', () => {
+		expect(() => {
+
+			baseInstance.BigIntValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+	test('correct Symbol value', () => {
+		baseInstance.SymbolValue = Symbol('test');
+		expect(typeof baseInstance.SymbolValue).toEqual('symbol');
+	});
+
+	test('wrong assignment to BigInt value', () => {
+		expect(() => {
+
+			baseInstance.SymbolValue = 123;
+
+		}).toThrow(new TypeError('Type Mismatch'));
+	});
+
+	test('correct prototype correction', () => {
+		expect(baseInstance.additionalProp).toEqual(321);
+		expect(baseInstance.toString).toBeInstanceOf(Function);
+	});
+
+	test('missing value fails', () => {
+		expect(() => {
+
+			baseInstance.missingValue > 1;
+
+		}).toThrow(new TypeError('Attempt to Access to Undefined Prop: [ missingValue ]'));
+	});
+
+});
+
+describe('prototype mutations tests', () => {
+
+	test('incorrect prototype invocation number get', () => {
+		expect(() => {
+
+			upperInstance.numberValue > 1;
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+	});
+
+	test('incorrect prototype invocation number set', () => {
+		expect(() => {
+
+			upperInstance.numberValue = new Number(1);
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+	});
+
+
+	test('incorrect prototype invocation string get', () => {
+		expect(() => {
+
+			upperInstance.stringValue > '1';
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+	});
+
+	test('incorrect prototype invocation string set', () => {
+		expect(() => {
+
+			upperInstance.stringValue = new String(1);
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+	});
+
+});
+
+describe('methods tests', () => {
+
+	test('functions are restricted for data type', () => {
+
+		expect(() => {
+
+			baseInstance.someMethod = function () { };
+
+		}).toThrow(new TypeError('Functions are Restricted'));
+
+	});
+
+	test('proxy proto methods are SOLID', () => {
+
+		const result = baseInstance.someMethod();
+		expect(result).toBe(MUTATION_VALUE);
+
+	});
+
+});
+
+describe('property re-definition works', () => {
+
+	test('exact prototype invocation for correct property extraction', () => {
+
+		Object.defineProperty(upperInstance, 'stringProp', {
+			get() {
+				const target = Reflect.getPrototypeOf(upperInstance) as {
+					stringValue: string
+				};
+				return target.stringValue;
+			}
+		});
+
+		const value = upperInstance.stringProp;
+		expect(`${value}`).toEqual('123');
+
+	});
+});
+
+
+describe('functional constructors tests', () => {
+	test('construction made properly', () => {
+
+		const { stringProp,
+			constructor: {
+				name
+			}
+		} = myFunctionalInstance;
+		expect(name).toEqual('MyFunctionalConstructor');
+		expect(stringProp.valueOf()).toEqual('123');
+
+	});
+});
+
+describe('instanceof works', () => {
+	test('for class construction', () => {
+
+		expect(baseInstance).toBeInstanceOf(Base);
+
+	});
+	test('for simple construction', () => {
+
+		expect(simpleInstance).toBeInstanceOf(SimpleBase);
+
+	});
+	test('for functional construction', () => {
+
+		expect(myFunctionalInstance).toBeInstanceOf(MyFunctionalConstructor);
+
+	});
+});
+
+describe('deep extend works', () => {
+	test('class extended three times construction', () => {
+
+		expect(tiripleExtendInstance).toBeInstanceOf(Base);
+		expect(tiripleExtendInstance).toBeInstanceOf(SecondaryExtend);
+		expect(tiripleExtendInstance).toBeInstanceOf(TripleExtend);
+		expect(`${tiripleExtendInstance.stringValue}`).toEqual('123');
+		expect(tiripleExtendInstance.second).toBeInstanceOf(Number);
+
+	});
+
+	test('network extention works', () => {
+		expect(networkedInstance).toBeInstanceOf(NetworkedExtention);
+
+		expect(() => {
+
+			`${networkedInstance.stringValue}`;
+
+		}).toThrow(new ReferenceError('Value Access Denied'));
+
+	});
+
+	test('builtin types works', () => {
+		expect(extendedArrayInstance).toBeInstanceOf(Array);
+		expect(extendedArrayInstance).toBeInstanceOf(ExtendedArray);
+		expect(extendedArrayInstance[0]).toBe(1);
+		extendedArrayInstance.unshift(0);
+		extendedArrayInstance.push(5);
+		expect(+extendedArrayInstance.length).toBe(5);
+		expect(+extendedArrayInstance[0]).toBe(0);
+		expect(+extendedArrayInstance[4]).toBe(5);
+
+		expect(extendedSetInstance).toBeInstanceOf(Set);
+		expect(extendedSetInstance).toBeInstanceOf(ExtendedSet);
+
+		// JS Object.create(new Set([1, 2, 3])) is doing the same error!
+		expect(() => {
+
+			extendedSetInstance.has(0);
+
+		}).toThrow(new TypeError('Method Set.prototype.has called on incompatible receiver [object Object]'));
+
+	});
+});

package/test/tsconfig.json

@@ -0,0 +1,30 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "ES2015",
+		"lib": [
+			"ES6",
+		],
+		"strict": true,
+		"alwaysStrict": true,
+		"strictFunctionTypes": true,
+		"diagnostics": true,
+		"noImplicitThis": true,
+		"extendedDiagnostics": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"declaration": true,
+		"sourceMap": false,
+		"outDir": "lib",
+		"traceResolution": false,
+		"removeComments": true,
+		"experimentalDecorators": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": [
+			"jest",
+			"node"
+		]
+	},
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "ES2015",
+		"lib": [
+			"ES6",
+		],
+		"strict": true,
+		"alwaysStrict": true,
+		"strictFunctionTypes": true,
+		"diagnostics": true,
+		"noImplicitThis": true,
+		"extendedDiagnostics": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"declaration": true,
+		"sourceMap": false,
+		"outDir": "lib",
+		"traceResolution": false,
+		"removeComments": true,
+		"experimentalDecorators": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": ["node"]
+	},
+	"include": [
+		"./src/**/*.ts",
+	],
+	"exclude": [
+		"./lib/**/*",
+		"./coverage/**/*",
+	]
+}