@hotmeshio/hotmesh 0.0.3 → 0.0.5

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

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

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

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

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

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

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

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

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

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

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

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

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