@hotmeshio/hotmesh 0.0.8 → 0.0.10

package/build/esm/services/pipe/functions/date.js

@@ -1,164 +0,0 @@
-class DateHandler {
-    /**
-     * It is so common in mapping operations to use a string (ISO) date as input. This helper
-     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
-     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
-     * @param input
-     * @returns
-     */
-    static getDateInstance(input) {
-        const ISO_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/;
-        if (typeof input === 'string') {
-            if (ISO_REGEX.test(input)) {
-                return new Date(input);
-            }
-            const milliseconds = parseInt(input, 10);
-            if (!isNaN(milliseconds)) {
-                return new Date(milliseconds);
-            }
-        }
-        else if (input instanceof Date) {
-            return input;
-        }
-        else if (typeof input === 'number') {
-            return new Date(input);
-        }
-        throw new Error("Invalid date format");
-    }
-    fromISOString(isoString) {
-        return new Date(isoString);
-    }
-    now() {
-        return Date.now();
-    }
-    parse(dateString) {
-        return Date.parse(dateString);
-    }
-    getDate(date) {
-        return DateHandler.getDateInstance(date).getDate();
-    }
-    getDay(date) {
-        return DateHandler.getDateInstance(date).getDay();
-    }
-    getFullYear(date) {
-        return DateHandler.getDateInstance(date).getFullYear();
-    }
-    getHours(date) {
-        return DateHandler.getDateInstance(date).getHours();
-    }
-    getMilliseconds(date) {
-        return DateHandler.getDateInstance(date).getMilliseconds();
-    }
-    getMinutes(date) {
-        return DateHandler.getDateInstance(date).getMinutes();
-    }
-    getMonth(date) {
-        return DateHandler.getDateInstance(date).getMonth();
-    }
-    getSeconds(date) {
-        return DateHandler.getDateInstance(date).getSeconds();
-    }
-    getTime(date) {
-        return DateHandler.getDateInstance(date).getTime();
-    }
-    getTimezoneOffset(date) {
-        return DateHandler.getDateInstance(date).getTimezoneOffset();
-    }
-    getUTCDate(date) {
-        return DateHandler.getDateInstance(date).getUTCDate();
-    }
-    getUTCDay(date) {
-        return DateHandler.getDateInstance(date).getUTCDay();
-    }
-    getUTCFullYear(date) {
-        return DateHandler.getDateInstance(date).getUTCFullYear();
-    }
-    getUTCHours(date) {
-        return DateHandler.getDateInstance(date).getUTCHours();
-    }
-    getUTCMilliseconds(date) {
-        return DateHandler.getDateInstance(date).getUTCMilliseconds();
-    }
-    getUTCMinutes(date) {
-        return DateHandler.getDateInstance(date).getUTCMinutes();
-    }
-    getUTCMonth(date) {
-        return DateHandler.getDateInstance(date).getUTCMonth();
-    }
-    getUTCSeconds(date) {
-        return DateHandler.getDateInstance(date).getUTCSeconds();
-    }
-    setMilliseconds(date, ms) {
-        return DateHandler.getDateInstance(date).setMilliseconds(ms);
-    }
-    setMinutes(date, minutes, seconds, ms) {
-        return DateHandler.getDateInstance(date).setMinutes(minutes, seconds, ms);
-    }
-    setMonth(date, month, day) {
-        return DateHandler.getDateInstance(date).setMonth(month, day);
-    }
-    setSeconds(date, seconds, ms) {
-        return DateHandler.getDateInstance(date).setSeconds(seconds, ms);
-    }
-    setTime(date, time) {
-        return DateHandler.getDateInstance(date).setTime(time);
-    }
-    setUTCDate(date, day) {
-        return DateHandler.getDateInstance(date).setUTCDate(day);
-    }
-    setUTCFullYear(date, year, month, day) {
-        return DateHandler.getDateInstance(date).setUTCFullYear(year, month, day);
-    }
-    setUTCHours(date, hours, minutes, seconds, ms) {
-        return DateHandler.getDateInstance(date).setUTCHours(hours, minutes, seconds, ms);
-    }
-    setUTCMilliseconds(date, ms) {
-        return DateHandler.getDateInstance(date).setUTCMilliseconds(ms);
-    }
-    setUTCMinutes(date, minutes, seconds, ms) {
-        return DateHandler.getDateInstance(date).setUTCMinutes(minutes, seconds, ms);
-    }
-    setUTCMonth(date, month, day) {
-        return DateHandler.getDateInstance(date).setUTCMonth(month, day);
-    }
-    setUTCSeconds(date, seconds, ms) {
-        return DateHandler.getDateInstance(date).setUTCSeconds(seconds, ms);
-    }
-    setDate(date, day) {
-        return DateHandler.getDateInstance(date).setDate(day);
-    }
-    setFullYear(date, year, month, day) {
-        return DateHandler.getDateInstance(date).setFullYear(year, month, day);
-    }
-    setHours(date, hours, minutes, seconds, ms) {
-        return DateHandler.getDateInstance(date).setHours(hours, minutes, seconds, ms);
-    }
-    toDateString(date) {
-        return DateHandler.getDateInstance(date).toDateString();
-    }
-    toISOString(date) {
-        return DateHandler.getDateInstance(date).toISOString();
-    }
-    toJSON(date) {
-        return DateHandler.getDateInstance(date).toJSON();
-    }
-    toLocaleDateString(date, locales, options) {
-        return DateHandler.getDateInstance(date).toLocaleDateString(locales, options);
-    }
-    toLocaleString(date, locales, options) {
-        return DateHandler.getDateInstance(date).toLocaleString(locales, options);
-    }
-    toLocaleTimeString(date, locales, options) {
-        return DateHandler.getDateInstance(date).toLocaleTimeString(locales, options);
-    }
-    toString(date) {
-        return DateHandler.getDateInstance(date).toString();
-    }
-    UTC(year, month, date, hours, minutes, seconds, ms) {
-        return Date.UTC(year, month, date, hours, minutes, seconds, ms);
-    }
-    valueOf(date) {
-        return DateHandler.getDateInstance(date).valueOf();
-    }
-}
-export { DateHandler };

package/build/esm/services/pipe/functions/index.d.ts

@@ -1,25 +0,0 @@
-import { ArrayHandler } from './array';
-import { BitwiseHandler } from './bitwise';
-import { ConditionalHandler } from './conditional';
-import { DateHandler } from './date';
-import { JsonHandler } from './json';
-import { MathHandler } from './math';
-import { NumberHandler } from './number';
-import { ObjectHandler } from './object';
-import { StringHandler } from './string';
-import { SymbolHandler } from './symbol';
-import { UnaryHandler } from './unary';
-declare const _default: {
-    array: ArrayHandler;
-    bitwise: BitwiseHandler;
-    conditional: ConditionalHandler;
-    date: DateHandler;
-    json: JsonHandler;
-    math: MathHandler;
-    number: NumberHandler;
-    object: ObjectHandler;
-    string: StringHandler;
-    symbol: SymbolHandler;
-    unary: UnaryHandler;
-};
-export default _default;

package/build/esm/services/pipe/functions/index.js

@@ -1,24 +0,0 @@
-import { ArrayHandler } from './array';
-import { BitwiseHandler } from './bitwise';
-import { ConditionalHandler } from './conditional';
-import { DateHandler } from './date';
-import { JsonHandler } from './json';
-import { MathHandler } from './math';
-import { NumberHandler } from './number';
-import { ObjectHandler } from './object';
-import { StringHandler } from './string';
-import { SymbolHandler } from './symbol';
-import { UnaryHandler } from './unary';
-export default {
-    array: new ArrayHandler(),
-    bitwise: new BitwiseHandler(),
-    conditional: new ConditionalHandler(),
-    date: new DateHandler(),
-    json: new JsonHandler(),
-    math: new MathHandler(),
-    number: new NumberHandler(),
-    object: new ObjectHandler(),
-    string: new StringHandler(),
-    symbol: new SymbolHandler(),
-    unary: new UnaryHandler(),
-};

package/build/esm/services/pipe/functions/json.d.ts

@@ -1,5 +0,0 @@
-declare class JsonHandler {
-    stringify(value: any, replacer?: (this: any, key: string, value: any) => any | (number | string)[] | null, space?: string | number): string;
-    parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
-}
-export { JsonHandler };

package/build/esm/services/pipe/functions/json.js

@@ -1,9 +0,0 @@
-class JsonHandler {
-    stringify(value, replacer, space) {
-        return JSON.stringify(value, replacer, space);
-    }
-    parse(text, reviver) {
-        return JSON.parse(text, reviver);
-    }
-}
-export { JsonHandler };

package/build/esm/services/pipe/functions/math.d.ts

@@ -1,38 +0,0 @@
-declare class MathHandler {
-    abs(x: number): number;
-    acos(x: number): number;
-    acosh(x: number): number;
-    asin(x: number): number;
-    asinh(x: number): number;
-    atan(x: number): number;
-    atan2(y: number, x: number): number;
-    atanh(x: number): number;
-    cbrt(x: number): number;
-    ceil(x: number): number;
-    clz32(x: number): number;
-    cos(x: number): number;
-    cosh(x: number): number;
-    exp(x: number): number;
-    expm1(x: number): number;
-    floor(x: number): number;
-    fround(x: number): number;
-    hypot(...values: number[]): number;
-    imul(x: number, y: number): number;
-    log(x: number): number;
-    log10(x: number): number;
-    log1p(x: number): number;
-    log2(x: number): number;
-    max(...values: number[]): number;
-    min(...values: number[]): number;
-    pow(x: number, y: number): number;
-    random(): number;
-    round(x: number): number;
-    sign(x: number): number;
-    sin(x: number): number;
-    sinh(x: number): number;
-    sqrt(x: number): number;
-    tan(x: number): number;
-    tanh(x: number): number;
-    trunc(x: number): number;
-}
-export { MathHandler };

package/build/esm/services/pipe/functions/math.js

@@ -1,108 +0,0 @@
-class MathHandler {
-    abs(x) {
-        return Math.abs(x);
-    }
-    acos(x) {
-        return Math.acos(x);
-    }
-    acosh(x) {
-        return Math.acosh(x);
-    }
-    asin(x) {
-        return Math.asin(x);
-    }
-    asinh(x) {
-        return Math.asinh(x);
-    }
-    atan(x) {
-        return Math.atan(x);
-    }
-    atan2(y, x) {
-        return Math.atan2(y, x);
-    }
-    atanh(x) {
-        return Math.atanh(x);
-    }
-    cbrt(x) {
-        return Math.cbrt(x);
-    }
-    ceil(x) {
-        return Math.ceil(x);
-    }
-    clz32(x) {
-        return Math.clz32(x);
-    }
-    cos(x) {
-        return Math.cos(x);
-    }
-    cosh(x) {
-        return Math.cosh(x);
-    }
-    exp(x) {
-        return Math.exp(x);
-    }
-    expm1(x) {
-        return Math.expm1(x);
-    }
-    floor(x) {
-        return Math.floor(x);
-    }
-    fround(x) {
-        return Math.fround(x);
-    }
-    hypot(...values) {
-        return Math.hypot(...values);
-    }
-    imul(x, y) {
-        return Math.imul(x, y);
-    }
-    log(x) {
-        return Math.log(x);
-    }
-    log10(x) {
-        return Math.log10(x);
-    }
-    log1p(x) {
-        return Math.log1p(x);
-    }
-    log2(x) {
-        return Math.log2(x);
-    }
-    max(...values) {
-        return Math.max(...values);
-    }
-    min(...values) {
-        return Math.min(...values);
-    }
-    pow(x, y) {
-        return Math.pow(x, y);
-    }
-    random() {
-        return Math.random();
-    }
-    round(x) {
-        return Math.round(x);
-    }
-    sign(x) {
-        return Math.sign(x);
-    }
-    sin(x) {
-        return Math.sin(x);
-    }
-    sinh(x) {
-        return Math.sinh(x);
-    }
-    sqrt(x) {
-        return Math.sqrt(x);
-    }
-    tan(x) {
-        return Math.tan(x);
-    }
-    tanh(x) {
-        return Math.tanh(x);
-    }
-    trunc(x) {
-        return Math.trunc(x);
-    }
-}
-export { MathHandler };

package/build/esm/services/pipe/functions/number.d.ts

@@ -1,25 +0,0 @@
-declare class NumberHandler {
-    isFinite(input: number): boolean;
-    isEven(input: number): boolean;
-    isOdd(input: number): boolean;
-    isInteger(input: number): boolean;
-    isNaN(input: number): boolean;
-    parseFloat(input: string): number;
-    parseInt(input: string, radix?: number): number;
-    toFixed(input: number, digits?: number): string;
-    toExponential(input: number, fractionalDigits?: number): string;
-    toPrecision(input: number, precision?: number): string;
-    gte(input: number, compareValue: number): boolean;
-    lte(input: number, compareValue: number): boolean;
-    gt(input: number, compareValue: number): boolean;
-    lt(input: number, compareValue: number): boolean;
-    max(...values: number[]): number;
-    min(...values: number[]): number;
-    pow(base: number, exponent: number): number;
-    round(input: number): number;
-    add(...operands: (number | number[])[]): number;
-    subtract(...operands: (number | number[])[]): number;
-    multiply(...operands: (number | number[])[]): number;
-    divide(...operands: (number | number[])[]): number;
-}
-export { NumberHandler };

package/build/esm/services/pipe/functions/number.js

@@ -1,130 +0,0 @@
-class NumberHandler {
-    isFinite(input) {
-        return Number.isFinite(input);
-    }
-    isEven(input) {
-        return !isNaN(input) && input % 2 === 0;
-    }
-    isOdd(input) {
-        return !isNaN(input) && input % 2 !== 0;
-    }
-    isInteger(input) {
-        return Number.isInteger(input);
-    }
-    isNaN(input) {
-        return Number.isNaN(input);
-    }
-    parseFloat(input) {
-        return parseFloat(input);
-    }
-    parseInt(input, radix) {
-        return parseInt(input, radix);
-    }
-    toFixed(input, digits) {
-        return input.toFixed(digits);
-    }
-    toExponential(input, fractionalDigits) {
-        return input.toExponential(fractionalDigits);
-    }
-    toPrecision(input, precision) {
-        return input.toPrecision(precision);
-    }
-    gte(input, compareValue) {
-        return input >= compareValue;
-    }
-    lte(input, compareValue) {
-        return input <= compareValue;
-    }
-    gt(input, compareValue) {
-        return input > compareValue;
-    }
-    lt(input, compareValue) {
-        return input < compareValue;
-    }
-    max(...values) {
-        return Math.max(...values);
-    }
-    min(...values) {
-        return Math.min(...values);
-    }
-    pow(base, exponent) {
-        return Math.pow(base, exponent);
-    }
-    round(input) {
-        return Math.round(input);
-    }
-    add(...operands) {
-        // @ts-ignore
-        return operands.reduce((a, b) => {
-            if (Array.isArray(b)) {
-                return a + this.add(...b);
-            }
-            else {
-                return a + b;
-            }
-        }, 0);
-    }
-    subtract(...operands) {
-        if (operands.length === 0) {
-            throw new Error('At least one operand is required.');
-        }
-        let flatOperands = [];
-        operands.forEach((op) => {
-            if (Array.isArray(op)) {
-                flatOperands = [...flatOperands, ...op];
-            }
-            else {
-                flatOperands.push(op);
-            }
-        });
-        if (flatOperands.length === 0) {
-            throw new Error('At least one operand is required after flattening.');
-        }
-        const result = flatOperands.reduce((a, b, i) => {
-            return i === 0 ? a : a - b;
-        });
-        return result;
-    }
-    multiply(...operands) {
-        if (operands.length === 0) {
-            throw new Error('At least one operand is required.');
-        }
-        // @ts-ignore
-        return operands.reduce((a, b) => {
-            if (Array.isArray(b)) {
-                return a * this.multiply(...b);
-            }
-            else {
-                return a * b;
-            }
-        }, 1);
-    }
-    divide(...operands) {
-        if (operands.length === 0) {
-            throw new Error('At least one operand is required.');
-        }
-        let flatOperands = [];
-        operands.forEach((op) => {
-            if (Array.isArray(op)) {
-                flatOperands = [...flatOperands, ...op];
-            }
-            else {
-                flatOperands.push(op);
-            }
-        });
-        if (flatOperands.length === 0) {
-            throw new Error('At least one operand is required after flattening.');
-        }
-        const result = flatOperands.reduce((a, b, i) => {
-            if (b === 0) {
-                return NaN;
-            }
-            return i === 0 ? a : a / b;
-        });
-        if (isNaN(result)) {
-            return NaN;
-        }
-        return result;
-    }
-}
-export { NumberHandler };

package/build/esm/services/pipe/functions/object.d.ts

@@ -1,22 +0,0 @@
-declare class ObjectHandler {
-    keys(obj: object): string[];
-    values(obj: object): any[];
-    entries(obj: object): [string, any][];
-    fromEntries(iterable: Iterable<[string, any]>): object;
-    assign(target: object, ...sources: object[]): object;
-    getOwnPropertyNames(obj: object): string[];
-    getOwnPropertySymbols(obj: object): symbol[];
-    getOwnPropertyDescriptor(obj: object, prop: string | symbol): PropertyDescriptor | undefined;
-    defineProperty(obj: object, prop: string | symbol, descriptor: PropertyDescriptor): object;
-    defineProperties(obj: object, props: PropertyDescriptorMap): object;
-    freeze(obj: object): object;
-    isFrozen(obj: object): boolean;
-    seal(obj: object): object;
-    isSealed(obj: object): boolean;
-    preventExtensions(obj: object): object;
-    isExtensible(obj: object): boolean;
-    hasOwnProperty(obj: object, prop: string | symbol): boolean;
-    isPrototypeOf(obj: object, prototypeObj: object): boolean;
-    propertyIsEnumerable(obj: object, prop: string | symbol): boolean;
-}
-export { ObjectHandler };

package/build/esm/services/pipe/functions/object.js

@@ -1,60 +0,0 @@
-class ObjectHandler {
-    keys(obj) {
-        return Object.keys(obj);
-    }
-    values(obj) {
-        return Object.values(obj);
-    }
-    entries(obj) {
-        return Object.entries(obj);
-    }
-    fromEntries(iterable) {
-        return Object.fromEntries(iterable);
-    }
-    assign(target, ...sources) {
-        return Object.assign(target, ...sources);
-    }
-    getOwnPropertyNames(obj) {
-        return Object.getOwnPropertyNames(obj);
-    }
-    getOwnPropertySymbols(obj) {
-        return Object.getOwnPropertySymbols(obj);
-    }
-    getOwnPropertyDescriptor(obj, prop) {
-        return Object.getOwnPropertyDescriptor(obj, prop);
-    }
-    defineProperty(obj, prop, descriptor) {
-        return Object.defineProperty(obj, prop, descriptor);
-    }
-    defineProperties(obj, props) {
-        return Object.defineProperties(obj, props);
-    }
-    freeze(obj) {
-        return Object.freeze(obj);
-    }
-    isFrozen(obj) {
-        return Object.isFrozen(obj);
-    }
-    seal(obj) {
-        return Object.seal(obj);
-    }
-    isSealed(obj) {
-        return Object.isSealed(obj);
-    }
-    preventExtensions(obj) {
-        return Object.preventExtensions(obj);
-    }
-    isExtensible(obj) {
-        return Object.isExtensible(obj);
-    }
-    hasOwnProperty(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    }
-    isPrototypeOf(obj, prototypeObj) {
-        return Object.prototype.isPrototypeOf.call(obj, prototypeObj);
-    }
-    propertyIsEnumerable(obj, prop) {
-        return Object.prototype.propertyIsEnumerable.call(obj, prop);
-    }
-}
-export { ObjectHandler };

package/build/esm/services/pipe/functions/string.d.ts

@@ -1,23 +0,0 @@
-declare class StringHandler {
-    split(input: string, delimiter: string): string[];
-    charAt(input: string, index: number): string;
-    concat(...strings: string[]): string;
-    includes(input: string, searchString: string, position?: number): boolean;
-    indexOf(input: string, searchString: string, fromIndex?: number): number;
-    lastIndexOf(input: string, searchString: string, fromIndex?: number): number;
-    slice(input: string, start?: number, end?: number): string;
-    toLowerCase(input: string): string;
-    toUpperCase(input: string): string;
-    trim(input: string): string;
-    trimStart(input: string): string;
-    trimEnd(input: string): string;
-    padStart(input: string, maxLength: number, padString?: string): string;
-    padEnd(input: string, maxLength: number, padString?: string): string;
-    replace(input: string, searchValue: string | RegExp, replaceValue: string): string;
-    search(input: string, regexp: RegExp): number;
-    substring(input: string, start: number, end?: number): string;
-    startsWith(str: string, searchString: string, position?: number): boolean;
-    endsWith(str: string, searchString: string, length?: number): boolean;
-    repeat(str: string, count: number): string;
-}
-export { StringHandler };