@sylphx/flow 2.18.1 → 2.18.3

package/src/utils/functional/array.ts

@@ -1,355 +0,0 @@
-/**
- * Functional array utilities
- * Pure array transformation functions
- *
- * DESIGN RATIONALE:
- * - Pure functions for array operations
- * - Composable transformations
- * - Type-safe operations
- * - No side effects (no mutations)
- */
-
-/**
- * Map over array
- */
-export const map =
-  <T, U>(fn: (item: T, index: number) => U) =>
-  (arr: T[]): U[] =>
-    arr.map(fn);
-
-/**
- * Filter array
- */
-export const filter =
-  <T>(predicate: (item: T, index: number) => boolean) =>
-  (arr: T[]): T[] =>
-    arr.filter(predicate);
-
-/**
- * Reduce array
- */
-export const reduce =
-  <T, U>(fn: (acc: U, item: T, index: number) => U, initial: U) =>
-  (arr: T[]): U =>
-    arr.reduce(fn, initial);
-
-/**
- * Find first element matching predicate
- */
-export const find =
-  <T>(predicate: (item: T, index: number) => boolean) =>
-  (arr: T[]): T | undefined =>
-    arr.find(predicate);
-
-/**
- * Find index of first element matching predicate
- */
-export const findIndex =
-  <T>(predicate: (item: T, index: number) => boolean) =>
-  (arr: T[]): number =>
-    arr.findIndex(predicate);
-
-/**
- * Check if any element matches predicate
- */
-export const some =
-  <T>(predicate: (item: T, index: number) => boolean) =>
-  (arr: T[]): boolean =>
-    arr.some(predicate);
-
-/**
- * Check if all elements match predicate
- */
-export const every =
-  <T>(predicate: (item: T, index: number) => boolean) =>
-  (arr: T[]): boolean =>
-    arr.every(predicate);
-
-/**
- * Flatten array one level
- */
-export const flatten = <T>(arr: T[][]): T[] => arr.flat();
-
-/**
- * Flatten array deeply
- */
-export const flattenDeep = <T>(arr: any[]): T[] => arr.flat(Number.POSITIVE_INFINITY);
-
-/**
- * Map and flatten (flatMap)
- */
-export const flatMap =
-  <T, U>(fn: (item: T, index: number) => U[]) =>
-  (arr: T[]): U[] =>
-    arr.flatMap(fn);
-
-/**
- * Take first n elements
- */
-export const take =
-  (n: number) =>
-  <T>(arr: T[]): T[] =>
-    arr.slice(0, n);
-
-/**
- * Skip first n elements
- */
-export const skip =
-  (n: number) =>
-  <T>(arr: T[]): T[] =>
-    arr.slice(n);
-
-/**
- * Take while predicate is true
- */
-export const takeWhile =
-  <T>(predicate: (item: T) => boolean) =>
-  (arr: T[]): T[] => {
-    const index = arr.findIndex((item) => !predicate(item));
-    return index === -1 ? arr : arr.slice(0, index);
-  };
-
-/**
- * Skip while predicate is true
- */
-export const skipWhile =
-  <T>(predicate: (item: T) => boolean) =>
-  (arr: T[]): T[] => {
-    const index = arr.findIndex((item) => !predicate(item));
-    return index === -1 ? [] : arr.slice(index);
-  };
-
-/**
- * Reverse array
- */
-export const reverse = <T>(arr: T[]): T[] => [...arr].reverse();
-
-/**
- * Sort array
- */
-export const sort =
-  <T>(compareFn?: (a: T, b: T) => number) =>
-  (arr: T[]): T[] =>
-    [...arr].sort(compareFn);
-
-/**
- * Sort by key
- */
-export const sortBy =
-  <T, K extends keyof T>(key: K, order: 'asc' | 'desc' = 'asc') =>
-  (arr: T[]): T[] => {
-    return [...arr].sort((a, b) => {
-      const aVal = a[key];
-      const bVal = b[key];
-
-      if (aVal < bVal) {
-        return order === 'asc' ? -1 : 1;
-      }
-      if (aVal > bVal) {
-        return order === 'asc' ? 1 : -1;
-      }
-      return 0;
-    });
-  };
-
-/**
- * Remove duplicates
- */
-export const unique = <T>(arr: T[]): T[] => [...new Set(arr)];
-
-/**
- * Remove duplicates by key
- */
-export const uniqueBy =
-  <T, K extends keyof T>(key: K) =>
-  (arr: T[]): T[] => {
-    const seen = new Set();
-    return arr.filter((item) => {
-      const value = item[key];
-      if (seen.has(value)) {
-        return false;
-      }
-      seen.add(value);
-      return true;
-    });
-  };
-
-/**
- * Partition array into two based on predicate
- */
-export const partition =
-  <T>(predicate: (item: T) => boolean) =>
-  (arr: T[]): [T[], T[]] => {
-    const pass: T[] = [];
-    const fail: T[] = [];
-
-    for (const item of arr) {
-      if (predicate(item)) {
-        pass.push(item);
-      } else {
-        fail.push(item);
-      }
-    }
-
-    return [pass, fail];
-  };
-
-/**
- * Group by key
- */
-export const groupBy =
-  <T, K extends keyof T>(key: K) =>
-  (arr: T[]): Record<string, T[]> => {
-    return arr.reduce(
-      (acc, item) => {
-        const groupKey = String(item[key]);
-        if (!acc[groupKey]) {
-          acc[groupKey] = [];
-        }
-        acc[groupKey].push(item);
-        return acc;
-      },
-      {} as Record<string, T[]>
-    );
-  };
-
-/**
- * Count occurrences
- */
-export const countBy =
-  <T>(fn: (item: T) => string) =>
-  (arr: T[]): Record<string, number> => {
-    return arr.reduce(
-      (acc, item) => {
-        const key = fn(item);
-        acc[key] = (acc[key] || 0) + 1;
-        return acc;
-      },
-      {} as Record<string, number>
-    );
-  };
-
-/**
- * Chunk array into smaller arrays
- */
-export const chunk =
-  (size: number) =>
-  <T>(arr: T[]): T[][] => {
-    const chunks: T[][] = [];
-    for (let i = 0; i < arr.length; i += size) {
-      chunks.push(arr.slice(i, i + size));
-    }
-    return chunks;
-  };
-
-/**
- * Zip arrays together
- */
-export const zip = <T, U>(arr1: T[], arr2: U[]): [T, U][] => {
-  const length = Math.min(arr1.length, arr2.length);
-  const result: [T, U][] = [];
-
-  for (let i = 0; i < length; i++) {
-    result.push([arr1[i], arr2[i]]);
-  }
-
-  return result;
-};
-
-/**
- * Unzip array of tuples
- */
-export const unzip = <T, U>(arr: [T, U][]): [T[], U[]] => {
-  const first: T[] = [];
-  const second: U[] = [];
-
-  for (const [a, b] of arr) {
-    first.push(a);
-    second.push(b);
-  }
-
-  return [first, second];
-};
-
-/**
- * Intersperse value between array elements
- */
-export const intersperse =
-  <T>(separator: T) =>
-  (arr: T[]): T[] => {
-    if (arr.length === 0) {
-      return [];
-    }
-
-    const result: T[] = [arr[0]];
-    for (let i = 1; i < arr.length; i++) {
-      result.push(separator, arr[i]);
-    }
-
-    return result;
-  };
-
-/**
- * Get first element
- */
-export const head = <T>(arr: T[]): T | undefined => arr[0];
-
-/**
- * Get last element
- */
-export const last = <T>(arr: T[]): T | undefined => arr[arr.length - 1];
-
-/**
- * Get all but first element
- */
-export const tail = <T>(arr: T[]): T[] => arr.slice(1);
-
-/**
- * Get all but last element
- */
-export const init = <T>(arr: T[]): T[] => arr.slice(0, -1);
-
-/**
- * Check if array is empty
- */
-export const isEmpty = <T>(arr: T[]): boolean => arr.length === 0;
-
-/**
- * Check if array is not empty
- */
-export const isNotEmpty = <T>(arr: T[]): boolean => arr.length > 0;
-
-/**
- * Sum numbers in array
- */
-export const sum = (arr: number[]): number => arr.reduce((a, b) => a + b, 0);
-
-/**
- * Get average of numbers in array
- */
-export const average = (arr: number[]): number => {
-  if (arr.length === 0) {
-    return 0;
-  }
-  return sum(arr) / arr.length;
-};
-
-/**
- * Get min value
- */
-export const min = (arr: number[]): number | undefined => {
-  if (arr.length === 0) {
-    return undefined;
-  }
-  return Math.min(...arr);
-};
-
-/**
- * Get max value
- */
-export const max = (arr: number[]): number | undefined => {
-  if (arr.length === 0) {
-    return undefined;
-  }
-  return Math.max(...arr);
-};

package/src/utils/functional/index.ts

@@ -1,15 +0,0 @@
-/**
- * Functional utilities
- * Pure, composable utility functions
- *
- * DESIGN RATIONALE:
- * - Pure functions for common operations
- * - Composable through currying
- * - Type-safe
- * - No side effects
- * - Point-free style support
- */
-
-export * as Arr from './array.js';
-export * as Obj from './object.js';
-export * as Str from './string.js';

package/src/utils/functional/object.ts

@@ -1,279 +0,0 @@
-/**
- * Functional object utilities
- * Pure object transformation functions
- *
- * DESIGN RATIONALE:
- * - Pure functions for object operations
- * - Immutable transformations
- * - Type-safe operations
- * - No side effects
- */
-
-/**
- * Get keys of object
- */
-export const keys = <T extends object>(obj: T): Array<keyof T> => {
-  return Object.keys(obj) as Array<keyof T>;
-};
-
-/**
- * Get values of object
- */
-export const values = <T extends object>(obj: T): T[keyof T][] => {
-  return Object.values(obj);
-};
-
-/**
- * Get entries of object
- */
-export const entries = <T extends object>(obj: T): [keyof T, T[keyof T]][] => {
-  return Object.entries(obj) as [keyof T, T[keyof T]][];
-};
-
-/**
- * Create object from entries
- */
-export const fromEntries = <K extends string | number | symbol, V>(
-  entries: [K, V][]
-): Record<K, V> => {
-  return Object.fromEntries(entries) as Record<K, V>;
-};
-
-/**
- * Pick properties from object
- */
-export const pick =
-  <T extends object, K extends keyof T>(keys: K[]) =>
-  (obj: T): Pick<T, K> => {
-    const result = {} as Pick<T, K>;
-    for (const key of keys) {
-      if (key in obj) {
-        result[key] = obj[key];
-      }
-    }
-    return result;
-  };
-
-/**
- * Omit properties from object
- */
-export const omit =
-  <T extends object, K extends keyof T>(keys: K[]) =>
-  (obj: T): Omit<T, K> => {
-    const result = { ...obj };
-    for (const key of keys) {
-      delete result[key];
-    }
-    return result;
-  };
-
-/**
- * Map over object values
- */
-export const mapValues =
-  <T extends object, U>(fn: (value: T[keyof T], key: keyof T) => U) =>
-  (obj: T): Record<keyof T, U> => {
-    const result = {} as Record<keyof T, U>;
-    for (const [key, value] of entries(obj)) {
-      result[key] = fn(value, key);
-    }
-    return result;
-  };
-
-/**
- * Map over object keys
- */
-export const mapKeys =
-  <T extends object, K extends string | number | symbol>(
-    fn: (key: keyof T, value: T[keyof T]) => K
-  ) =>
-  (obj: T): Record<K, T[keyof T]> => {
-    const result = {} as Record<K, T[keyof T]>;
-    for (const [key, value] of entries(obj)) {
-      const newKey = fn(key, value);
-      result[newKey] = value;
-    }
-    return result;
-  };
-
-/**
- * Filter object by predicate
- */
-export const filterObj =
-  <T extends object>(predicate: (value: T[keyof T], key: keyof T) => boolean) =>
-  (obj: T): Partial<T> => {
-    const result = {} as Partial<T>;
-    for (const [key, value] of entries(obj)) {
-      if (predicate(value, key)) {
-        result[key] = value;
-      }
-    }
-    return result;
-  };
-
-/**
- * Merge objects (shallow)
- */
-export const merge = <T extends object, U extends object>(obj1: T, obj2: U): T & U => {
-  return { ...obj1, ...obj2 };
-};
-
-/**
- * Deep merge objects
- */
-export const deepMerge = <T extends object>(target: T, source: Partial<T>): T => {
-  const result = { ...target };
-
-  for (const key of keys(source)) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-
-    if (
-      typeof sourceValue === 'object' &&
-      sourceValue !== null &&
-      !Array.isArray(sourceValue) &&
-      typeof targetValue === 'object' &&
-      targetValue !== null &&
-      !Array.isArray(targetValue)
-    ) {
-      result[key] = deepMerge(targetValue, sourceValue as any);
-    } else if (sourceValue !== undefined) {
-      result[key] = sourceValue as T[Extract<keyof T, string>];
-    }
-  }
-
-  return result;
-};
-
-/**
- * Check if object has property
- */
-export const has =
-  <T extends object>(key: PropertyKey) =>
-  (obj: T): boolean => {
-    return key in obj;
-  };
-
-/**
- * Get property safely
- */
-export const get =
-  <T extends object, K extends keyof T>(key: K) =>
-  (obj: T): T[K] | undefined => {
-    return obj[key];
-  };
-
-/**
- * Get nested property safely
- */
-export const getPath =
-  (path: string) =>
-  (obj: any): any => {
-    const keys = path.split('.');
-    let current = obj;
-
-    for (const key of keys) {
-      if (current === null || current === undefined) {
-        return undefined;
-      }
-      current = current[key];
-    }
-
-    return current;
-  };
-
-/**
- * Set property immutably
- */
-export const set =
-  <T extends object, K extends keyof T>(key: K, value: T[K]) =>
-  (obj: T): T => {
-    return { ...obj, [key]: value };
-  };
-
-/**
- * Update property immutably
- */
-export const update =
-  <T extends object, K extends keyof T>(key: K, fn: (value: T[K]) => T[K]) =>
-  (obj: T): T => {
-    return { ...obj, [key]: fn(obj[key]) };
-  };
-
-/**
- * Check if object is empty
- */
-export const isEmpty = <T extends object>(obj: T): boolean => {
-  return keys(obj).length === 0;
-};
-
-/**
- * Check if object is not empty
- */
-export const isNotEmpty = <T extends object>(obj: T): boolean => {
-  return keys(obj).length > 0;
-};
-
-/**
- * Remove undefined values
- */
-export const compact = <T extends object>(obj: T): Partial<T> => {
-  return filterObj((value: any) => value !== undefined)(obj);
-};
-
-/**
- * Remove null and undefined values
- */
-export const compactAll = <T extends object>(obj: T): Partial<T> => {
-  return filterObj((value: any) => value !== null && value !== undefined)(obj);
-};
-
-/**
- * Invert object (swap keys and values)
- */
-export const invert = <T extends Record<string, string | number>>(
-  obj: T
-): Record<string, string> => {
-  const result: Record<string, string> = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[String(value)] = key;
-  }
-  return result;
-};
-
-/**
- * Deep clone object
- */
-export const clone = <T>(obj: T): T => {
-  if (obj === null || typeof obj !== 'object') {
-    return obj;
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map(clone) as any;
-  }
-
-  const cloned = {} as T;
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      cloned[key] = clone(obj[key]);
-    }
-  }
-
-  return cloned;
-};
-
-/**
- * Freeze object deeply (make immutable)
- */
-export const deepFreeze = <T extends object>(obj: T): Readonly<T> => {
-  Object.freeze(obj);
-
-  for (const value of values(obj)) {
-    if (typeof value === 'object' && value !== null) {
-      deepFreeze(value);
-    }
-  }
-
-  return obj;
-};