@rainbow-o23/n1 1.0.50 → 1.0.51

package/index.js

@@ -1,27 +1,9 @@
-import dayjs from 'dayjs';
-import ArraySupport from 'dayjs/plugin/arraySupport.js';
-import CustomParseFormat from 'dayjs/plugin/customParseFormat.js';
-import Duration from 'dayjs/plugin/duration.js';
-import IsToday from 'dayjs/plugin/isToday.js';
-import ObjectSupport from 'dayjs/plugin/objectSupport.js';
-import QuarterOfYear from 'dayjs/plugin/quarterOfYear.js';
-import RelativeTime from 'dayjs/plugin/relativeTime.js';
-import UTC from 'dayjs/plugin/utc.js';
-import WeekOfYear from 'dayjs/plugin/weekOfYear.js';
+import { isPrototype, isLength, isArrayLike, ValueOperator } from '@rainbow-n19/n1';
 import { customAlphabet, nanoid } from 'nanoid';
+import dayjs from 'dayjs';
 import Decimal from 'decimal.js';
 import { create, all } from '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';
@@ -434,516 +416,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 };
-    };
-};
-
-var Rounding;
-(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";
-})(Rounding || (Rounding = {}));
-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
-};
-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 = 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 = 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(Rounding.ROUND_HALF_UP);
-const roundDown = baseRound(Rounding.ROUND_HALF_DOWN);
-const floor = baseRound(Rounding.ROUND_FLOOR);
-const ceil = baseRound(Rounding.ROUND_CEIL);
-const roundBy = (fractionDigits, rounding = 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();
@@ -995,9 +467,7 @@ let 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 isPrototype(value);
     }
     static isLength(value) {
         return isLength(value);
@@ -1006,16 +476,16 @@ let StepHelpersUtils = class StepHelpersUtils {
         return isArrayLike(value);
     }
     static isEmpty(value) {
-        return isEmpty(value).test;
+        return ValueOperator.of(value).isEmpty().ok();
     }
     static isNotEmpty(value) {
-        return isNotEmpty(value).test;
+        return ValueOperator.of(value).isNotEmpty().ok();
     }
     static isBlank(value) {
-        return isBlank(value).test;
+        return ValueOperator.of(value).isBlank().ok();
     }
     static isNotBlank(value) {
-        return isNotBlank(value).test;
+        return ValueOperator.of(value).isNotBlank().ok();
     }
     static trim(value) {
         if (value == null) {
@@ -1027,7 +497,7 @@ let 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 ValueOperator.of(value);
     }
     static noop() {
     }
@@ -1311,4 +781,4 @@ class PipelineRepository {
     }
 }
 
-export { AbstractPipeline, AbstractPipelineExecution, AbstractPipelineStep, AbstractStaticPipeline, AllTesters, AllTransformers, CatchableError, Config, ConsoleLogger, DefaultPipelineBuilder, DefaultPipelineStepBuilder, ERR_DUPLICATED_ERROR_CODE, ERR_PIPELINE_NOT_FOUND, ERR_TRIM_NON_STRING, ERR_UNKNOWN, EnhancedLogger, ErrorCodes, ExposedUncatchableError, LoggerPerformanceSaver, LoggerUtils, OBJECT_PROTOTYPE, PIPELINE_STEP_FILE_SYMBOL, PIPELINE_STEP_RETURN_NULL, PerformanceExecution, PipelineRepository, PipelineStepDateHelper, Rounding, StepHelpersUtils, UncatchableError, ValueOperator, ceil, createConfig, createLogger, createStepHelpers, floor, isArrayLike, isBlank, isDecimal, isEmpty, isGreaterThan, isGreaterThanOrEqual, isInRange, isInteger, isLength, isLessThan, isLessThanOrEqual, isNegative, isNotBlank, isNotEmpty, isNotNegative, isNotNull, isNotPositive, isNotZero, isNull, isPositive, isPrototype, isZero, pad, padEnd, padStart, regexp, registerToStepHelpers, roundBy, roundDown, roundUp, saveLoggerPerformance, toDecimal, toFixed, toNumber, trim };
+export { AbstractPipeline, AbstractPipelineExecution, AbstractPipelineStep, AbstractStaticPipeline, CatchableError, Config, ConsoleLogger, DefaultPipelineBuilder, DefaultPipelineStepBuilder, ERR_DUPLICATED_ERROR_CODE, ERR_PIPELINE_NOT_FOUND, ERR_TRIM_NON_STRING, ERR_UNKNOWN, EnhancedLogger, ErrorCodes, ExposedUncatchableError, LoggerPerformanceSaver, LoggerUtils, PIPELINE_STEP_FILE_SYMBOL, PIPELINE_STEP_RETURN_NULL, PerformanceExecution, PipelineRepository, PipelineStepDateHelper, StepHelpersUtils, UncatchableError, createConfig, createLogger, createStepHelpers, registerToStepHelpers, saveLoggerPerformance };

package/lib/envs.d.ts

@@ -1 +1 @@
-export {};
+import '@rainbow-n19/n1';

package/lib/pipeline/index.d.ts

@@ -1,7 +1,5 @@
 export * from './pipeline-execution';
 export * from './pipeline-step';
 export * from './pipeline';
-export * from './value-operators';
-export * from './step-helpers-value-operator';
 export * from './step-helpers-utils';
 export * from './step-helpers';

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

@@ -1,6 +1,6 @@
+import { IValueOperator } from '@rainbow-n19/n1';
 import { CatchableError, ExposedUncatchableError, UncatchableError } from '../utils';
 import { PipelineStepHelpers } from './step-helpers';
-import { IValueOperator } from './step-helpers-value-operator';
 export interface PipelineStepErrorOptions {
     status: number;
     code: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainbow-o23/n1",
-	"version": "1.0.50",
+	"version": "1.0.51",
 	"description": "o23 interfaces",
 	"main": "index.cjs",
 	"module": "index.js",
@@ -21,6 +21,7 @@
 		"url": "https://github.com/InsureMO/rainbow-o23/issues"
 	},
 	"dependencies": {
+		"@rainbow-n19/n1": "latest",
 		"dayjs": "^1.11.13",
 		"decimal.js": "^10.4.3",
 		"mathjs": "^13.2.1",

package/rollup.config.base.js

@@ -23,7 +23,10 @@ export const buildConfig = (lint) => {
 		].filter(x => x != null),
 		external(id) {
 			return ["dayjs/plugin/"].some(scope => id.startsWith(scope))
-				|| ['nanoid', 'dayjs', 'mathjs', 'decimal.js'].includes(id);
+				|| [
+					'@rainbow-n19/n1',
+					'nanoid', 'dayjs', 'mathjs', 'decimal.js'
+				].includes(id);
 		}
 	};
 };

package/src/lib/envs.ts

@@ -1,20 +1,2 @@
-import dayjs from 'dayjs';
-import ArraySupport from 'dayjs/plugin/arraySupport.js';
-import CustomParseFormat from 'dayjs/plugin/customParseFormat.js';
-import Duration from 'dayjs/plugin/duration.js';
-import IsToday from 'dayjs/plugin/isToday.js';
-import ObjectSupport from 'dayjs/plugin/objectSupport.js';
-import QuarterOfYear from 'dayjs/plugin/quarterOfYear.js';
-import RelativeTime from 'dayjs/plugin/relativeTime.js';
-import UTC from 'dayjs/plugin/utc.js';
-import WeekOfYear from 'dayjs/plugin/weekOfYear.js';
-
-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);
+// initial dayjs and decimal.js
+import '@rainbow-n19/n1';

package/src/lib/pipeline/index.ts

@@ -2,7 +2,5 @@ export * from './pipeline-execution';
 export * from './pipeline-step';
 export * from './pipeline';
 
-export * from './value-operators';
-export * from './step-helpers-value-operator';
 export * from './step-helpers-utils';
 export * from './step-helpers';