@hotmeshio/hotmesh 0.4.0 → 0.4.1

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

@@ -0,0 +1,60 @@
+"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);
+    }
+}
+exports.NumberHandler = NumberHandler;

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

@@ -0,0 +1,25 @@
+declare class ObjectHandler {
+    get(obj: object, prop: string | symbol): any;
+    set(obj: object, prop: string | symbol, value: any): any;
+    create(...args: any[]): object;
+    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,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHandler = void 0;
+class ObjectHandler {
+    get(obj, prop) {
+        return obj?.[prop];
+    }
+    set(obj, prop, value) {
+        if (!obj)
+            obj = {};
+        obj[prop] = value;
+        return obj;
+    }
+    create(...args) {
+        const obj = {};
+        if (args.length === 0)
+            return obj;
+        for (let i = 0; i < args.length; i += 2) {
+            obj[args[i]] = args[i + 1];
+        }
+        return obj;
+    }
+    keys(obj) {
+        return obj && Object.keys(obj) || [];
+    }
+    values(obj) {
+        return obj && Object.values(obj) || [];
+    }
+    entries(obj) {
+        return obj && 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,48 @@
+import { JobState, JobData } from '../../types/job';
+import { PipeContext, PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
+declare class Pipe {
+    rules: PipeType;
+    jobData: JobData;
+    context: PipeContext;
+    constructor(rules: PipeType, jobData: JobData, context?: PipeContext);
+    private isPipeType;
+    private isreduceType;
+    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(resolved?: unknown[] | null): any;
+    cloneUnknown<T>(value: T): T;
+    /**
+     * Transforms iterable `input` into a single value. Vars $output, $item, $key
+     * and $input are available. The final statement in the iterator (the reduction)
+     * is assumed to be the return value. A default $output object may be provided
+     * to the iterator by placing the the second cell of the preceding row. Otherwise,
+     * construct the object during first run and ensure it is the first cell of the
+     * last row of the iterator, so it is returned as the $output for the next cycle
+     * @param {unknown[]} input
+     * @returns {unknown}
+     * @private
+     */
+    reduce(input: Array<unknown[]>): unknown;
+    private processRow;
+    static resolveFunction(functionName: string): any;
+    processCells(cells: PipeItems): unknown[];
+    private isFunction;
+    private isContextVariable;
+    private isMappable;
+    resolveCellValue(currentCell: PipeItem): unknown;
+    private getNestedProperty;
+    resolveMappableValue(currentCell: string): unknown;
+    resolveContextValue(currentCell: string): unknown;
+    resolveContextTerm(currentCell: string): string;
+    resolveFunctionTerm(currentCell: string): string;
+    resolveMapTerm(currentCell: string): string;
+}
+export { Pipe };

package/build/services/pipe/index.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipe = void 0;
+const functions_1 = __importDefault(require("./functions"));
+class Pipe {
+    constructor(rules, jobData, context) {
+        this.rules = rules;
+        this.jobData = jobData;
+        this.context = context;
+    }
+    isPipeType(currentRow) {
+        return !Array.isArray(currentRow) && '@pipe' in currentRow;
+    }
+    isreduceType(currentRow) {
+        return !Array.isArray(currentRow) && '@reduce' in currentRow;
+    }
+    static isPipeObject(obj) {
+        return (typeof obj === 'object' &&
+            obj !== null &&
+            !Array.isArray(obj) &&
+            '@pipe' in obj);
+    }
+    static resolve(unresolved, context) {
+        let pipe;
+        if (Pipe.isPipeObject(unresolved)) {
+            pipe = new Pipe(unresolved['@pipe'], context);
+        }
+        else {
+            pipe = new Pipe([[unresolved]], context);
+        }
+        return pipe.process();
+    }
+    /**
+     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
+     * @returns {any} the result of the pipe
+     */
+    process(resolved = null) {
+        let index = 0;
+        if (!(resolved ||
+            this.isPipeType(this.rules[0]) ||
+            this.isreduceType(this.rules[0]))) {
+            resolved = this.processCells(this.rules[0]); // Add type assertion
+            index = 1;
+        }
+        const len = this.rules.length;
+        const subPipeQueue = [];
+        for (let i = index; i < len; i++) {
+            resolved = this.processRow(this.rules[i], resolved, subPipeQueue);
+        }
+        return resolved[0];
+    }
+    cloneUnknown(value) {
+        if (value === null || typeof value !== 'object') {
+            return value;
+        }
+        if (value instanceof Date) {
+            return new Date(value.getTime());
+        }
+        if (value instanceof RegExp) {
+            return new RegExp(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.cloneUnknown(item));
+        }
+        const clonedObj = {};
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                clonedObj[key] = this.cloneUnknown(value[key]);
+            }
+        }
+        return clonedObj;
+    }
+    /**
+     * Transforms iterable `input` into a single value. Vars $output, $item, $key
+     * and $input are available. The final statement in the iterator (the reduction)
+     * is assumed to be the return value. A default $output object may be provided
+     * to the iterator by placing the the second cell of the preceding row. Otherwise,
+     * construct the object during first run and ensure it is the first cell of the
+     * last row of the iterator, so it is returned as the $output for the next cycle
+     * @param {unknown[]} input
+     * @returns {unknown}
+     * @private
+     */
+    reduce(input) {
+        let resolved = this.cloneUnknown(input[1] ?? null);
+        if (Array.isArray(input[0])) {
+            for (let index = 0; index < input[0].length; index++) {
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][index],
+                    $key: index.toString(),
+                    $index: index,
+                };
+                resolved = this.process([resolved]);
+            }
+        }
+        else {
+            let index = -1;
+            for (const $key in input[0]) {
+                index++;
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][$key],
+                    $key,
+                    $index: index,
+                };
+                resolved = this.process([resolved]);
+            }
+        }
+        return [resolved];
+    }
+    processRow(currentRow, resolvedPriorRow, subPipeQueue) {
+        if (resolvedPriorRow && this.isreduceType(currentRow)) {
+            //reduce the resolvedPriorRow and return the output from the reducer
+            const subPipe = new Pipe(currentRow['@reduce'], this.jobData);
+            const reduced = subPipe.reduce(resolvedPriorRow);
+            return reduced;
+        }
+        else if (this.isPipeType(currentRow)) {
+            //process subPipe and push to subPipeQueue; echo resolvedPriorRow
+            const subPipe = new Pipe(currentRow['@pipe'], this.jobData, this.context);
+            subPipeQueue.push(subPipe.process());
+            return resolvedPriorRow;
+        }
+        else {
+            //pivot the subPipeQueue into the arguments array (resolvedPriorRow)
+            if (subPipeQueue.length > 0) {
+                resolvedPriorRow = [...subPipeQueue];
+                subPipeQueue.length = 0;
+            }
+            if (!resolvedPriorRow) {
+                //if no prior row, use current row as prior row
+                return [].concat(this.processCells(Array.isArray(currentRow) ? [...currentRow] : []));
+            }
+            else {
+                const [functionName, ...params] = currentRow; // Add type assertion
+                //use resolved values from prior row (n - 1) as input params to cell 1 function
+                let resolvedValue;
+                if (this.isContextVariable(functionName)) {
+                    resolvedValue = this.resolveContextValue(functionName);
+                }
+                else {
+                    resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
+                }
+                //resolve remaining cells in row and return concatenated with resolvedValue
+                return [resolvedValue].concat(this.processCells([...params]));
+            }
+        }
+    }
+    static resolveFunction(functionName) {
+        let [prefix, suffix] = functionName.split('.');
+        prefix = prefix.substring(2);
+        suffix = suffix.substring(0, suffix.length - 1);
+        const domain = functions_1.default[prefix];
+        if (!domain) {
+            throw new Error(`Unknown domain name [${functionName}]: ${prefix}`);
+        }
+        if (!domain[suffix]) {
+            throw new Error(`Unknown domain function [${functionName}]: ${prefix}.${suffix}`);
+        }
+        return domain[suffix];
+    }
+    processCells(cells) {
+        const resolved = [];
+        if (Array.isArray(cells)) {
+            for (const currentCell of cells) {
+                resolved.push(this.resolveCellValue(currentCell));
+            }
+        }
+        return resolved;
+    }
+    isFunction(currentCell) {
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{@') &&
+            currentCell.endsWith('}'));
+    }
+    isContextVariable(currentCell) {
+        if (typeof currentCell === 'string' && currentCell.endsWith('}')) {
+            return (currentCell.startsWith('{$item') ||
+                currentCell.startsWith('{$key') ||
+                currentCell.startsWith('{$index') ||
+                currentCell.startsWith('{$input') ||
+                currentCell.startsWith('{$output'));
+        }
+    }
+    isMappable(currentCell) {
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{') &&
+            currentCell.endsWith('}'));
+    }
+    resolveCellValue(currentCell) {
+        if (this.isFunction(currentCell)) {
+            const fn = Pipe.resolveFunction(currentCell);
+            return fn.call();
+        }
+        else if (this.isContextVariable(currentCell)) {
+            return this.resolveContextValue(currentCell);
+        }
+        else if (this.isMappable(currentCell)) {
+            return this.resolveMappableValue(currentCell);
+        }
+        else {
+            return currentCell;
+        }
+    }
+    getNestedProperty(obj, path) {
+        const pathParts = path.split('.');
+        let current = obj;
+        for (const part of pathParts) {
+            if (current === null ||
+                typeof current !== 'object' ||
+                !current.hasOwnProperty(part)) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    resolveMappableValue(currentCell) {
+        const term = this.resolveMapTerm(currentCell);
+        return this.getNestedProperty(this.jobData, term);
+    }
+    resolveContextValue(currentCell) {
+        const term = this.resolveContextTerm(currentCell);
+        return this.getNestedProperty(this.context, term);
+    }
+    resolveContextTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
+    resolveFunctionTerm(currentCell) {
+        return currentCell.substring(2, currentCell.length - 1);
+    }
+    resolveMapTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
+}
+exports.Pipe = Pipe;