@fsai-flow/workflow 0.0.2 → 0.0.3

package/src/lib/utils.ts

@@ -1,141 +1,125 @@
 import {
-  parse as esprimaParse,
-  Syntax,
-  type Node as SyntaxNode,
-  type ExpressionStatement,
-} from "esprima-next";
-import type { IDisplayOptions, INodeProperties } from "./Interfaces";
-import { merge } from "lodash";
+	parse as esprimaParse,
+	Syntax,
+	type Node as SyntaxNode,
+	type ExpressionStatement,
+} from 'esprima-next';
+import type { IDisplayOptions, INodeProperties } from './Interfaces';
+import { merge } from 'lodash';
 
 export function updateDisplayOptions(
-  displayOptions: IDisplayOptions,
-  properties: INodeProperties[]
+	displayOptions: IDisplayOptions,
+	properties: INodeProperties[],
 ) {
-  return properties.map((nodeProperty) => {
-    return {
-      ...nodeProperty,
-      displayOptions: merge({}, nodeProperty.displayOptions, displayOptions),
-    };
-  });
+	return properties.map((nodeProperty) => {
+		return {
+			...nodeProperty,
+			displayOptions: merge({}, nodeProperty.displayOptions, displayOptions),
+		};
+	});
 }
 export function randomInt(max: number): number;
 export function randomInt(min: number, max: number): number;
 /**
- * Generates a cryptographically secure random integer within a specified range.
+ * Generates a random integer within a specified range.
  *
- * @param {number} min - The inclusive lower bound.
- * @param {number} [max] - The exclusive upper bound. If not provided, min is treated as max and lower bound is 0.
- * @returns {number} A random integer within [min, max).
+ * @param {number} min - The lower bound of the range. If `max` is not provided, this value is used as the upper bound and the lower bound is set to 0.
+ * @param {number} [max] - The upper bound of the range, not inclusive.
+ * @returns {number} A random integer within the specified range.
  */
 export function randomInt(min: number, max?: number): number {
-  if (max === undefined) {
-    max = min;
-    min = 0;
-  }
+	if (max === undefined) {
+		max = min;
+		min = 0;
+	}
 
-  if (max <= min) {
-    throw new Error("max must be greater than min");
-  }
+	if (max <= min) {
+		throw new Error("max must be greater than min");
+	}
 
-  const range = max - min;
-  const maxUnbiased = Math.floor(0xffffffff / range) * range;
+	const range = max - min;
+	const maxUnbiased = Math.floor(0xffffffff / range) * range;
 
-  let rand: number;
-  do {
-    rand = crypto.getRandomValues(new Uint32Array(1))[0];
-  } while (rand >= maxUnbiased);
+	let rand: number;
+	do {
+		rand = crypto.getRandomValues(new Uint32Array(1))[0];
+	} while (rand >= maxUnbiased);
 
-  return min + (rand % range);
+	return min + (rand % range);
 }
 type MutuallyExclusive<T, U> =
-  | (T & { [k in Exclude<keyof U, keyof T>]?: never })
-  | (U & { [k in Exclude<keyof T, keyof U>]?: never });
+	| (T & { [k in Exclude<keyof U, keyof T>]?: never })
+	| (U & { [k in Exclude<keyof T, keyof U>]?: never });
 
 type JSONParseOptions<T> = { acceptJSObject?: boolean } & MutuallyExclusive<
-  { errorMessage?: string },
-  { fallbackValue?: T }
+	{ errorMessage?: string },
+	{ fallbackValue?: T }
 >;
 
-export const jsonParse = <T>(
-  jsonString: string,
-  options?: JSONParseOptions<T>
-): T => {
-  try {
-    return JSON.parse(jsonString) as T;
-  } catch (error) {
-    if (options?.acceptJSObject) {
-      try {
-        const jsonStringCleaned = parseJSObject(jsonString);
-        return jsonStringCleaned as T;
-      } catch (e) {
-        // Ignore this error and return the original error or the fallback value
-      }
-    }
-    if (options?.fallbackValue !== undefined) {
-      if (options.fallbackValue instanceof Function) {
-        return options.fallbackValue();
-      }
-      return options.fallbackValue;
-    } else if (options?.errorMessage) {
-      // TODO REFACTOR: Use ApplicationError from offical @fsai-flow/workflow repo
-      throw new Error(options.errorMessage);
-    }
-
-    throw error;
-  }
+export const jsonParse = <T>(jsonString: string, options?: JSONParseOptions<T>): T => {
+	try {
+		return JSON.parse(jsonString) as T;
+	} catch (error) {
+		if (options?.acceptJSObject) {
+			try {
+				const jsonStringCleaned = parseJSObject(jsonString);
+				return jsonStringCleaned as T;
+			} catch (e) {
+				// Ignore this error and return the original error or the fallback value
+			}
+		}
+		if (options?.fallbackValue !== undefined) {
+			if (options.fallbackValue instanceof Function) {
+				return options.fallbackValue();
+			}
+			return options.fallbackValue;
+		} else if (options?.errorMessage) {
+			// TODO REFACTOR: Use ApplicationError from offical @fsai-flow/workflow repo
+			throw new Error(options.errorMessage);
+		}
+
+		throw error;
+	}
 };
 
 type JSONStringifyOptions = {
-  replaceCircularRefs?: boolean;
+	replaceCircularRefs?: boolean;
 };
 
-export const replaceCircularReferences = <T>(
-  value: T,
-  knownObjects = new WeakSet()
-): T => {
-  if (typeof value !== "object" || value === null || value instanceof RegExp)
-    return value;
-  if ("toJSON" in value && typeof value.toJSON === "function")
-    return value.toJSON() as T;
-  if (knownObjects.has(value)) return "[Circular Reference]" as T;
-  knownObjects.add(value);
-  const copy = (Array.isArray(value) ? [] : {}) as T;
-  for (const key in value) {
-    copy[key] = replaceCircularReferences(value[key], knownObjects);
-  }
-  knownObjects.delete(value);
-  return copy;
+export const replaceCircularReferences = <T>(value: T, knownObjects = new WeakSet()): T => {
+	if (typeof value !== 'object' || value === null || value instanceof RegExp) return value;
+	if ('toJSON' in value && typeof value.toJSON === 'function') return value.toJSON() as T;
+	if (knownObjects.has(value)) return '[Circular Reference]' as T;
+	knownObjects.add(value);
+	const copy = (Array.isArray(value) ? [] : {}) as T;
+	for (const key in value) {
+		copy[key] = replaceCircularReferences(value[key], knownObjects);
+	}
+	knownObjects.delete(value);
+	return copy;
 };
 
-export const jsonStringify = (
-  obj: unknown,
-  options: JSONStringifyOptions = {}
-): string => {
-  return JSON.stringify(
-    options?.replaceCircularRefs ? replaceCircularReferences(obj) : obj
-  );
+export const jsonStringify = (obj: unknown, options: JSONStringifyOptions = {}): string => {
+	return JSON.stringify(options?.replaceCircularRefs ? replaceCircularReferences(obj) : obj);
 };
 
 function syntaxNodeToValue(expression?: SyntaxNode | null): unknown {
-  switch (expression?.type) {
-    case Syntax.ObjectExpression:
-      return Object.fromEntries(
-        expression.properties
-          .filter((prop) => prop.type === Syntax.Property)
-          .map(({ key, value }) => [
-            syntaxNodeToValue(key),
-            syntaxNodeToValue(value),
-          ])
-      );
-    case Syntax.Identifier:
-      return expression.name;
-    case Syntax.Literal:
-      return expression.value;
-    case Syntax.ArrayExpression:
-      return expression.elements.map((exp) => syntaxNodeToValue(exp));
-    default:
-      return undefined;
-  }
+	switch (expression?.type) {
+		case Syntax.ObjectExpression:
+			return Object.fromEntries(
+				expression.properties
+					.filter((prop) => prop.type === Syntax.Property)
+					.map(({ key, value }) => [syntaxNodeToValue(key), syntaxNodeToValue(value)]),
+			);
+		case Syntax.Identifier:
+			return expression.name;
+		case Syntax.Literal:
+			return expression.value;
+		case Syntax.ArrayExpression:
+			return expression.elements.map((exp) => syntaxNodeToValue(exp));
+		default:
+			return undefined;
+	}
 }
 
 /**
@@ -144,23 +128,18 @@ function syntaxNodeToValue(expression?: SyntaxNode | null): unknown {
  * - unquoted keys
  */
 function parseJSObject(objectAsString: string): object {
-  const jsExpression = esprimaParse(`(${objectAsString})`).body.find(
-    (node): node is ExpressionStatement =>
-      node.type === Syntax.ExpressionStatement &&
-      node.expression.type === Syntax.ObjectExpression
-  );
+	const jsExpression = esprimaParse(`(${objectAsString})`).body.find(
+		(node): node is ExpressionStatement =>
+			node.type === Syntax.ExpressionStatement && node.expression.type === Syntax.ObjectExpression,
+	);
 
-  return syntaxNodeToValue(jsExpression?.expression) as object;
+	return syntaxNodeToValue(jsExpression?.expression) as object;
 }
 
 /**
  * Checks if a value is an object with a specific key and provides a type guard for the key.
  */
-export function hasKey<T extends PropertyKey>(
-  value: unknown,
-  key: T
-): value is Record<T, unknown> {
-  return (
-    value !== null && typeof value === "object" && value.hasOwnProperty(key)
-  );
+export function hasKey<T extends PropertyKey>(value: unknown, key: T): value is Record<T, unknown> {
+	return value !== null && typeof value === 'object' && value.hasOwnProperty(key);
 }
+