@hotmeshio/hotmesh 0.0.55 → 0.0.57

package/services/pipe/functions/date.ts

@@ -1,220 +0,0 @@
-import { formatISODate } from "../../../modules/utils";
-
-type DateInput = Date | string | number;
-
-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: DateInput): Date {
-    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: string): Date {
-    return new Date(isoString);
-  }
-
-  now(): number {
-    return Date.now();
-  }
-
-  parse(dateString: string): number {
-    return Date.parse(dateString);
-  }
-
-  getDate(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getDate();
-  }
-
-  getDay(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getDay();
-  }
-
-  getFullYear(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getFullYear();
-  }
-
-  getHours(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getHours();
-  }
-
-  getMilliseconds(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getMilliseconds();
-  }
-
-  getMinutes(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getMinutes();
-  }
-
-  getMonth(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getMonth();
-  }
-
-  getSeconds(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getSeconds();
-  }
-
-  getTime(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getTime();
-  }
-
-  getTimezoneOffset(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getTimezoneOffset();
-  }
-
-  getUTCDate(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCDate();
-  }
-
-  getUTCDay(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCDay();
-  }
-
-  getUTCFullYear(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCFullYear();
-  }
-
-  getUTCHours(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCHours();
-  }
-
-  getUTCMilliseconds(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCMilliseconds();
-  }
-
-  getUTCMinutes(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCMinutes();
-  }
-
-  getUTCMonth(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCMonth();
-  }
-
-  getUTCSeconds(date: DateInput): number {
-    return DateHandler.getDateInstance(date).getUTCSeconds();
-  }
-
-  setMilliseconds(date: DateInput, ms: number): number {
-    return DateHandler.getDateInstance(date).setMilliseconds(ms);
-  }
-
-  setMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setMinutes(minutes, seconds, ms);
-  }
-
-  setMonth(date: DateInput, month: number, day?: number): number {
-    return DateHandler.getDateInstance(date).setMonth(month, day);
-  }
-
-  setSeconds(date: DateInput, seconds: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setSeconds(seconds, ms);
-  }
-
-  setTime(date: DateInput, time: number): number {
-    return DateHandler.getDateInstance(date).setTime(time);
-  }
-
-  setUTCDate(date: DateInput, day: number): number {
-    return DateHandler.getDateInstance(date).setUTCDate(day);
-  }
-
-  setUTCFullYear(date: DateInput, year: number, month?: number, day?: number): number {
-    return DateHandler.getDateInstance(date).setUTCFullYear(year, month, day);
-  }
-
-  setUTCHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setUTCHours(hours, minutes, seconds, ms);
-  }
-
-  setUTCMilliseconds(date: DateInput, ms: number): number {
-    return DateHandler.getDateInstance(date).setUTCMilliseconds(ms);
-  }
-
-  setUTCMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setUTCMinutes(minutes, seconds, ms);
-  }
-
-  setUTCMonth(date: DateInput, month: number, day?: number): number {
-    return DateHandler.getDateInstance(date).setUTCMonth(month, day);
-  }
-
-  setUTCSeconds(date: DateInput, seconds: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setUTCSeconds(seconds, ms);
-  }
-  
-  setDate(date: DateInput, day: number): number {
-    return DateHandler.getDateInstance(date).setDate(day);
-  }
-
-  setFullYear(date: DateInput, year: number, month?: number, day?: number): number {
-    return DateHandler.getDateInstance(date).setFullYear(year, month, day);
-  }
-
-  setHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number {
-    return DateHandler.getDateInstance(date).setHours(hours, minutes, seconds, ms);
-  }
-  toDateString(date: DateInput): string {
-    return DateHandler.getDateInstance(date).toDateString();
-  }
-
-  toISOString(date: DateInput): string {
-    return DateHandler.getDateInstance(date).toISOString();
-  }
-
-  toISOXString(date?: DateInput): string {
-    return formatISODate(date ? DateHandler.getDateInstance(date) : new Date());
-  }
-
-  toJSON(date: DateInput): string {
-    return DateHandler.getDateInstance(date).toJSON();
-  }
-
-  toLocaleDateString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string {
-    return DateHandler.getDateInstance(date).toLocaleDateString(locales, options);
-  }
-
-  toLocaleString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string {
-    return DateHandler.getDateInstance(date).toLocaleString(locales, options);
-  }
-
-  toLocaleTimeString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string {
-    return DateHandler.getDateInstance(date).toLocaleTimeString(locales, options);
-  }
-
-  toString(date: DateInput): string {
-    return DateHandler.getDateInstance(date).toString();
-  }
-
-  UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number {
-    return Date.UTC(year, month, date, hours, minutes, seconds, ms);
-  }
-
-  valueOf(date: DateInput): number {
-    return DateHandler.getDateInstance(date).valueOf();
-  }
-
-}
-
-export { DateHandler };

package/services/pipe/functions/index.ts

@@ -1,27 +0,0 @@
-import { ArrayHandler } from './array';
-import { BitwiseHandler } from './bitwise';
-import { ConditionalHandler } from './conditional';
-import { DateHandler } from './date';
-import { JsonHandler } from './json';
-import { LogicalHandler } from './logical';
-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(),
-  logical: new LogicalHandler(),
-  math: new MathHandler(),
-  number: new NumberHandler(),
-  object: new ObjectHandler(),
-  string: new StringHandler(),
-  symbol: new SymbolHandler(),
-  unary: new UnaryHandler(),
-};

package/services/pipe/functions/json.ts

@@ -1,11 +0,0 @@
-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/logical.ts

@@ -1,11 +0,0 @@
-class LogicalHandler {
-  and(firstValue: boolean, secondValue: boolean): boolean {
-    return firstValue && secondValue;
-  }
-
-  or(firstValue: boolean, secondValue: boolean): boolean {
-    return firstValue || secondValue;
-  }
-}
-
-export { LogicalHandler };

package/services/pipe/functions/math.ts

@@ -1,217 +0,0 @@
-class MathHandler {
-  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;
-  }
-
-  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

@@ -1,75 +0,0 @@
-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);
-  }
-}
-
-export { NumberHandler };

package/services/pipe/functions/object.ts

@@ -1,98 +0,0 @@
-class ObjectHandler {
-  get(obj: object, prop: string | symbol): any {
-    return obj?.[prop];
-  }
-
-  set(obj: object, prop: string | symbol, value: any): any {
-    if (!obj) obj = {};
-    obj[prop] = value;
-    return obj;
-  }
-
-  create(...args: any[]): object {
-    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: object): string[] {
-    return obj && Object.keys(obj) || [];
-  }
-
-  values(obj: object): any[] {
-    return obj && Object.values(obj) || [];
-  }
-
-  entries(obj: object): [string, any][] {
-    return obj && 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 };