@rainbow-o23/n1 1.0.49 → 1.0.50

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

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

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

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

package/test/value-test.test.ts

@@ -0,0 +1,55 @@
+// noinspection ES6PreferShortImport
+
+import Decimal from 'decimal.js';
+import * as math from 'mathjs';
+import {ValueOperator as VO} from '../src/lib/pipeline/step-helpers-value-operator';
+
+describe('Value test chain', () => {
+	test('Test 1', async () => {
+		expect(VO.from('abc').isNotBlank().orUseDefault('default').value()).toEqual('abc');
+		expect(VO.from('').isNotBlank.withDefault('default').value()).toEqual('default');
+		expect(VO.from('123').isNumber().toFixed(2).value()).toEqual('123.00');
+		expect(VO.from(void 0).isNumber.useDefault(100).value()).toEqual(100);
+		expect(VO.with(123).isInt.toFixed2.value()).toEqual('123.00');
+		expect(VO.of('123.45').within({min: 100, max: 200}).toFixed3().orElse(150).value()).toEqual('123.450');
+		console.log({
+			'math: number, 5.0000000000000001': math.isInteger(5.0000000000000001),
+			'math: string, 5.0000000000000001': math.isInteger('5.0000000000000001' as any),
+			'decimal: number, 5.0000000000000001': new Decimal(5.0000000000000001).isInteger(),
+			'decimal: string, 5.0000000000000001': new Decimal('5.0000000000000001').isInteger(),
+			'math: 0.1 + 0.2': math.chain(0.1).add(0.2).done(),
+			'math: add("0.1 + 0.2")': math.evaluate('0.1 + 0.2'),
+			'decimal: 0.1 + 0.2': new Decimal(0.1).add(0.2).toNumber()
+		});
+
+		VO.of(123).isPositive
+			.success((value: number) => console.log('isPositive', value))
+			.failure((value: number) => console.log('isNotPositive', value));
+		VO.of(-123).isPositive
+			.success((value: number) => console.log('isPositive', value))
+			.failure((value: number) => console.log('isNotPositive', value));
+		expect(VO.of(123).isPositive.ok()).toEqual(true);
+		expect(VO.of(-123).isPositive.ok()).toEqual(false);
+		try {
+			const v = await VO.of(123).isPositive.toNumber.promise();
+			expect(v).toEqual(123);
+			await VO.of(-123).isPositive.promise();
+		} catch (v) {
+			expect(v).toEqual(-123);
+		}
+
+		// console.log(new Decimal({} as any).isInteger());
+		interface AskImportConfigRequest {
+			type?: string;
+			pageSize?: number;
+			pageNumber?: number;
+		}
+
+		const {type, pageSize, pageNumber} = {} as AskImportConfigRequest;
+		const criteria: AskImportConfigRequest = {type};
+		criteria.pageSize = VO.of(pageSize).isPositive.toFixed0.toNumber.orUseDefault(20).value();
+		criteria.pageNumber = VO.of(pageNumber).isPositive.toFixed0.toNumber.orUseDefault(1).value();
+	});
+
+	afterAll((done) => done());
+});