@hotmeshio/hotmesh 0.0.1

package/build/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/services/pipe/functions/math.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathHandler = void 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);
+    }
+}
+exports.MathHandler = MathHandler;

package/build/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/services/pipe/functions/number.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberHandler = void 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;
+    }
+}
+exports.NumberHandler = NumberHandler;

package/build/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/services/pipe/functions/object.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHandler = void 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);
+    }
+}
+exports.ObjectHandler = ObjectHandler;

package/build/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 };

package/build/services/pipe/functions/string.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringHandler = void 0;
+class StringHandler {
+    split(input, delimiter) {
+        return input.split(delimiter);
+    }
+    charAt(input, index) {
+        return input.charAt(index);
+    }
+    concat(...strings) {
+        return strings.join('');
+    }
+    includes(input, searchString, position) {
+        return input.includes(searchString, position);
+    }
+    indexOf(input, searchString, fromIndex) {
+        return input.indexOf(searchString, fromIndex);
+    }
+    lastIndexOf(input, searchString, fromIndex) {
+        return input.lastIndexOf(searchString, fromIndex);
+    }
+    slice(input, start, end) {
+        return input.slice(start, end);
+    }
+    toLowerCase(input) {
+        return input.toLowerCase();
+    }
+    toUpperCase(input) {
+        return input.toUpperCase();
+    }
+    trim(input) {
+        return input.trim();
+    }
+    trimStart(input) {
+        return input.trimStart();
+    }
+    trimEnd(input) {
+        return input.trimEnd();
+    }
+    padStart(input, maxLength, padString) {
+        return input.padStart(maxLength, padString);
+    }
+    padEnd(input, maxLength, padString) {
+        return input.padEnd(maxLength, padString);
+    }
+    replace(input, searchValue, replaceValue) {
+        return input.replace(searchValue, replaceValue);
+    }
+    search(input, regexp) {
+        return input.search(regexp);
+    }
+    substring(input, start, end) {
+        return input.substring(start, end);
+    }
+    startsWith(str, searchString, position) {
+        return str.startsWith(searchString, position);
+    }
+    endsWith(str, searchString, length) {
+        return str.endsWith(searchString, length);
+    }
+    repeat(str, count) {
+        if (count < 0 || count === Infinity) {
+            throw new RangeError('Invalid repeat count. Must be a positive finite number.');
+        }
+        return str.repeat(count);
+    }
+}
+exports.StringHandler = StringHandler;

package/build/services/pipe/functions/symbol.d.ts

@@ -0,0 +1,12 @@
+declare class SymbolHandler {
+    null(): null;
+    undefined(): undefined;
+    whitespace(): string;
+    object(): object;
+    array(): any[];
+    posInfinity(): number;
+    negInfinity(): number;
+    NaN(): number;
+    date(): Date;
+}
+export { SymbolHandler };

package/build/services/pipe/functions/symbol.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolHandler = void 0;
+class SymbolHandler {
+    null() {
+        return null;
+    }
+    undefined() {
+        return undefined;
+    }
+    whitespace() {
+        return ' ';
+    }
+    object() {
+        return {};
+    }
+    array() {
+        return [];
+    }
+    posInfinity() {
+        return Infinity;
+    }
+    negInfinity() {
+        return -Infinity;
+    }
+    NaN() {
+        return NaN;
+    }
+    date() {
+        return new Date();
+    }
+}
+exports.SymbolHandler = SymbolHandler;

package/build/services/pipe/functions/unary.d.ts

@@ -0,0 +1,7 @@
+declare class UnaryHandler {
+    not(value: boolean): boolean;
+    positive(value: number): number;
+    negative(value: number): number;
+    bitwise_not(value: number): number;
+}
+export { UnaryHandler };

package/build/services/pipe/functions/unary.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnaryHandler = void 0;
+class UnaryHandler {
+    not(value) {
+        return !value;
+    }
+    positive(value) {
+        return +value;
+    }
+    negative(value) {
+        return -value;
+    }
+    bitwise_not(value) {
+        return ~value;
+    }
+}
+exports.UnaryHandler = UnaryHandler;

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

@@ -0,0 +1,30 @@
+import { JobState, JobData } from '../../types/job';
+import { PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
+declare class Pipe {
+    rules: PipeType;
+    jobData: JobData;
+    constructor(rules: PipeType, jobData: JobData);
+    private isPipeType;
+    static isPipeObject(obj: {
+        [key: string]: unknown;
+    } | PipeItem): boolean;
+    static resolve(unresolved: {
+        [key: string]: unknown;
+    } | PipeItem, context: Partial<JobState>): any;
+    /**
+     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
+     * @returns {any} the result of the pipe
+     */
+    process(): any;
+    private processRow;
+    static resolveFunction(functionName: string): any;
+    processCells(cells: PipeItems): unknown[];
+    private isFunction;
+    private isMappable;
+    resolveCellValue(currentCell: PipeItem): unknown;
+    private getNestedProperty;
+    resolveMappableValue(currentCell: string): unknown;
+    resolveFunctionTerm(currentCell: string): string;
+    resolveMapTerm(currentCell: string): string;
+}
+export { Pipe };