@rainbow-o23/n1 1.0.49 → 1.0.50

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

@@ -0,0 +1,307 @@
+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/step-helpers.ts

@@ -1,21 +1,8 @@
 import dayjs from 'dayjs';
-import * as math from 'mathjs';
-import {
-	CatchableError,
-	Config,
-	DateTime,
-	ErrorCodes,
-	ExposedUncatchableError,
-	Logger,
-	UncatchableError
-} from '../utils';
-import {
-	PIPELINE_STEP_RETURN_NULL,
-	PipelineStepErrorOptions,
-	PipelineStepFile,
-	PipelineStepFileOptions,
-	StepHelpersUtils
-} from './step-helpers-utils';
+import Decimal from 'decimal.js';
+import {all, create, MathJsInstance} from 'mathjs';
+import {Config, DateTime, ErrorCodes, Logger} from '../utils';
+import {IStepHelpersUtils, PipelineStepErrorOptions, StepHelpersUtils} from './step-helpers-utils';
 
 export class PipelineStepDateHelper {
 	private readonly _dateTimeFormat: string;
@@ -37,42 +24,19 @@ export class PipelineStepDateHelper {
 	}
 }
 
-export type PipelineStepMathHelper = typeof math;
+export type PipelineStepMathHelper = MathJsInstance;
+export type PipelineStepDecimalHelper = (value: Decimal.Value) => Decimal;
 
-export interface PipelineStepHelpers {
+export interface PipelineStepHelpers extends IStepHelpersUtils {
 	$config?: Config;
 	$logger?: Logger;
 	$date: PipelineStepDateHelper;
 	$math: PipelineStepMathHelper;
-	$nano: (size?: number) => string;
-	$ascii: (size?: number) => string;
+	$decimal: PipelineStepDecimalHelper;
+
 	/** create an exposed uncatchable error*/
 	$error: (options: PipelineStepErrorOptions) => never;
 	$errorCodes: Readonly<Record<string, string>>;
-	$errors: {
-		catchable: (options: Omit<PipelineStepErrorOptions, 'status'>) => never;
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		isCatchable: (e: any) => e is CatchableError;
-		exposed: (options: PipelineStepErrorOptions) => never;
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		isExposed: (e: any) => e is ExposedUncatchableError;
-		uncatchable: (options: Omit<PipelineStepErrorOptions, 'status'>) => never;
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		isUncatchable: (e: any) => e is UncatchableError;
-	};
-	/** create a file */
-	$file: (options: PipelineStepFileOptions) => PipelineStepFile;
-	$clearContextData: () => typeof PIPELINE_STEP_RETURN_NULL;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	isEmpty: (value: any) => boolean;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	isNotEmpty: (value: any) => boolean;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	isBlank: (value: any) => boolean;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	isNotBlank: (value: any) => boolean;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	trim: (value: any) => string;
 
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	[key: string]: any;
@@ -84,13 +48,15 @@ export const registerToStepHelpers = (helpers: Record<string, any>) => {
 	RegisteredHelpers.helpers = helpers ?? {};
 };
 
-export const createStepHelpers = (config: Config, logger: Logger): PipelineStepHelpers => {
-	return {
+const mathjs = create(all, {number: 'BigNumber', precision: 32});
+export const createStepHelpers = (config: Config, logger: Logger): Readonly<PipelineStepHelpers> => {
+	const helpers: PipelineStepHelpers = {
 		...RegisteredHelpers.helpers,
 		$config: config, $logger: logger,
 		// date
 		$date: new PipelineStepDateHelper(config),
-		$math: math,
+		$math: mathjs,
+		$decimal: (value: Decimal.Value) => new Decimal(value),
 		// nano
 		$nano: StepHelpersUtils.$nano, $ascii: StepHelpersUtils.$ascii,
 		// errors
@@ -98,12 +64,20 @@ export const createStepHelpers = (config: Config, logger: Logger): PipelineStepH
 		$errorCodes: ErrorCodes,
 		$errors: StepHelpersUtils.$errors,
 		// file
-		$file: StepHelpersUtils.createFile,
+		$file: StepHelpersUtils.$file,
 		// semaphore
 		$clearContextData: StepHelpersUtils.$clearContextData,
 		// utilities
 		isEmpty: StepHelpersUtils.isEmpty, isNotEmpty: StepHelpersUtils.isNotEmpty,
 		isBlank: StepHelpersUtils.isBlank, isNotBlank: StepHelpersUtils.isNotBlank,
-		trim: StepHelpersUtils.trim
+		trim: StepHelpersUtils.trim,
+		touch: StepHelpersUtils.touch,
+		noop: StepHelpersUtils.noop, asyncNoop: StepHelpersUtils.asyncNoop
 	};
+	return new Proxy(helpers, {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+		set(_target: PipelineStepHelpers, _p: string | symbol, _value: any, _receiver: any): boolean {
+			return false;
+		}
+	});
 };

package/src/lib/pipeline/types.ts

@@ -0,0 +1,7 @@
+export const StaticImplements = <T>() => {
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	return <U extends T>(_constructor: U) => {
+		// since only one static method, no need to execute constructor anymore
+		// constructor;
+	};
+};

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

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

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

@@ -0,0 +1,58 @@
+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});

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

@@ -0,0 +1,85 @@
+import Decimal from 'decimal.js';
+import {ValueAction} from './action-types';
+import {toDecimal} from './transform-decimal-actions';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isDecimal: ValueAction<any, Decimal> = (value?: any) => {
+	const {test, value: decimal} = toDecimal(value);
+	return {test, value: test ? decimal : value};
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isInteger: ValueAction<any, Decimal> = (value?: any) => {
+	const {test, value: decimal} = toDecimal(value);
+	return (test && decimal.isInteger()) ? {test: true, value: decimal} : {test: false, value};
+};
+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; })
+/**
+ * @param options.min value of range, might be included or not
+ * @param options.max max value of range, might be included or not
+ * @param options.interval closed, c -> [min, max]; open, o -> (min, max); left-open, lo -> (min, max]; right-open, ro -> [min, max)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isInRange = (options: DecimalInRangeOptions): ValueAction<any, Decimal> => {
+	const {min, max, interval = 'closed'} = options;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return (value?: any) => {
+		const {test, value: decimal} = toDecimal(value);
+		if (!test) {
+			return {test: false, value};
+		}
+		let pass = false;
+		switch (interval) {
+			case 'open':
+			case 'o':
+				pass = (min == null || decimal.gt(min)) && (max == null || decimal.lt(max));
+				break;
+			case 'left-open':
+			case 'lo':
+				pass = (min == null || decimal.gt(min)) && (max == null || decimal.lte(max));
+				break;
+			case 'right-open':
+			case 'ro':
+				pass = (min == null || decimal.gte(min)) && (max == null || decimal.lt(max));
+				break;
+			case 'closed':
+			case 'c':
+			default:
+				pass = (min == null || decimal.gte(min)) && (max == null || decimal.lte(max));
+				break;
+		}
+		return pass ? {test: true, value: decimal} : {test: false, value};
+	};
+};
+export const isPositive = isInRange({min: 0, interval: 'left-open'});
+export const isNotPositive = isInRange({max: 0});
+export const isNegative = isInRange({max: 0, interval: 'right-open'});
+export const isNotNegative = isInRange({min: 0});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isZero: ValueAction<any, Decimal> = (value?: any) => {
+	const {test, value: decimal} = toDecimal(value);
+	return (test && decimal.isZero()) ? {test: true, value: decimal} : {test: false, value};
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isNotZero: ValueAction<any, Decimal> = (value?: any) => {
+	const {test, value: decimal} = toDecimal(value);
+	return (test && !decimal.isZero()) ? {test: true, value: decimal} : {test: false, value};
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isGreaterThan = (compare: Decimal.Value): ValueAction<any, Decimal> => {
+	return isInRange({min: compare, interval: 'left-open'});
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isGreaterThanOrEqual = (compare: Decimal.Value): ValueAction<any, Decimal> => {
+	return isInRange({min: compare});
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isLessThan = (compare: Decimal.Value): ValueAction<any, Decimal> => {
+	return isInRange({max: compare, interval: 'right-open'});
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isLessThanOrEqual = (compare: Decimal.Value): ValueAction<any, Decimal> => {
+	return isInRange({max: compare});
+};

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

@@ -0,0 +1,15 @@
+import {ValueAction} from './action-types';
+
+export const regexp = (regexp: RegExp): ValueAction => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	return (value?: any) => {
+		if (value == null) {
+			return {test: false, value};
+		}
+		const type = typeof value;
+		if (['string', 'number', 'bigint'].includes(type)) {
+			return {test: regexp.test(value), value};
+		}
+		return {test: false, value};
+	};
+};

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

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