typeomatica 0.3.39 → 0.3.57

package/src/index.ts

@@ -1,301 +0,0 @@
-'use strict';
-
-import { ErrorsNames } from './errors';
-
-import {
-	functions,
-	nullish,
-	objects,
-	primitives,
-	special,
-	isPrimitive
-} from './types';
-
-import { FieldConstructor } from './fields';
-
-const resolver = Object.entries({
-	primitives,
-	special,
-	nullish,
-	objects,
-	functions
-}).reduce((obj: object, [key, _handler]) => {
-	// @ts-ignore
-	obj[key] = function (initialValue: object, receiver: object) {
-		const handler = _handler(initialValue);
-		return {
-			get() {
-				const invocationThis = this;
-				if (invocationThis !== receiver) {
-					throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
-				}
-				const result = handler.get();
-				return result;
-			},
-			set(replacementValue: unknown) {
-				const invocationThis = this;
-				if (invocationThis !== receiver) {
-					throw new ReferenceError(ErrorsNames.ACCESS_DENIED);
-				}
-				const result = handler.set(replacementValue);
-				return result;
-			}
-		};
-	};
-
-	return obj;
-}, {});
-
-const createProperty = (propName: string, initialValue: unknown, receiver: object) => {
-
-	const value = initialValue;
-	const valueIsPrimitive = isPrimitive(initialValue);
-	const isObject = typeof initialValue === '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'
-		)
-	);
-
-	const descriptor = (isObject && (value instanceof FieldConstructor)) ?
-		value
-		:
-		{
-			enumerable: true,
-			// @ts-ignore
-			...resolver[type](value, receiver),
-		};
-
-	// if (value instanceof FieldConstructor) {
-	// 	descriptor;
-	// 	debugger;
-	// }
-
-	const result = Reflect.defineProperty(receiver, propName, descriptor);
-	return result;
-
-};
-
-// line below 'href' is for util.inspect works, useful for v24
-const props2skip = new Set([Symbol.toStringTag, Symbol.iterator, 'href']);
-// 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) {
-		const result = Reflect.get(target, prop, receiver);
-		if (result !== undefined) {
-			return result;
-		}
-		if (prop === 'toJSON') {
-			return function (this: typeof target) {
-				const entries = Object.entries(this);
-				return JSON.stringify(entries.reduce((obj, [key, value]) => {
-					// @ts-ignore
-					obj[key] = value.valueOf();
-					return obj;
-				}, {}));
-			};
-		}
-		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);
-		return result;
-	},
-	// defineProperty(target: object, key: string, descriptor: object) {
-	// 	debugger;
-	// 	Reflect.defineProperty(target, key, descriptor);
-	// 	return true;
-	// }
-};
-
-// user have to precisely define all props
-const BaseTarget = Object.create(null);
-
-type Proto<P, T> = Pick<P, Exclude<keyof P, keyof T>> & T;
-
-
-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: {
-			prototype: {
-				constructor: typeof BaseConstructorPrototype
-			}
-			//@ts-ignore
-		} = BaseConstructorPrototype.bind(this, InstanceTarget);
-
-		self.prototype = {
-			constructor: BaseConstructorPrototype
-		};
-
-		return self as T;
-
-	}
-
-	const InstancePrototype = new Proxy(InstanceTarget, handlers);
-
-	let protoPointer = this as object;
-	let protoConstrcutor;
-	do {
-		protoPointer = Reflect.getPrototypeOf(protoPointer) as object;
-		protoConstrcutor = Reflect.getOwnPropertyDescriptor(protoPointer, 'constructor')!.value;
-	} while (protoConstrcutor !== BaseConstructorPrototype);
-
-	Reflect.setPrototypeOf(protoPointer, InstancePrototype);
-	return this;
-
-} as {
-	new(): unknown
-	(): void
-};
-
-// const BaseConstructorProtoProxy = new Proxy(BaseConstructorPrototype, {
-// 	construct (target: Function, argumentsList: unknown[], newTarget: Function) {
-// 		debugger;
-// 		console.log('.construct invocation');
-// 		const result = Reflect.construct(target, argumentsList, newTarget);
-// 		debugger;
-// 		return result;
-// 	},
-// 	get (target: object, prop: string | symbol, receiver: object) {
-// 		debugger;
-// 		const result = Reflect.get(target, prop, receiver);
-// 		debugger;
-// 		return result;
-// 	},
-// 	set(_: object, prop: string, value: unknown, receiver: object) {
-// 		debugger;
-// 		const result = createProperty(prop, value, receiver);
-// 		return result;
-// 	},
-// 	defineProperty(target: object, key: string, descriptor: object) {
-// 		debugger;
-// 		Reflect.defineProperty(target, key, descriptor);
-// 		return true;
-// 	},
-// 	getPrototypeOf(target: object) {
-// 		debugger;
-// 		const result = Reflect.getPrototypeOf(target);
-// 		return result;
-// 	},
-// 	setPrototypeOf(target, prototype) {
-// 		debugger;
-// 		Reflect.setPrototypeOf(target, prototype);
-// 		return true;
-// 	  },
-// });
-
-// as ObjectConstructor & {
-// 	(): void
-// 	new<T>(param?: T extends object ? T : {}): {
-// 		[key in keyof T]: T[key]
-// 	}
-// };
-
-Object.defineProperty(module, 'exports', {
-	get() {
-		// return BaseConstructorProtoProxy;
-		return BaseConstructorPrototype;
-	},
-	enumerable: true
-});
-
-
-// export class BaseClass extends BaseConstructorProtoProxy { }
-// @ts-ignore
-export class BaseClass extends BaseConstructorPrototype { }
-
-export { FieldConstructor } from './fields';
-export const { SymbolInitialValue } = FieldConstructor;
-
-type StrictRuntime = {
-	<T extends object>(...args: unknown[]): T
-}
-
-// export const { StrictPrototype, Strict } = {
-export const { Strict } = {
-	// Strict: BaseConstructorProtoProxy,
-	Strict: BaseConstructorPrototype,
-} as {
-	// StrictPrototype: StrictRuntime
-	Strict: StrictRuntime
-};
-
-Object.defineProperty(module.exports, 'BaseClass', {
-	get() {
-		return BaseClass;
-	},
-	enumerable: true
-});
-Object.defineProperty(module.exports, 'FieldConstructor', {
-	get() {
-		return FieldConstructor;
-	},
-	enumerable: true
-});
-Object.defineProperty(module.exports, 'SymbolInitialValue', {
-	get() {
-		return SymbolInitialValue;
-	},
-	enumerable: true
-});
-Object.defineProperty(module.exports, 'Strict', {
-	get() {
-		return function (prototypeTarget: object) {
-			const decorator = function (
-				this: object,
-				Target: {
-					new(): unknown
-					(): void
-				},
-			) {
-				//@ts-ignore
-				const Targeted = BaseConstructorPrototype.call(Target, prototypeTarget);
-				//@ts-ignore
-				const MyProxyClass = new Proxy(Targeted, {
-					construct(target, argumentsList, newTarget) {
-						//@ts-ignore
-						const result = Reflect.construct(target, argumentsList, newTarget);
-						return result;
-					},
-				});
-				return MyProxyClass;
-			};
-
-			return decorator;
-
-		};
-		// return BaseConstructorProtoProxy;
-		// return BaseConstructorPrototype;
-	},
-	enumerable: true
-});

package/src/types/functions.ts

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

package/src/types/index.ts

@@ -1,17 +0,0 @@
-'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

@@ -1,15 +0,0 @@
-'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

@@ -1,19 +0,0 @@
-'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

@@ -1,69 +0,0 @@
-'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);
-					}
-
-					const answer = value[prop];
-					return answer;
-				}
-			});
-			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

@@ -1,19 +0,0 @@
-'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/__snapshots__/index.ts.snap

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