@rainbow-o23/n1 1.0.50 → 1.0.51

package/src/lib/pipeline/step-helpers-utils.ts

@@ -1,9 +1,8 @@
+import {isArrayLike, isLength, isPrototype, IValueOperator, ValueOperator} from '@rainbow-n19/n1';
 import {customAlphabet, nanoid} from 'nanoid';
 import {CatchableError, ERR_TRIM_NON_STRING, ExposedUncatchableError, UncatchableError} from '../utils';
 import {PipelineStepHelpers} from './step-helpers';
-import {IValueOperator, ValueOperator} from './step-helpers-value-operator';
 import {StaticImplements} from './types';
-import {isArrayLike, isBlank, isEmpty, isLength, isNotBlank, isNotEmpty, OBJECT_PROTOTYPE} from './value-operators';
 
 export interface PipelineStepErrorOptions {
 	// exactly same as http status
@@ -135,10 +134,7 @@ export class StepHelpersUtils {
 	// utils
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static isPrototype(value: any): boolean {
-		const Ctor = value && value.constructor;
-		const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
-
-		return value === proto;
+		return isPrototype(value);
 	}
 
 	/**
@@ -168,7 +164,7 @@ export class StepHelpersUtils {
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static isEmpty(value: any): boolean {
-		return isEmpty(value).test;
+		return ValueOperator.of(value).isEmpty().ok();
 	}
 
 	/**
@@ -177,7 +173,7 @@ export class StepHelpersUtils {
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static isNotEmpty(value: any): boolean {
-		return isNotEmpty(value).test;
+		return ValueOperator.of(value).isNotEmpty().ok();
 	}
 
 	/**
@@ -186,7 +182,7 @@ export class StepHelpersUtils {
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static isBlank(value: any): boolean {
-		return isBlank(value).test;
+		return ValueOperator.of(value).isBlank().ok();
 	}
 
 	/**
@@ -195,7 +191,7 @@ export class StepHelpersUtils {
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static isNotBlank(value: any): boolean {
-		return isNotBlank(value).test;
+		return ValueOperator.of(value).isNotBlank().ok();
 	}
 
 	/**
@@ -216,7 +212,7 @@ export class StepHelpersUtils {
 
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public static touch(value: any): IValueOperator {
-		return ValueOperator.from(value);
+		return ValueOperator.of(value);
 	}
 
 	/**

package/lib/pipeline/step-helpers-value-operator.d.ts

@@ -1,34 +0,0 @@
-import { AllTesters, AllTransformers, RegisteredValueAction, RegisteredValueActionWithParams } from './value-operators';
-export interface FinalValueRetriever {
-    value: <T>() => T;
-    success: <T>(value: T) => {
-        failure: <V>(value: V) => void;
-    };
-    failure: <V>(value: V) => {
-        success: <T>(value: T) => void;
-    };
-    ok: () => boolean;
-    promise: <T>() => Promise<T>;
-}
-export interface DefaultValueSetter extends FinalValueRetriever {
-    orUseDefault: (defaultValue: any) => FinalValueRetriever;
-    useDefault: (defaultValue: any) => FinalValueRetriever;
-    withDefault: (defaultValue: any) => FinalValueRetriever;
-    orElse: (defaultValue: any) => FinalValueRetriever;
-    else: (defaultValue: any) => FinalValueRetriever;
-}
-type ActionType<T> = T extends RegisteredValueAction ? (ValueActionsWithDefault & (() => ValueActionsWithDefault)) : T extends RegisteredValueActionWithParams ? ((...args: Parameters<T['func']>) => ValueActionsWithDefault) : never;
-export type ValueActions = {
-    [K in keyof typeof AllTesters]: ActionType<typeof AllTesters[K]>;
-} & {
-    [K in keyof typeof AllTransformers]: ActionType<typeof AllTransformers[K]>;
-};
-export type ValueActionsWithDefault = ValueActions & DefaultValueSetter;
-export type IValueOperator = ValueActions;
-export interface IValueOperatorBoostrap {
-    of(value: any): IValueOperator;
-    from(value: any): IValueOperator;
-    with(value: any): IValueOperator;
-}
-export declare const ValueOperator: IValueOperatorBoostrap;
-export {};

package/lib/pipeline/value-operators/action-types.d.ts

@@ -1,18 +0,0 @@
-export type ValueActionPassed<V> = {
-    test: true;
-    value: V;
-};
-export type ValueActionFailed<V> = {
-    test: false;
-    value: V;
-};
-export type ValueAction<From = any, To = any> = (value?: From) => ValueActionPassed<To> | ValueActionFailed<From>;
-export type RegisteredValueAction = {
-    type: 'func';
-    func: ValueAction;
-};
-export type RegisteredValueActionWithParams<F = (...args: Array<any>) => ValueAction> = {
-    type: 'param';
-    func: F;
-};
-export declare const OBJECT_PROTOTYPE: Object;

package/lib/pipeline/value-operators/index.d.ts

@@ -1,8 +0,0 @@
-export * from './action-types';
-export * from './test-any-actions';
-export * from './test-string-actions';
-export * from './test-decimal-actions';
-export * from './testers';
-export * from './transform-string-actions';
-export * from './transform-decimal-actions';
-export * from './transformers';

package/lib/pipeline/value-operators/test-any-actions.d.ts

@@ -1,10 +0,0 @@
-import { ValueAction } from './action-types';
-export declare const isLength: (value: any) => boolean;
-export declare const isArrayLike: (value: any) => boolean;
-export declare const isPrototype: (value: any) => boolean;
-export declare const isNull: ValueAction<any, null | undefined>;
-export declare const isNotNull: ValueAction<any, NonNullable<any>>;
-export declare const isEmpty: ValueAction;
-export declare const isNotEmpty: ValueAction;
-export declare const isBlank: ValueAction<any, null | undefined | string>;
-export declare const isNotBlank: ValueAction;

package/lib/pipeline/value-operators/test-decimal-actions.d.ts

@@ -1,25 +0,0 @@
-import Decimal from 'decimal.js';
-import { ValueAction } from './action-types';
-export declare const isDecimal: ValueAction<any, Decimal>;
-export declare const isInteger: ValueAction<any, Decimal>;
-export type DecimalInterval = 'closed' | 'c' | 'open' | 'o' | 'left-open' | 'lo' | 'right-open' | 'ro';
-export type DecimalInRangeOptions = {
-    interval?: DecimalInterval;
-} & ({
-    min: Decimal.Value;
-    max?: Decimal.Value;
-} | {
-    min?: Decimal.Value;
-    max: Decimal.Value;
-});
-export declare const isInRange: (options: DecimalInRangeOptions) => ValueAction<any, Decimal>;
-export declare const isPositive: ValueAction<any, Decimal>;
-export declare const isNotPositive: ValueAction<any, Decimal>;
-export declare const isNegative: ValueAction<any, Decimal>;
-export declare const isNotNegative: ValueAction<any, Decimal>;
-export declare const isZero: ValueAction<any, Decimal>;
-export declare const isNotZero: ValueAction<any, Decimal>;
-export declare const isGreaterThan: (compare: Decimal.Value) => ValueAction<any, Decimal>;
-export declare const isGreaterThanOrEqual: (compare: Decimal.Value) => ValueAction<any, Decimal>;
-export declare const isLessThan: (compare: Decimal.Value) => ValueAction<any, Decimal>;
-export declare const isLessThanOrEqual: (compare: Decimal.Value) => ValueAction<any, Decimal>;

package/lib/pipeline/value-operators/test-string-actions.d.ts

@@ -1,2 +0,0 @@
-import { ValueAction } from './action-types';
-export declare const regexp: (regexp: RegExp) => ValueAction;

package/lib/pipeline/value-operators/testers.d.ts

@@ -1,36 +0,0 @@
-import { RegisteredValueAction, RegisteredValueActionWithParams } from './action-types';
-import { isGreaterThan, isGreaterThanOrEqual, isInRange, isLessThan, isLessThanOrEqual } from './test-decimal-actions';
-import { regexp } from './test-string-actions';
-declare const testers: {
-    isNull: RegisteredValueAction;
-    isNotNull: RegisteredValueAction;
-    isEmpty: RegisteredValueAction;
-    isNotEmpty: RegisteredValueAction;
-    isBlank: RegisteredValueAction;
-    isNotBlank: RegisteredValueAction;
-    regexp: RegisteredValueActionWithParams<typeof regexp>;
-    regex: RegisteredValueActionWithParams<typeof regexp>;
-    matches: RegisteredValueActionWithParams<typeof regexp>;
-    isNumber: RegisteredValueAction;
-    isDecimal: RegisteredValueAction;
-    isInteger: RegisteredValueAction;
-    isInt: RegisteredValueAction;
-    isPositive: RegisteredValueAction;
-    isNotPositive: RegisteredValueAction;
-    isNegative: RegisteredValueAction;
-    isNotNegative: RegisteredValueAction;
-    isZero: RegisteredValueAction;
-    isNotZero: RegisteredValueAction;
-    isGreaterThan: RegisteredValueActionWithParams<typeof isGreaterThan>;
-    gt: RegisteredValueActionWithParams<typeof isGreaterThan>;
-    isGreaterThanOrEqual: RegisteredValueActionWithParams<typeof isGreaterThanOrEqual>;
-    gte: RegisteredValueActionWithParams<typeof isGreaterThanOrEqual>;
-    isLessThan: RegisteredValueActionWithParams<typeof isLessThan>;
-    lt: RegisteredValueActionWithParams<typeof isLessThan>;
-    isLessThanOrEqual: RegisteredValueActionWithParams<typeof isLessThanOrEqual>;
-    lte: RegisteredValueActionWithParams<typeof isLessThanOrEqual>;
-    isInRange: RegisteredValueActionWithParams<typeof isInRange>;
-    within: RegisteredValueActionWithParams<typeof isInRange>;
-};
-export declare const AllTesters: Readonly<typeof testers>;
-export {};

package/lib/pipeline/value-operators/transform-decimal-actions.d.ts

@@ -1,21 +0,0 @@
-import Decimal from 'decimal.js';
-import { ValueAction } from './action-types';
-export declare enum Rounding {
-    ROUND_UP = "up",
-    ROUND_DOWN = "down",
-    ROUND_CEIL = "ceil",
-    ROUND_FLOOR = "floor",
-    ROUND_HALF_UP = "half-up",
-    ROUND_HALF_DOWN = "half-down",
-    ROUND_HALF_EVEN = "half-even",
-    ROUND_HALF_CEIL = "half-ceil",
-    ROUND_HALF_FLOOR = "half-floor"
-}
-export declare const toDecimal: ValueAction<any, Decimal>;
-export declare const toNumber: ValueAction<any, number>;
-export declare const toFixed: (fractionDigits: number, rounding?: Rounding) => ValueAction<any, string>;
-export declare const roundUp: (fractionDigits: number) => ValueAction<any, Decimal>;
-export declare const roundDown: (fractionDigits: number) => ValueAction<any, Decimal>;
-export declare const floor: (fractionDigits: number) => ValueAction<any, Decimal>;
-export declare const ceil: (fractionDigits: number) => ValueAction<any, Decimal>;
-export declare const roundBy: (fractionDigits: number, rounding?: Rounding) => ValueAction<any, Decimal>;

package/lib/pipeline/value-operators/transform-string-actions.d.ts

@@ -1,10 +0,0 @@
-import { ValueAction } from './action-types';
-export declare const trim: ValueAction;
-export type PadOptions = {
-    length: number;
-    char?: string;
-    direction?: 'left' | 'right';
-};
-export declare const pad: (options: PadOptions) => ValueAction;
-export declare const padStart: (options: Omit<PadOptions, "direction">) => ValueAction;
-export declare const padEnd: (options: Omit<PadOptions, "direction">) => ValueAction;

package/lib/pipeline/value-operators/transformers.d.ts

@@ -1,31 +0,0 @@
-import { RegisteredValueAction, RegisteredValueActionWithParams } from './action-types';
-import { ceil, floor, roundBy, roundDown, roundUp, toFixed } from './transform-decimal-actions';
-import { pad, padEnd, padStart } from './transform-string-actions';
-declare const transformers: {
-    trim: RegisteredValueAction;
-    pad: RegisteredValueActionWithParams<typeof pad>;
-    padStart: RegisteredValueActionWithParams<typeof padStart>;
-    padLeft: RegisteredValueActionWithParams<typeof padStart>;
-    lpad: RegisteredValueActionWithParams<typeof padStart>;
-    padEnd: RegisteredValueActionWithParams<typeof padEnd>;
-    padRight: RegisteredValueActionWithParams<typeof padEnd>;
-    rpad: RegisteredValueActionWithParams<typeof padEnd>;
-    toDecimal: RegisteredValueAction;
-    toNumber: RegisteredValueAction;
-    toFixed0: RegisteredValueAction;
-    toFixed1: RegisteredValueAction;
-    toFixed2: RegisteredValueAction;
-    toFixed3: RegisteredValueAction;
-    toFixed4: RegisteredValueAction;
-    toFixed5: RegisteredValueAction;
-    toFixed6: RegisteredValueAction;
-    toFixed: RegisteredValueActionWithParams<typeof toFixed>;
-    round: RegisteredValueActionWithParams<typeof roundUp>;
-    roundUp: RegisteredValueActionWithParams<typeof roundUp>;
-    roundDown: RegisteredValueActionWithParams<typeof roundDown>;
-    floor: RegisteredValueActionWithParams<typeof floor>;
-    ceil: RegisteredValueActionWithParams<typeof ceil>;
-    roundBy: RegisteredValueActionWithParams<typeof roundBy>;
-};
-export declare const AllTransformers: Readonly<typeof transformers>;
-export {};

package/src/lib/pipeline/step-helpers-value-operator.ts

@@ -1,307 +0,0 @@
-import {StaticImplements} from './types';
-import {
-	AllTesters,
-	AllTransformers,
-	RegisteredValueAction,
-	RegisteredValueActionWithParams,
-	ValueAction,
-	ValueActionFailed,
-	ValueActionPassed
-} from './value-operators';
-
-interface ValueOperatorBase {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	$value?: any;
-	$allowMoreAction: boolean;
-	$actions?: Array<ValueAction>;
-	$allowUseDefault: boolean;
-	$defaultUsed: boolean;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	$defaultValue?: any;
-	// control
-	$allowNoParamFuncCall: boolean;
-}
-
-/**
- * function call is allowed for tester and transformer, only when the {@link $allowNoParamFuncCall} is true.
- * and once it is called, set {@link $allowNoParamFuncCall} to false.
- * otherwise, throw exception.
- */
-const applyOperator = (operator: IValueOperator, base: ValueOperatorBase) => {
-	if (base.$allowNoParamFuncCall) {
-		base.$allowNoParamFuncCall = false;
-		return operator;
-	} else {
-		throw new Error(`Function call is not allowed from: ${operator}.`);
-	}
-};
-const NOT_FOUND = Symbol('not found');
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type ValueActionFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => IValueOperator | ((...args: Array<any>) => IValueOperator) | symbol;
-const findValueAction = (actions: Record<string, RegisteredValueAction | RegisteredValueActionWithParams>): ValueActionFind => {
-	return (operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-		const tester = actions[prop];
-		if (tester == null) {
-			return NOT_FOUND;
-		}
-
-		base.$allowUseDefault = true;
-		if (base.$actions == null) {
-			base.$actions = [];
-		}
-		if (tester.type === 'func') {
-			// push to tester stack
-			base.$actions.push(tester.func);
-			base.$allowNoParamFuncCall = true;
-			return operator;
-		} else if (tester.type === 'param') {
-			// build a function to accept parameters
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			return (...args: Array<any>) => {
-				base.$actions.push(tester.func(...args));
-				return operator;
-			};
-		} else {
-			throw new Error(`Unknown tester type: ${tester}.`);
-		}
-	};
-};
-const findTester = findValueAction(AllTesters);
-const findTransformer = findValueAction(AllTransformers);
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type UseDefaultFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => ((defaultValue: any) => IValueOperator) | undefined | symbol;
-const findUseDefault: UseDefaultFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	if (!base.$allowUseDefault || !['orUseDefault', 'useDefault', 'withDefault', 'orElse', 'else'].includes(prop)) {
-		return NOT_FOUND;
-	}
-	if ((base.$actions == null || base.$actions.length === 0)) {
-		// no action defined, use default value directly, no way
-		return (void 0);
-	}
-	base.$allowMoreAction = false;
-	base.$allowUseDefault = false;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return (defaultValue: any) => {
-		base.$defaultUsed = true;
-		base.$defaultValue = defaultValue;
-		return operator;
-	};
-};
-type ValueFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => (<T>() => T) | undefined | symbol;
-const createValueRetrieveFunc = (base: ValueOperatorBase) => {
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return <T>(): ValueActionPassed<T> | ValueActionFailed<any> => {
-		const tested = {test: true, value: base.$value};
-		for (const action of (base.$actions ?? [])) {
-			const result = action(tested.value);
-			if (!result.test) {
-				// failed on action proceeding, ignore all tailing actions, and use original value
-				tested.test = false;
-				tested.value = base.$value;
-				break;
-			} else {
-				// action proceeded successfully
-				tested.value = result.value;
-			}
-		}
-		if (tested.test) {
-			// all actions proceeded, and value might be transformed, do nothing
-		} else if (base.$defaultUsed) {
-			// failed on action proceeding, use default value if defined
-			// therefore, final result has been treated as success
-			tested.test = true;
-			tested.value = base.$defaultValue as T;
-		} else {
-			// failed on acton proceeding, and no default value defined, return value itself
-			tested.value = base.$value;
-		}
-		return tested;
-	};
-};
-const findValue: ValueFind = (_operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	if (prop !== 'value') {
-		return NOT_FOUND;
-	}
-	if ((base.$actions == null || base.$actions.length === 0)) {
-		// no action defined, get value directly, no way
-		return (void 0);
-	}
-	// return value anyway, no matter success or failure
-	return <T>(): T => createValueRetrieveFunc(base)<T>().value;
-};
-type SuccessCallback = (callback: <T>(value: T) => void) => ({ failure: (callback: <V>(value: V) => void) => void });
-type FailureCallback = (callback: <V>(value: V) => void) => ({ success: (callback: <T>(value: T) => void) => void });
-type SuccessOrFailureCallbackFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => SuccessCallback | FailureCallback | undefined | symbol;
-const findSuccessOrFailureCallback: SuccessOrFailureCallbackFind = (_operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	if (prop !== 'success' && prop !== 'failure') {
-		return NOT_FOUND;
-	}
-	if ((base.$actions == null || base.$actions.length === 0)) {
-		// no action defined, get value directly, no way
-		return (void 0);
-	}
-	switch (prop) {
-		case 'success':
-			return (callback: <T>(value: T) => void) => {
-				const tested = createValueRetrieveFunc(base)();
-				if (tested.test) {
-					callback(tested.value);
-				}
-				return {
-					failure: (callback: <T>(value: T) => void): void => {
-						if (!tested.test) {
-							callback(tested.value);
-						}
-					}
-				};
-			};
-		case 'failure':
-			return (callback: <V>(value: V) => void) => {
-				const tested = createValueRetrieveFunc(base)();
-				if (!tested.test) {
-					callback(tested.value);
-				}
-				return {
-					success: (callback: <T>(value: T) => void): void => {
-						if (tested.test) {
-							callback(tested.value);
-						}
-					}
-				};
-			};
-		default:
-			throw new Error(`Unknown callback type: ${prop}.`);
-	}
-};
-type OKFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => (() => boolean) | symbol;
-const findOK: OKFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	if (prop !== 'ok') {
-		return NOT_FOUND;
-	}
-	if ((base.$actions == null || base.$actions.length === 0)) {
-		// no action defined, get value directly, no way
-		return (void 0);
-	}
-	return (): boolean => createValueRetrieveFunc(base)().test;
-};
-type PromiseFind = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => (<T>() => Promise<T>) | symbol;
-const findPromise: PromiseFind = (_operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	if (prop !== 'promise') {
-		return NOT_FOUND;
-	}
-	if ((base.$actions == null || base.$actions.length === 0)) {
-		// no action defined, get value directly, no way
-		return (void 0);
-	}
-	return async <T>(): Promise<T> => {
-		const tested = createValueRetrieveFunc(base)();
-		if (tested.test) {
-			return Promise.resolve(tested.value as T);
-		} else {
-			return Promise.reject(tested.value);
-		}
-	};
-};
-const getFromOperator = (operator: IValueOperator, base: ValueOperatorBase, prop: string) => {
-	// set to false anyway
-	base.$allowNoParamFuncCall = false;
-	const finds = [
-		findTester, findTransformer, findUseDefault,
-		findValue, findSuccessOrFailureCallback, findOK, findPromise
-	];
-	for (const find of finds) {
-		const result = find(operator, base, prop);
-		if (result !== NOT_FOUND) {
-			return result;
-		}
-	}
-	// not found, return undefined
-	return (void 0);
-};
-const createOperator = (base: ValueOperatorBase): IValueOperator => {
-	const operatorBase = () => {
-	};
-	operatorBase.$base = base;
-	const operator = new Proxy(operatorBase, {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-		apply(base: typeof operatorBase, _thisArg: any, _argArray: any[]): any {
-			return applyOperator(operator, base.$base);
-		},
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-		get(base: any, p: string, _receiver: any): any {
-			return getFromOperator(operator, base.$base, p);
-		}
-	});
-	return operator;
-};
-
-export interface FinalValueRetriever {
-	value: <T>() => T;
-	success: <T>(value: T) => { failure: <V>(value: V) => void };
-	failure: <V>(value: V) => { success: <T>(value: T) => void };
-	ok: () => boolean;
-	// parameter of reject original value
-	promise: <T>() => Promise<T>;
-}
-
-export interface DefaultValueSetter extends FinalValueRetriever {
-	// once, or ignored
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	orUseDefault: (defaultValue: any) => FinalValueRetriever;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	useDefault: (defaultValue: any) => FinalValueRetriever;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	withDefault: (defaultValue: any) => FinalValueRetriever;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	orElse: (defaultValue: any) => FinalValueRetriever;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	else: (defaultValue: any) => FinalValueRetriever;
-}
-
-type ActionType<T> = T extends RegisteredValueAction
-	? (ValueActionsWithDefault & (() => ValueActionsWithDefault))
-	: T extends RegisteredValueActionWithParams ? ((...args: Parameters<T['func']>) => ValueActionsWithDefault) : never;
-export type ValueActions =
-	& { [K in keyof typeof AllTesters]: ActionType<typeof AllTesters[K]> }
-	& { [K in keyof typeof AllTransformers]: ActionType<typeof AllTransformers[K]> };
-export type ValueActionsWithDefault = ValueActions & DefaultValueSetter;
-
-export type IValueOperator = ValueActions;
-
-export interface IValueOperatorBoostrap {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	of(value: any): IValueOperator;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	from(value: any): IValueOperator;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	with(value: any): IValueOperator;
-}
-
-@StaticImplements<IValueOperatorBoostrap>()
-class ValueOperatorBootstrap {
-	// noinspection JSUnusedLocalSymbols
-	private constructor() {
-		// avoid extend
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public static of(value: any): IValueOperator {
-		return createOperator({
-			$value: value,
-			$allowMoreAction: true, $allowUseDefault: false, $defaultUsed: false,
-			$allowNoParamFuncCall: false
-		});
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public static from(value: any): IValueOperator {
-		return ValueOperatorBootstrap.of(value);
-	}
-
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	public static with(value: any): IValueOperator {
-		return ValueOperatorBootstrap.of(value);
-	}
-}
-
-export const ValueOperator: IValueOperatorBoostrap = ValueOperatorBootstrap;

package/src/lib/pipeline/value-operators/action-types.ts

@@ -1,8 +0,0 @@
-export type ValueActionPassed<V> = { test: true, value: V };
-export type ValueActionFailed<V> = { test: false, value: V };
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ValueAction<From = any, To = any> = (value?: From) => ValueActionPassed<To> | ValueActionFailed<From>;
-export type RegisteredValueAction = { type: 'func', func: ValueAction }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type RegisteredValueActionWithParams<F = (...args: Array<any>) => ValueAction> = { type: 'param', func: F };
-export const OBJECT_PROTOTYPE = Object.prototype;

package/src/lib/pipeline/value-operators/index.ts

@@ -1,10 +0,0 @@
-export * from './action-types';
-
-export * from './test-any-actions';
-export * from './test-string-actions';
-export * from './test-decimal-actions';
-export * from './testers';
-
-export * from './transform-string-actions';
-export * from './transform-decimal-actions';
-export * from './transformers';

package/src/lib/pipeline/value-operators/test-any-actions.ts

@@ -1,58 +0,0 @@
-import {OBJECT_PROTOTYPE, ValueAction} from './action-types';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isLength = (value: any): boolean => {
-	return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isArrayLike = (value: any): boolean => {
-	return value != null && typeof value !== 'function' && isLength(value.length);
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isPrototype = (value: any): boolean => {
-	const Ctor = value && value.constructor;
-	const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
-
-	return value === proto;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isNull: ValueAction<any, null | undefined> = (value?: any) => {
-	return value == null
-		? {test: true, value: value as null | undefined}
-		: {test: false, value};
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isNotNull: ValueAction<any, NonNullable<any>> = (value?: any) => ({test: !isNull(value).test, value});
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isEmpty: ValueAction = (value?: any) => {
-	if (value == null) {
-		return {test: true, value: value as null | undefined};
-	}
-	let length: number | null = null;
-	if (isArrayLike(value) && (Array.isArray(value) || typeof value === 'string')) {
-		length = value.length;
-	} else if (value instanceof Map) {
-		length = value.size;
-	} else if (value instanceof Set) {
-		length = value.size;
-	} else if (isPrototype(value)) {
-		length = Object.keys(value).length;
-	}
-	return {test: length === 0, value};
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isNotEmpty: ValueAction = (value?: any) => ({test: !isEmpty(value).test, value});
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isBlank: ValueAction<any, null | undefined | string> = (value?: any) => {
-	switch (true) {
-		case (value == null):
-			return {test: true, value: value as null | undefined};
-		case (typeof value === 'string' && value.trim().length === 0):
-			return {test: true, value: value as string};
-		default:
-			return {test: false, value};
-	}
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isNotBlank: ValueAction = (value?: any) => ({test: !isBlank(value).test, value});