@rainbow-o23/n1 1.0.50 → 1.0.51

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

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

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

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

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

@@ -1,88 +0,0 @@
-import Decimal from 'decimal.js';
-import {ValueAction} from './action-types';
-
-export 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'
-}
-
-const ToDecimalJsRounding = {
-	[Rounding.ROUND_UP]: Decimal.ROUND_UP,
-	[Rounding.ROUND_DOWN]: Decimal.ROUND_DOWN,
-	[Rounding.ROUND_CEIL]: Decimal.ROUND_CEIL,
-	[Rounding.ROUND_FLOOR]: Decimal.ROUND_FLOOR,
-	[Rounding.ROUND_HALF_UP]: Decimal.ROUND_HALF_UP,
-	[Rounding.ROUND_HALF_DOWN]: Decimal.ROUND_HALF_DOWN,
-	[Rounding.ROUND_HALF_EVEN]: Decimal.ROUND_HALF_EVEN,
-	[Rounding.ROUND_HALF_CEIL]: Decimal.ROUND_HALF_CEIL,
-	[Rounding.ROUND_HALF_FLOOR]: Decimal.ROUND_HALF_FLOOR
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const toDecimal: ValueAction<any, Decimal> = (value?: any) => {
-	if (value == null) {
-		return {test: false, value};
-	} else if (value instanceof Decimal) {
-		return {test: true, value};
-	} else if (['string', 'number'].includes(typeof value)) {
-		try {
-			return {test: true, value: new Decimal(value)};
-		} catch {
-			return {test: false, value};
-		}
-	} else {
-		return {test: false, value};
-	}
-};
-/**
- * May cause precision loss or value truncation.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const toNumber: ValueAction<any, number> = (value?: any) => {
-	const {test, value: parsed} = toDecimal(value);
-	if (!test) {
-		return {test: false, value};
-	}
-	return {test: true, value: parsed.toNumber()};
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const toFixed = (fractionDigits: number, rounding: Rounding = Rounding.ROUND_HALF_UP): ValueAction<any, string> => {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return (value?: any) => {
-		const {test, value: parsed} = toDecimal(value);
-		if (!test) {
-			return {test: false, value};
-		}
-		return {test: true, value: parsed.toFixed(fractionDigits, ToDecimalJsRounding[rounding])};
-	};
-};
-const baseRound = (rounding: Rounding = Rounding.ROUND_HALF_UP) => {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	return (fractionDigits: number): ValueAction<any, Decimal> => {
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		return (value?: any) => {
-			const {test, value: parsed} = toDecimal(value);
-			if (!test) {
-				return {test: false, value};
-			}
-			return {test: true, value: parsed.toDecimalPlaces(fractionDigits, ToDecimalJsRounding[rounding])};
-		};
-	};
-};
-/** half up */
-export const roundUp = baseRound(Rounding.ROUND_HALF_UP);
-/** half down */
-export const roundDown = baseRound(Rounding.ROUND_HALF_DOWN);
-export const floor = baseRound(Rounding.ROUND_FLOOR);
-export const ceil = baseRound(Rounding.ROUND_CEIL);
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const roundBy = (fractionDigits: number, rounding: Rounding = Rounding.ROUND_HALF_UP): ValueAction<any, Decimal> => {
-	return baseRound(rounding)(fractionDigits);
-};

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

@@ -1,49 +0,0 @@
-import {ValueAction} from './action-types';
-
-/**
- * always pass, and trim if given value is string
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const trim: ValueAction = (value?: any) => {
-	if (value == null) {
-		return {test: true, value};
-	} else if (typeof value === 'string') {
-		return {test: true, value: value.trim()};
-	} else {
-		return {test: true, value};
-	}
-};
-export type PadOptions = {
-	length: number;
-	char?: string;
-	direction?: 'left' | 'right';
-}
-/**
- * return value must be a string if padding could perform, otherwise return given value itself no matter what it is.
- * could perform means performed, or not performed when length of given value is greater than or equal to given length.
- */
-export const pad = (options: PadOptions): ValueAction => {
-	const {length, char = ' ', direction = 'right'} = options;
-	// 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', 'boolean'].includes(type)) {
-			const stringified = `${value}`;
-			const len = stringified.length;
-			if (len >= length) {
-				return {test: true, value: stringified};
-			}
-			return {
-				test: true,
-				value: direction === 'left' ? stringified.padStart(length, char) : stringified.padEnd(length, char)
-			};
-		} else {
-			return {test: false, value};
-		}
-	};
-};
-export const padStart = (options: Omit<PadOptions, 'direction'>): ValueAction => pad({...options, direction: 'left'});
-export const padEnd = (options: Omit<PadOptions, 'direction'>): ValueAction => pad({...options, direction: 'right'});

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

@@ -1,34 +0,0 @@
-import {RegisteredValueAction, RegisteredValueActionWithParams} from './action-types';
-import {ceil, floor, roundBy, roundDown, roundUp, toDecimal, toFixed, toNumber} from './transform-decimal-actions';
-import {pad, padEnd, padStart, trim} from './transform-string-actions';
-
-const transformers = {
-	// string
-	trim: {type: 'func', func: trim} as RegisteredValueAction,
-	pad: {type: 'param', func: pad} as RegisteredValueActionWithParams<typeof pad>,
-	padStart: {type: 'param', func: padStart} as RegisteredValueActionWithParams<typeof padStart>,
-	padLeft: {type: 'param', func: padStart} as RegisteredValueActionWithParams<typeof padStart>,
-	lpad: {type: 'param', func: padStart} as RegisteredValueActionWithParams<typeof padStart>,
-	padEnd: {type: 'param', func: padEnd} as RegisteredValueActionWithParams<typeof padEnd>,
-	padRight: {type: 'param', func: padEnd} as RegisteredValueActionWithParams<typeof padEnd>,
-	rpad: {type: 'param', func: padEnd} as RegisteredValueActionWithParams<typeof padEnd>,
-	// decimal
-	toDecimal: {type: 'func', func: toDecimal} as RegisteredValueAction,
-	toNumber: {type: 'func', func: toNumber} as RegisteredValueAction,
-	toFixed0: {type: 'func', func: toFixed(0)} as RegisteredValueAction,
-	toFixed1: {type: 'func', func: toFixed(1)} as RegisteredValueAction,
-	toFixed2: {type: 'func', func: toFixed(2)} as RegisteredValueAction,
-	toFixed3: {type: 'func', func: toFixed(3)} as RegisteredValueAction,
-	toFixed4: {type: 'func', func: toFixed(4)} as RegisteredValueAction,
-	toFixed5: {type: 'func', func: toFixed(5)} as RegisteredValueAction,
-	toFixed6: {type: 'func', func: toFixed(6)} as RegisteredValueAction,
-	// decimal with params
-	toFixed: {type: 'param', func: toFixed} as RegisteredValueActionWithParams<typeof toFixed>,
-	round: {type: 'param', func: roundUp} as RegisteredValueActionWithParams<typeof roundUp>,
-	roundUp: {type: 'param', func: roundUp} as RegisteredValueActionWithParams<typeof roundUp>,
-	roundDown: {type: 'param', func: roundDown} as RegisteredValueActionWithParams<typeof roundDown>,
-	floor: {type: 'param', func: floor} as RegisteredValueActionWithParams<typeof floor>,
-	ceil: {type: 'param', func: ceil} as RegisteredValueActionWithParams<typeof ceil>,
-	roundBy: {type: 'param', func: roundBy} as RegisteredValueActionWithParams<typeof roundBy>
-};
-export const AllTransformers: Readonly<typeof transformers> = transformers;