@rainbow-o23/n1 1.0.50 → 1.0.51

package/index.cjs

@@ -1,29 +1,11 @@
 'use strict';
 
-var dayjs = require('dayjs');
-var ArraySupport = require('dayjs/plugin/arraySupport.js');
-var CustomParseFormat = require('dayjs/plugin/customParseFormat.js');
-var Duration = require('dayjs/plugin/duration.js');
-var IsToday = require('dayjs/plugin/isToday.js');
-var ObjectSupport = require('dayjs/plugin/objectSupport.js');
-var QuarterOfYear = require('dayjs/plugin/quarterOfYear.js');
-var RelativeTime = require('dayjs/plugin/relativeTime.js');
-var UTC = require('dayjs/plugin/utc.js');
-var WeekOfYear = require('dayjs/plugin/weekOfYear.js');
+var n1 = require('@rainbow-n19/n1');
 var nanoid = require('nanoid');
+var dayjs = require('dayjs');
 var Decimal = require('decimal.js');
 var mathjs$1 = require('mathjs');
 
-dayjs.extend(WeekOfYear);
-dayjs.extend(QuarterOfYear);
-dayjs.extend(Duration);
-dayjs.extend(IsToday);
-dayjs.extend(RelativeTime);
-dayjs.extend(ArraySupport);
-dayjs.extend(ObjectSupport);
-dayjs.extend(CustomParseFormat);
-dayjs.extend(UTC);
-
 const ERR_PIPELINE_NOT_FOUND = 'O01-00001';
 const ERR_TRIM_NON_STRING = 'O01-00002';
 const ERR_DUPLICATED_ERROR_CODE = 'O01-00002';
@@ -436,516 +418,6 @@ const StaticImplements = () => {
     };
 };
 
-const OBJECT_PROTOTYPE = Object.prototype;
-
-const isLength = (value) => {
-    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
-};
-const isArrayLike = (value) => {
-    return value != null && typeof value !== 'function' && isLength(value.length);
-};
-const isPrototype = (value) => {
-    const Ctor = value && value.constructor;
-    const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
-    return value === proto;
-};
-const isNull = (value) => {
-    return value == null
-        ? { test: true, value: value }
-        : { test: false, value };
-};
-const isNotNull = (value) => ({ test: !isNull(value).test, value });
-const isEmpty = (value) => {
-    if (value == null) {
-        return { test: true, value: value };
-    }
-    let length = 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 };
-};
-const isNotEmpty = (value) => ({ test: !isEmpty(value).test, value });
-const isBlank = (value) => {
-    switch (true) {
-        case (value == null):
-            return { test: true, value: value };
-        case (typeof value === 'string' && value.trim().length === 0):
-            return { test: true, value: value };
-        default:
-            return { test: false, value };
-    }
-};
-const isNotBlank = (value) => ({ test: !isBlank(value).test, value });
-
-const regexp = (regexp) => {
-    return (value) => {
-        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 };
-    };
-};
-
-exports.Rounding = void 0;
-(function (Rounding) {
-    Rounding["ROUND_UP"] = "up";
-    Rounding["ROUND_DOWN"] = "down";
-    Rounding["ROUND_CEIL"] = "ceil";
-    Rounding["ROUND_FLOOR"] = "floor";
-    Rounding["ROUND_HALF_UP"] = "half-up";
-    Rounding["ROUND_HALF_DOWN"] = "half-down";
-    Rounding["ROUND_HALF_EVEN"] = "half-even";
-    Rounding["ROUND_HALF_CEIL"] = "half-ceil";
-    Rounding["ROUND_HALF_FLOOR"] = "half-floor";
-})(exports.Rounding || (exports.Rounding = {}));
-const ToDecimalJsRounding = {
-    [exports.Rounding.ROUND_UP]: Decimal.ROUND_UP,
-    [exports.Rounding.ROUND_DOWN]: Decimal.ROUND_DOWN,
-    [exports.Rounding.ROUND_CEIL]: Decimal.ROUND_CEIL,
-    [exports.Rounding.ROUND_FLOOR]: Decimal.ROUND_FLOOR,
-    [exports.Rounding.ROUND_HALF_UP]: Decimal.ROUND_HALF_UP,
-    [exports.Rounding.ROUND_HALF_DOWN]: Decimal.ROUND_HALF_DOWN,
-    [exports.Rounding.ROUND_HALF_EVEN]: Decimal.ROUND_HALF_EVEN,
-    [exports.Rounding.ROUND_HALF_CEIL]: Decimal.ROUND_HALF_CEIL,
-    [exports.Rounding.ROUND_HALF_FLOOR]: Decimal.ROUND_HALF_FLOOR
-};
-const toDecimal = (value) => {
-    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 };
-    }
-};
-const toNumber = (value) => {
-    const { test, value: parsed } = toDecimal(value);
-    if (!test) {
-        return { test: false, value };
-    }
-    return { test: true, value: parsed.toNumber() };
-};
-const toFixed = (fractionDigits, rounding = exports.Rounding.ROUND_HALF_UP) => {
-    return (value) => {
-        const { test, value: parsed } = toDecimal(value);
-        if (!test) {
-            return { test: false, value };
-        }
-        return { test: true, value: parsed.toFixed(fractionDigits, ToDecimalJsRounding[rounding]) };
-    };
-};
-const baseRound = (rounding = exports.Rounding.ROUND_HALF_UP) => {
-    return (fractionDigits) => {
-        return (value) => {
-            const { test, value: parsed } = toDecimal(value);
-            if (!test) {
-                return { test: false, value };
-            }
-            return { test: true, value: parsed.toDecimalPlaces(fractionDigits, ToDecimalJsRounding[rounding]) };
-        };
-    };
-};
-const roundUp = baseRound(exports.Rounding.ROUND_HALF_UP);
-const roundDown = baseRound(exports.Rounding.ROUND_HALF_DOWN);
-const floor = baseRound(exports.Rounding.ROUND_FLOOR);
-const ceil = baseRound(exports.Rounding.ROUND_CEIL);
-const roundBy = (fractionDigits, rounding = exports.Rounding.ROUND_HALF_UP) => {
-    return baseRound(rounding)(fractionDigits);
-};
-
-const isDecimal = (value) => {
-    const { test, value: decimal } = toDecimal(value);
-    return { test, value: test ? decimal : value };
-};
-const isInteger = (value) => {
-    const { test, value: decimal } = toDecimal(value);
-    return (test && decimal.isInteger()) ? { test: true, value: decimal } : { test: false, value };
-};
-const isInRange = (options) => {
-    const { min, max, interval = 'closed' } = options;
-    return (value) => {
-        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 };
-    };
-};
-const isPositive = isInRange({ min: 0, interval: 'left-open' });
-const isNotPositive = isInRange({ max: 0 });
-const isNegative = isInRange({ max: 0, interval: 'right-open' });
-const isNotNegative = isInRange({ min: 0 });
-const isZero = (value) => {
-    const { test, value: decimal } = toDecimal(value);
-    return (test && decimal.isZero()) ? { test: true, value: decimal } : { test: false, value };
-};
-const isNotZero = (value) => {
-    const { test, value: decimal } = toDecimal(value);
-    return (test && !decimal.isZero()) ? { test: true, value: decimal } : { test: false, value };
-};
-const isGreaterThan = (compare) => {
-    return isInRange({ min: compare, interval: 'left-open' });
-};
-const isGreaterThanOrEqual = (compare) => {
-    return isInRange({ min: compare });
-};
-const isLessThan = (compare) => {
-    return isInRange({ max: compare, interval: 'right-open' });
-};
-const isLessThanOrEqual = (compare) => {
-    return isInRange({ max: compare });
-};
-
-const testers = {
-    isNull: { type: 'func', func: isNull },
-    isNotNull: { type: 'func', func: isNotNull },
-    isEmpty: { type: 'func', func: isEmpty },
-    isNotEmpty: { type: 'func', func: isNotEmpty },
-    isBlank: { type: 'func', func: isBlank },
-    isNotBlank: { type: 'func', func: isNotBlank },
-    regexp: { type: 'param', func: regexp },
-    regex: { type: 'param', func: regexp },
-    matches: { type: 'param', func: regexp },
-    isNumber: { type: 'func', func: isDecimal },
-    isDecimal: { type: 'func', func: isDecimal },
-    isInteger: { type: 'func', func: isInteger },
-    isInt: { type: 'func', func: isInteger },
-    isPositive: { type: 'func', func: isPositive },
-    isNotPositive: { type: 'func', func: isNotPositive },
-    isNegative: { type: 'func', func: isNegative },
-    isNotNegative: { type: 'func', func: isNotNegative },
-    isZero: { type: 'func', func: isZero },
-    isNotZero: { type: 'func', func: isNotZero },
-    isGreaterThan: { type: 'param', func: isGreaterThan },
-    gt: { type: 'param', func: isGreaterThan },
-    isGreaterThanOrEqual: {
-        type: 'param', func: isGreaterThanOrEqual
-    },
-    gte: { type: 'param', func: isGreaterThanOrEqual },
-    isLessThan: { type: 'param', func: isLessThan },
-    lt: { type: 'param', func: isLessThan },
-    isLessThanOrEqual: {
-        type: 'param', func: isLessThanOrEqual
-    },
-    lte: { type: 'param', func: isLessThanOrEqual },
-    isInRange: { type: 'param', func: isInRange },
-    within: { type: 'param', func: isInRange }
-};
-const AllTesters = testers;
-
-const trim = (value) => {
-    if (value == null) {
-        return { test: true, value };
-    }
-    else if (typeof value === 'string') {
-        return { test: true, value: value.trim() };
-    }
-    else {
-        return { test: true, value };
-    }
-};
-const pad = (options) => {
-    const { length, char = ' ', direction = 'right' } = options;
-    return (value) => {
-        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 };
-        }
-    };
-};
-const padStart = (options) => pad({ ...options, direction: 'left' });
-const padEnd = (options) => pad({ ...options, direction: 'right' });
-
-const transformers = {
-    trim: { type: 'func', func: trim },
-    pad: { type: 'param', func: pad },
-    padStart: { type: 'param', func: padStart },
-    padLeft: { type: 'param', func: padStart },
-    lpad: { type: 'param', func: padStart },
-    padEnd: { type: 'param', func: padEnd },
-    padRight: { type: 'param', func: padEnd },
-    rpad: { type: 'param', func: padEnd },
-    toDecimal: { type: 'func', func: toDecimal },
-    toNumber: { type: 'func', func: toNumber },
-    toFixed0: { type: 'func', func: toFixed(0) },
-    toFixed1: { type: 'func', func: toFixed(1) },
-    toFixed2: { type: 'func', func: toFixed(2) },
-    toFixed3: { type: 'func', func: toFixed(3) },
-    toFixed4: { type: 'func', func: toFixed(4) },
-    toFixed5: { type: 'func', func: toFixed(5) },
-    toFixed6: { type: 'func', func: toFixed(6) },
-    toFixed: { type: 'param', func: toFixed },
-    round: { type: 'param', func: roundUp },
-    roundUp: { type: 'param', func: roundUp },
-    roundDown: { type: 'param', func: roundDown },
-    floor: { type: 'param', func: floor },
-    ceil: { type: 'param', func: ceil },
-    roundBy: { type: 'param', func: roundBy }
-};
-const AllTransformers = transformers;
-
-var ValueOperatorBootstrap_1;
-const applyOperator = (operator, base) => {
-    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');
-const findValueAction = (actions) => {
-    return (operator, base, prop) => {
-        const tester = actions[prop];
-        if (tester == null) {
-            return NOT_FOUND;
-        }
-        base.$allowUseDefault = true;
-        if (base.$actions == null) {
-            base.$actions = [];
-        }
-        if (tester.type === 'func') {
-            base.$actions.push(tester.func);
-            base.$allowNoParamFuncCall = true;
-            return operator;
-        }
-        else if (tester.type === 'param') {
-            return (...args) => {
-                base.$actions.push(tester.func(...args));
-                return operator;
-            };
-        }
-        else {
-            throw new Error(`Unknown tester type: ${tester}.`);
-        }
-    };
-};
-const findTester = findValueAction(AllTesters);
-const findTransformer = findValueAction(AllTransformers);
-const findUseDefault = (operator, base, prop) => {
-    if (!base.$allowUseDefault || !['orUseDefault', 'useDefault', 'withDefault', 'orElse', 'else'].includes(prop)) {
-        return NOT_FOUND;
-    }
-    if ((base.$actions == null || base.$actions.length === 0)) {
-        return (void 0);
-    }
-    base.$allowMoreAction = false;
-    base.$allowUseDefault = false;
-    return (defaultValue) => {
-        base.$defaultUsed = true;
-        base.$defaultValue = defaultValue;
-        return operator;
-    };
-};
-const createValueRetrieveFunc = (base) => {
-    return () => {
-        const tested = { test: true, value: base.$value };
-        for (const action of (base.$actions ?? [])) {
-            const result = action(tested.value);
-            if (!result.test) {
-                tested.test = false;
-                tested.value = base.$value;
-                break;
-            }
-            else {
-                tested.value = result.value;
-            }
-        }
-        if (tested.test) ;
-        else if (base.$defaultUsed) {
-            tested.test = true;
-            tested.value = base.$defaultValue;
-        }
-        else {
-            tested.value = base.$value;
-        }
-        return tested;
-    };
-};
-const findValue = (_operator, base, prop) => {
-    if (prop !== 'value') {
-        return NOT_FOUND;
-    }
-    if ((base.$actions == null || base.$actions.length === 0)) {
-        return (void 0);
-    }
-    return () => createValueRetrieveFunc(base)().value;
-};
-const findSuccessOrFailureCallback = (_operator, base, prop) => {
-    if (prop !== 'success' && prop !== 'failure') {
-        return NOT_FOUND;
-    }
-    if ((base.$actions == null || base.$actions.length === 0)) {
-        return (void 0);
-    }
-    switch (prop) {
-        case 'success':
-            return (callback) => {
-                const tested = createValueRetrieveFunc(base)();
-                if (tested.test) {
-                    callback(tested.value);
-                }
-                return {
-                    failure: (callback) => {
-                        if (!tested.test) {
-                            callback(tested.value);
-                        }
-                    }
-                };
-            };
-        case 'failure':
-            return (callback) => {
-                const tested = createValueRetrieveFunc(base)();
-                if (!tested.test) {
-                    callback(tested.value);
-                }
-                return {
-                    success: (callback) => {
-                        if (tested.test) {
-                            callback(tested.value);
-                        }
-                    }
-                };
-            };
-        default:
-            throw new Error(`Unknown callback type: ${prop}.`);
-    }
-};
-const findOK = (operator, base, prop) => {
-    if (prop !== 'ok') {
-        return NOT_FOUND;
-    }
-    if ((base.$actions == null || base.$actions.length === 0)) {
-        return (void 0);
-    }
-    return () => createValueRetrieveFunc(base)().test;
-};
-const findPromise = (_operator, base, prop) => {
-    if (prop !== 'promise') {
-        return NOT_FOUND;
-    }
-    if ((base.$actions == null || base.$actions.length === 0)) {
-        return (void 0);
-    }
-    return async () => {
-        const tested = createValueRetrieveFunc(base)();
-        if (tested.test) {
-            return Promise.resolve(tested.value);
-        }
-        else {
-            return Promise.reject(tested.value);
-        }
-    };
-};
-const getFromOperator = (operator, base, prop) => {
-    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;
-        }
-    }
-    return (void 0);
-};
-const createOperator = (base) => {
-    const operatorBase = () => {
-    };
-    operatorBase.$base = base;
-    const operator = new Proxy(operatorBase, {
-        apply(base, _thisArg, _argArray) {
-            return applyOperator(operator, base.$base);
-        },
-        get(base, p, _receiver) {
-            return getFromOperator(operator, base.$base, p);
-        }
-    });
-    return operator;
-};
-let ValueOperatorBootstrap = ValueOperatorBootstrap_1 = class ValueOperatorBootstrap {
-    constructor() {
-    }
-    static of(value) {
-        return createOperator({
-            $value: value,
-            $allowMoreAction: true, $allowUseDefault: false, $defaultUsed: false,
-            $allowNoParamFuncCall: false
-        });
-    }
-    static from(value) {
-        return ValueOperatorBootstrap_1.of(value);
-    }
-    static with(value) {
-        return ValueOperatorBootstrap_1.of(value);
-    }
-};
-ValueOperatorBootstrap = ValueOperatorBootstrap_1 = __decorate([
-    StaticImplements()
-], ValueOperatorBootstrap);
-const ValueOperator = ValueOperatorBootstrap;
-
 var StepHelpersUtils_1;
 const PIPELINE_STEP_FILE_SYMBOL = Symbol();
 const PIPELINE_STEP_RETURN_NULL = Symbol();
@@ -997,27 +469,25 @@ exports.StepHelpersUtils = class StepHelpersUtils {
         return PIPELINE_STEP_RETURN_NULL;
     }
     static isPrototype(value) {
-        const Ctor = value && value.constructor;
-        const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
-        return value === proto;
+        return n1.isPrototype(value);
     }
     static isLength(value) {
-        return isLength(value);
+        return n1.isLength(value);
     }
     static isArrayLike(value) {
-        return isArrayLike(value);
+        return n1.isArrayLike(value);
     }
     static isEmpty(value) {
-        return isEmpty(value).test;
+        return n1.ValueOperator.of(value).isEmpty().ok();
     }
     static isNotEmpty(value) {
-        return isNotEmpty(value).test;
+        return n1.ValueOperator.of(value).isNotEmpty().ok();
     }
     static isBlank(value) {
-        return isBlank(value).test;
+        return n1.ValueOperator.of(value).isBlank().ok();
     }
     static isNotBlank(value) {
-        return isNotBlank(value).test;
+        return n1.ValueOperator.of(value).isNotBlank().ok();
     }
     static trim(value) {
         if (value == null) {
@@ -1029,7 +499,7 @@ exports.StepHelpersUtils = class StepHelpersUtils {
         throw new UncatchableError(ERR_TRIM_NON_STRING, `Cannot apply trim to non-string object[type=${typeof value}, value=${value}].`);
     }
     static touch(value) {
-        return ValueOperator.from(value);
+        return n1.ValueOperator.of(value);
     }
     static noop() {
     }
@@ -1317,8 +787,6 @@ exports.AbstractPipeline = AbstractPipeline;
 exports.AbstractPipelineExecution = AbstractPipelineExecution;
 exports.AbstractPipelineStep = AbstractPipelineStep;
 exports.AbstractStaticPipeline = AbstractStaticPipeline;
-exports.AllTesters = AllTesters;
-exports.AllTransformers = AllTransformers;
 exports.CatchableError = CatchableError;
 exports.Config = Config;
 exports.ConsoleLogger = ConsoleLogger;
@@ -1333,51 +801,14 @@ exports.ErrorCodes = ErrorCodes;
 exports.ExposedUncatchableError = ExposedUncatchableError;
 exports.LoggerPerformanceSaver = LoggerPerformanceSaver;
 exports.LoggerUtils = LoggerUtils;
-exports.OBJECT_PROTOTYPE = OBJECT_PROTOTYPE;
 exports.PIPELINE_STEP_FILE_SYMBOL = PIPELINE_STEP_FILE_SYMBOL;
 exports.PIPELINE_STEP_RETURN_NULL = PIPELINE_STEP_RETURN_NULL;
 exports.PerformanceExecution = PerformanceExecution;
 exports.PipelineRepository = PipelineRepository;
 exports.PipelineStepDateHelper = PipelineStepDateHelper;
 exports.UncatchableError = UncatchableError;
-exports.ValueOperator = ValueOperator;
-exports.ceil = ceil;
 exports.createConfig = createConfig;
 exports.createLogger = createLogger;
 exports.createStepHelpers = createStepHelpers;
-exports.floor = floor;
-exports.isArrayLike = isArrayLike;
-exports.isBlank = isBlank;
-exports.isDecimal = isDecimal;
-exports.isEmpty = isEmpty;
-exports.isGreaterThan = isGreaterThan;
-exports.isGreaterThanOrEqual = isGreaterThanOrEqual;
-exports.isInRange = isInRange;
-exports.isInteger = isInteger;
-exports.isLength = isLength;
-exports.isLessThan = isLessThan;
-exports.isLessThanOrEqual = isLessThanOrEqual;
-exports.isNegative = isNegative;
-exports.isNotBlank = isNotBlank;
-exports.isNotEmpty = isNotEmpty;
-exports.isNotNegative = isNotNegative;
-exports.isNotNull = isNotNull;
-exports.isNotPositive = isNotPositive;
-exports.isNotZero = isNotZero;
-exports.isNull = isNull;
-exports.isPositive = isPositive;
-exports.isPrototype = isPrototype;
-exports.isZero = isZero;
-exports.pad = pad;
-exports.padEnd = padEnd;
-exports.padStart = padStart;
-exports.regexp = regexp;
 exports.registerToStepHelpers = registerToStepHelpers;
-exports.roundBy = roundBy;
-exports.roundDown = roundDown;
-exports.roundUp = roundUp;
 exports.saveLoggerPerformance = saveLoggerPerformance;
-exports.toDecimal = toDecimal;
-exports.toFixed = toFixed;
-exports.toNumber = toNumber;
-exports.trim = trim;