@hotmeshio/hotmesh 0.0.1

package/services/pipe/functions/index.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';
+
+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/services/pipe/functions/json.ts

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

package/services/pipe/functions/math.ts

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

package/services/pipe/functions/number.ts

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

package/services/pipe/functions/object.ts

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

package/services/pipe/functions/string.ts

@@ -0,0 +1,86 @@
+class StringHandler {
+  split(input: string, delimiter: string): string[] {
+    return input.split(delimiter);
+  }
+
+  charAt(input: string, index: number): string {
+    return input.charAt(index);
+  }
+
+  concat(...strings: string[]): string {
+    return strings.join('');
+  }
+
+  includes(input: string, searchString: string, position?: number): boolean {
+    return input.includes(searchString, position);
+  }
+
+  indexOf(input: string, searchString: string, fromIndex?: number): number {
+    return input.indexOf(searchString, fromIndex);
+  }
+
+  lastIndexOf(input: string, searchString: string, fromIndex?: number): number {
+    return input.lastIndexOf(searchString, fromIndex);
+  }
+
+  slice(input: string, start?: number, end?: number): string {
+    return input.slice(start, end);
+  }
+
+  toLowerCase(input: string): string {
+    return input.toLowerCase();
+  }
+
+  toUpperCase(input: string): string {
+    return input.toUpperCase();
+  }
+
+  trim(input: string): string {
+    return input.trim();
+  }
+
+  trimStart(input: string): string {
+    return input.trimStart();
+  }
+
+  trimEnd(input: string): string {
+    return input.trimEnd();
+  }
+
+  padStart(input: string, maxLength: number, padString?: string): string {
+    return input.padStart(maxLength, padString);
+  }
+
+  padEnd(input: string, maxLength: number, padString?: string): string {
+    return input.padEnd(maxLength, padString);
+  }
+
+  replace(input: string, searchValue: string | RegExp, replaceValue: string): string {
+    return input.replace(searchValue, replaceValue);
+  }
+
+  search(input: string, regexp: RegExp): number {
+    return input.search(regexp);
+  }
+
+  substring(input: string, start: number, end?: number): string {
+    return input.substring(start, end);
+  }
+
+  startsWith(str: string, searchString: string, position?: number): boolean {
+    return str.startsWith(searchString, position);
+  }
+
+  endsWith(str: string, searchString: string, length?: number): boolean {
+    return str.endsWith(searchString, length);
+  }
+
+  repeat(str: string, count: number): string {
+    if (count < 0 || count === Infinity) {
+      throw new RangeError('Invalid repeat count. Must be a positive finite number.');
+    }
+    return str.repeat(count);
+  }
+}
+  
+export { StringHandler };

package/services/pipe/functions/symbol.ts

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

package/services/pipe/functions/unary.ts

@@ -0,0 +1,19 @@
+class UnaryHandler {
+  not(value: boolean): boolean {
+    return !value;
+  }
+
+  positive(value: number): number {
+    return +value;
+  }
+
+  negative(value: number): number {
+    return -value;
+  }
+
+  bitwise_not(value: number): number {
+    return ~value;
+  }
+}
+
+export { UnaryHandler };

package/services/pipe/index.ts

@@ -0,0 +1,138 @@
+import FUNCTIONS from './functions'
+import { JobState, JobData, JobsData } from '../../types/job';
+import { PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
+
+class Pipe {
+  rules: PipeType;
+  jobData: JobData;
+
+  constructor(rules: PipeType, jobData: JobData) {
+    this.rules = rules;
+    this.jobData = jobData;
+  }
+
+  private isPipeType(currentRow: PipeItem[]|PipeType): currentRow is PipeType {
+    return !Array.isArray(currentRow) && '@pipe' in currentRow;
+  }
+
+  static isPipeObject(obj: { [key: string]: unknown }|PipeItem): boolean {
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj) && '@pipe' in obj;
+  }
+
+  static resolve(unresolved: { [key: string]: unknown }|PipeItem, context: Partial<JobState>): any {
+    let pipe: Pipe;
+    if (Pipe.isPipeObject(unresolved)) {
+      pipe = new Pipe(unresolved['@pipe'], context);
+    } else {
+      pipe = new Pipe([[unresolved as unknown as PipeItem]], 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(): any {
+    let resolved = this.processCells(this.rules[0] as PipeItem[]);
+    const len = this.rules.length;
+    for (let i = 1; i < len; i++) {
+      resolved = this.processRow(this.rules[i], resolved, []);
+    }
+    return resolved[0];
+  }
+
+  private processRow(currentRow: PipeItem[]|PipeType, resolvedPriorRow: unknown[]|null, subPipeQueue: unknown[]): PipeItem[] {
+    if (this.isPipeType(currentRow)) {
+      //currentRow is a recursive subPipe
+      const subPipe = new Pipe(currentRow['@pipe'], this.jobData);
+      subPipeQueue.push(subPipe.process());
+      //return prior row as if nothing happened
+      return resolvedPriorRow as PipeItem[];
+    } else {
+      if (subPipeQueue.length > 0) {
+        //if items in subPipeQueue, flush and use as resolvedPriorRow
+        resolvedPriorRow = [...subPipeQueue];
+        subPipeQueue.length = 0;
+      } else if (!resolvedPriorRow) {
+        //if no prior row, use current row as prior row
+        return [].concat(this.processCells([...currentRow]));
+      } else {
+        const [functionName, ...params] = currentRow;
+        //use resolved values from prior row (n - 1) as input params to cell 1 function
+        const resolvedValue = Pipe.resolveFunction(functionName as string)(...resolvedPriorRow);
+        //resolve remaining cells in row and return concatenated with resolvedValue
+        return [resolvedValue].concat(this.processCells([...params]));
+      }
+    }
+  }
+
+  static resolveFunction(functionName: string) {
+    let [prefix, suffix] = functionName.split('.');
+    prefix = prefix.substring(2);
+    suffix = suffix.substring(0, suffix.length - 1);
+    const domain = FUNCTIONS[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: PipeItems): unknown[] {
+    const resolved = [];
+    for (const currentCell of cells) {
+      resolved.push(this.resolveCellValue(currentCell));
+    }
+    return resolved;
+  }
+
+  private isFunction(currentCell: PipeItem): boolean {
+    return typeof currentCell === 'string' && currentCell.startsWith('{@') && currentCell.endsWith('}');
+  }
+
+  private isMappable(currentCell: PipeItem): boolean {
+    return typeof currentCell === 'string' &&  currentCell.startsWith('{') && currentCell.endsWith('}');
+  }
+
+  resolveCellValue(currentCell: PipeItem): unknown {
+    if (this.isFunction(currentCell)) {
+      const fn = Pipe.resolveFunction(currentCell as string);
+      return fn.call();
+    } else if (this.isMappable(currentCell)) {
+      return this.resolveMappableValue(currentCell as string);
+    } else {
+      return currentCell;
+    }
+  }
+
+  private getNestedProperty(obj: JobsData|unknown, path: string): any {
+    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: string): unknown {
+    const term = this.resolveMapTerm(currentCell);
+    return this.getNestedProperty(this.jobData, term);
+  }
+
+  resolveFunctionTerm(currentCell: string): string {
+    return currentCell.substring(2, currentCell.length - 1);
+  }
+
+  resolveMapTerm(currentCell: string): string {
+    return currentCell.substring(1, currentCell.length - 1);
+  }
+}
+
+export { Pipe };