@sylphx/flow 2.18.0 → 2.18.2

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;
-};

package/src/utils/functional/string.ts

@@ -1,281 +0,0 @@
-/**
- * Functional string utilities
- * Pure string transformation functions
- *
- * DESIGN RATIONALE:
- * - Pure functions for string operations
- * - Composable transformations
- * - Type-safe operations
- * - No side effects
- */
-
-/**
- * Trim whitespace from string
- */
-export const trim = (str: string): string => str.trim();
-
-/**
- * Trim start of string
- */
-export const trimStart = (str: string): string => str.trimStart();
-
-/**
- * Trim end of string
- */
-export const trimEnd = (str: string): string => str.trimEnd();
-
-/**
- * Convert to lowercase
- */
-export const toLowerCase = (str: string): string => str.toLowerCase();
-
-/**
- * Convert to uppercase
- */
-export const toUpperCase = (str: string): string => str.toUpperCase();
-
-/**
- * Split string by delimiter
- */
-export const split =
-  (delimiter: string | RegExp) =>
-  (str: string): string[] =>
-    str.split(delimiter);
-
-/**
- * Join array of strings
- */
-export const join =
-  (delimiter: string) =>
-  (arr: string[]): string =>
-    arr.join(delimiter);
-
-/**
- * Replace pattern in string
- */
-export const replace =
-  (pattern: string | RegExp, replacement: string) =>
-  (str: string): string =>
-    str.replace(pattern, replacement);
-
-/**
- * Replace all occurrences
- */
-export const replaceAll =
-  (pattern: string | RegExp, replacement: string) =>
-  (str: string): string =>
-    str.replaceAll(pattern, replacement);
-
-/**
- * Check if string starts with prefix
- */
-export const startsWith =
-  (prefix: string) =>
-  (str: string): boolean =>
-    str.startsWith(prefix);
-
-/**
- * Check if string ends with suffix
- */
-export const endsWith =
-  (suffix: string) =>
-  (str: string): boolean =>
-    str.endsWith(suffix);
-
-/**
- * Check if string includes substring
- */
-export const includes =
-  (substring: string) =>
-  (str: string): boolean =>
-    str.includes(substring);
-
-/**
- * Test string against regex
- */
-export const test =
-  (pattern: RegExp) =>
-  (str: string): boolean =>
-    pattern.test(str);
-
-/**
- * Match string against regex
- */
-export const match =
-  (pattern: RegExp) =>
-  (str: string): RegExpMatchArray | null =>
-    str.match(pattern);
-
-/**
- * Slice string
- */
-export const slice =
-  (start: number, end?: number) =>
-  (str: string): string =>
-    str.slice(start, end);
-
-/**
- * Substring
- */
-export const substring =
-  (start: number, end?: number) =>
-  (str: string): string =>
-    str.substring(start, end);
-
-/**
- * Pad start of string
- */
-export const padStart =
-  (length: number, fillString = ' ') =>
-  (str: string): string =>
-    str.padStart(length, fillString);
-
-/**
- * Pad end of string
- */
-export const padEnd =
-  (length: number, fillString = ' ') =>
-  (str: string): string =>
-    str.padEnd(length, fillString);
-
-/**
- * Repeat string n times
- */
-export const repeat =
-  (count: number) =>
-  (str: string): string =>
-    str.repeat(count);
-
-/**
- * Check if string is empty
- */
-export const isEmpty = (str: string): boolean => str.length === 0;
-
-/**
- * Check if string is blank (empty or whitespace)
- */
-export const isBlank = (str: string): boolean => str.trim().length === 0;
-
-/**
- * Check if string is not empty
- */
-export const isNotEmpty = (str: string): boolean => str.length > 0;
-
-/**
- * Check if string is not blank
- */
-export const isNotBlank = (str: string): boolean => str.trim().length > 0;
-
-/**
- * Capitalize first letter
- */
-export const capitalize = (str: string): string => {
-  if (str.length === 0) {
-    return str;
-  }
-  return str.charAt(0).toUpperCase() + str.slice(1);
-};
-
-/**
- * Capitalize all words
- */
-export const capitalizeWords = (str: string): string => {
-  return str
-    .split(' ')
-    .map((word) => capitalize(word))
-    .join(' ');
-};
-
-/**
- * Convert to camelCase
- */
-export const toCamelCase = (str: string): string => {
-  return str
-    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
-    .replace(/^[A-Z]/, (c) => c.toLowerCase());
-};
-
-/**
- * Convert to PascalCase
- */
-export const toPascalCase = (str: string): string => {
-  const camel = toCamelCase(str);
-  return capitalize(camel);
-};
-
-/**
- * Convert to kebab-case
- */
-export const toKebabCase = (str: string): string => {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1-$2')
-    .replace(/[\s_]+/g, '-')
-    .toLowerCase();
-};
-
-/**
- * Convert to snake_case
- */
-export const toSnakeCase = (str: string): string => {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1_$2')
-    .replace(/[\s-]+/g, '_')
-    .toLowerCase();
-};
-
-/**
- * Truncate string to max length
- */
-export const truncate =
-  (maxLength: number, suffix = '...') =>
-  (str: string): string => {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.slice(0, maxLength - suffix.length) + suffix;
-  };
-
-/**
- * Extract lines from string
- */
-export const lines = (str: string): string[] => str.split(/\r?\n/);
-
-/**
- * Remove empty lines
- */
-export const removeEmptyLines = (str: string): string => {
-  return lines(str).filter(isNotBlank).join('\n');
-};
-
-/**
- * Indent each line
- */
-export const indent =
-  (spaces: number) =>
-  (str: string): string => {
-    const indentation = ' '.repeat(spaces);
-    return lines(str)
-      .map((line) => indentation + line)
-      .join('\n');
-  };
-
-/**
- * Remove indentation
- */
-export const dedent = (str: string): string => {
-  const linesArray = lines(str);
-
-  // Find minimum indentation
-  const minIndent = linesArray.filter(isNotBlank).reduce((min, line) => {
-    const match = line.match(/^(\s*)/);
-    const indent = match ? match[1].length : 0;
-    return Math.min(min, indent);
-  }, Number.POSITIVE_INFINITY);
-
-  if (minIndent === 0 || minIndent === Number.POSITIVE_INFINITY) {
-    return str;
-  }
-
-  // Remove minimum indentation from each line
-  return linesArray.map((line) => line.slice(minIndent)).join('\n');
-};