fp-pack 0.1.0

package/src/implement/object/merge.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import merge from './merge';
+
+describe('merge', () => {
+  it('merges objects shallowly', () => {
+    const base = { id: 1, name: 'A' };
+    const patch = { name: 'B' };
+
+    expect(merge(base, patch)).toEqual({ id: 1, name: 'B' });
+    expect(base).toEqual({ id: 1, name: 'A' }); // immutability check
+  });
+
+  it('preserves combined types (compile-time)', () => {
+    const a = { id: 1, name: 'Ada' };
+    const b = { active: true };
+    const result = merge(a, b);
+    // TypeScript should allow accessing both sets of properties
+    expect(result.id).toBe(1);
+    expect(result.name).toBe('Ada');
+    expect(result.active).toBe(true);
+  });
+});

package/src/implement/object/merge.ts

@@ -0,0 +1,19 @@
+import curry from '../composition/curry';
+
+type Merge = {
+  <T>(...args: [obj1: T]): <U>(obj2: U) => T & U;
+  <T, U>(...args: [obj1: T, obj2: U]): T & U;
+};
+
+/**
+ * merge - 객체 병합 (얕은 병합)
+ */
+function merge<T, U>(obj1: T, obj2: U): T & U {
+  return {
+    ...(obj1 as object),
+    ...(obj2 as object),
+  } as T & U;
+}
+
+const curriedMerge = curry(merge) as Merge;
+export default curriedMerge;

package/src/implement/object/mergeAll.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import mergeAll from './mergeAll';
+
+describe('mergeAll', () => {
+  it('merges an array of objects shallowly', () => {
+    const result = mergeAll([{ id: 1 }, { name: 'Ada' }, { id: 2 }]);
+    expect(result).toEqual({ id: 2, name: 'Ada' });
+  });
+
+  it('returns empty object for empty array', () => {
+    expect(mergeAll([])).toEqual({});
+  });
+});

package/src/implement/object/mergeAll.ts

@@ -0,0 +1,12 @@
+/**
+ * mergeAll - 객체 배열 병합 (얕은 병합)
+ */
+function mergeAll<T extends object>(objects: T[]): T {
+  const merged = objects.reduce<Record<string, unknown>>(
+    (acc, obj) => ({ ...acc, ...(obj as Record<string, unknown>) }),
+    {}
+  );
+  return merged as T;
+}
+
+export default mergeAll;

package/src/implement/object/mergeDeep.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import mergeDeep from './mergeDeep';
+
+describe('mergeDeep', () => {
+  it('merges nested objects', () => {
+    const base = { user: { name: 'A', age: 20 }, meta: { id: 1 } };
+    const patch = { user: { age: 21 } };
+
+    expect(mergeDeep(base, patch)).toEqual({ user: { name: 'A', age: 21 }, meta: { id: 1 } });
+  });
+});

package/src/implement/object/mergeDeep.ts

@@ -0,0 +1,41 @@
+import curry from '../composition/curry';
+
+type MergeDeep = {
+  <T>(...args: [obj1: T]): <U>(obj2: U) => T & U;
+  <T, U>(...args: [obj1: T, obj2: U]): T & U;
+};
+
+/**
+ * mergeDeep - 깊은 객체 병합
+ */
+function mergeDeep<T, U>(obj1: T, obj2: U): T & U {
+  const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+    typeof value === 'object' && value !== null && !Array.isArray(value);
+
+  const mergeObjects = (left: Record<string, unknown>, right: Record<string, unknown>) => {
+    const result: Record<string, unknown> = { ...left };
+
+    for (const [key, value] of Object.entries(right)) {
+      const existing = result[key];
+      if (isPlainObject(existing) && isPlainObject(value)) {
+        result[key] = mergeObjects(existing, value);
+      } else {
+        result[key] = value;
+      }
+    }
+
+    return result;
+  };
+
+  if (isPlainObject(obj1) && isPlainObject(obj2)) {
+    return mergeObjects(obj1, obj2) as T & U;
+  }
+
+  return {
+    ...(obj1 as object),
+    ...(obj2 as object),
+  } as T & U;
+}
+
+const curriedMergeDeep = curry(mergeDeep) as MergeDeep;
+export default curriedMergeDeep;

package/src/implement/object/omit.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import omit from './omit';
+
+describe('omit', () => {
+  it('removes keys', () => {
+    const user = { id: 1, name: 'A', active: true };
+    const updated = omit<typeof user>(['active'], user);
+
+    expect(updated).toEqual({ id: 1, name: 'A' });
+    expect(user).toEqual({ id: 1, name: 'A', active: true }); // immutability
+  });
+});

package/src/implement/object/omit.ts

@@ -0,0 +1,20 @@
+import curry from '../composition/curry';
+
+type OmitFn = {
+  <K extends PropertyKey>(...args: [keys: K[]]): <T extends Record<K, unknown>>(obj: T) => Omit<T, K>;
+  <T extends object, K extends keyof T = keyof T>(...args: [keys: K[], obj: T]): Omit<T, K>;
+};
+
+/**
+ * omit - 일부 속성 제거
+ */
+function omit<T, K extends keyof T = keyof T>(keys: K[], obj: T): Omit<T, K> {
+  const result = { ...(obj as object) } as T;
+  for (const key of keys) {
+    delete (result as Record<PropertyKey, unknown>)[key];
+  }
+  return result as Omit<T, K>;
+}
+
+const curriedOmit = curry(omit) as OmitFn;
+export default curriedOmit;

package/src/implement/object/path.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import path from './path';
+
+describe('path', () => {
+  it('gets nested values', () => {
+    const user = { profile: { name: 'A' } };
+    expect(path<string>(['profile', 'name'], user)).toBe('A');
+  });
+});

package/src/implement/object/path.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Path = {
+  (pathArray: string[]): <T>(obj: any) => T | undefined;
+  <T>(...args: [pathArray: string[], obj: any]): T | undefined;
+};
+
+/**
+ * path - 안전한 깊은 프로퍼티 접근
+ */
+function path<T>(pathArray: string[], obj: any): T | undefined {
+  return pathArray.reduce((current, key) => (current == null ? undefined : current[key]), obj) as T | undefined;
+}
+
+const curriedPath = curry(path) as Path;
+export default curriedPath;

package/src/implement/object/pathOr.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import pathOr from './pathOr';
+
+describe('pathOr', () => {
+  it('returns nested value when present', () => {
+    const user = { profile: { name: 'Ada' } };
+    expect(pathOr('unknown', ['profile', 'name'], user)).toBe('Ada');
+  });
+
+  it('returns default when missing or nullish', () => {
+    const user = { profile: { name: null as string | null } };
+    expect(pathOr('unknown', ['profile', 'name'], user)).toBe('unknown');
+    expect(pathOr('none', ['profile', 'age'], user)).toBe('none');
+  });
+});

package/src/implement/object/pathOr.ts

@@ -0,0 +1,18 @@
+import curry from '../composition/curry';
+
+type PathOr = {
+  <D>(...args: [defaultValue: D]): <T>(pathArray: string[]) => (obj: any) => T | D;
+  <D>(...args: [defaultValue: D, pathArray: string[]]): <T>(obj: any) => T | D;
+  <T, D>(...args: [defaultValue: D, pathArray: string[], obj: any]): T | D;
+};
+
+/**
+ * pathOr - 기본값이 있는 깊은 프로퍼티 접근
+ */
+function pathOr<T, D>(defaultValue: D, pathArray: string[], obj: any): T | D {
+  const value = pathArray.reduce((current, key) => (current == null ? undefined : current[key]), obj) as T | undefined;
+  return value == null ? defaultValue : value;
+}
+
+const curriedPathOr = curry(pathOr) as PathOr;
+export default curriedPathOr;

package/src/implement/object/pick.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import pick from './pick';
+
+describe('pick', () => {
+  it('picks keys', () => {
+    const user = { id: 1, name: 'A', active: true };
+    const picked = pick<typeof user>(['id', 'name'], user);
+
+    expect(picked).toEqual({ id: 1, name: 'A' });
+    expect(user).toEqual({ id: 1, name: 'A', active: true }); // immutability
+  });
+});

package/src/implement/object/pick.ts

@@ -0,0 +1,22 @@
+import curry from '../composition/curry';
+
+type PickFn = {
+  <K extends PropertyKey>(...args: [keys: K[]]): <T extends Record<K, unknown>>(obj: T) => Pick<T, K>;
+  <T extends object, K extends keyof T = keyof T>(...args: [keys: K[], obj: T]): Pick<T, K>;
+};
+
+/**
+ * pick - 일부 속성 선택
+ */
+function pick<T extends object, K extends keyof T = 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;
+}
+
+const curriedPick = curry(pick) as PickFn;
+export default curriedPick;

package/src/implement/object/prop.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import prop from './prop';
+
+describe('prop', () => {
+  it('gets a property', () => {
+    const user = { id: 1, name: 'A' };
+    expect(prop<typeof user>('name', user)).toBe('A');
+  });
+});

package/src/implement/object/prop.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Prop = {
+  <K extends PropertyKey>(...args: [key: K]): <T extends Record<K, unknown>>(obj: T) => T[K] | undefined;
+  <T, K extends keyof T = keyof T>(...args: [key: K, obj: T]): T[K] | undefined;
+};
+
+/**
+ * prop - 안전한 프로퍼티 접근
+ */
+function prop<T, K extends keyof T = keyof T>(key: K, obj: T): T[K] | undefined {
+  return obj?.[key];
+}
+
+const curriedProp = curry(prop) as Prop;
+export default curriedProp;

package/src/implement/object/propOr.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import propOr from './propOr';
+
+describe('propOr', () => {
+  it('returns property when present', () => {
+    const user = { id: 1, name: 'Ada' };
+    expect(propOr('unknown', 'name', user)).toBe('Ada');
+  });
+
+  it('returns default when missing or nullish', () => {
+    const user = { id: 1, name: null as string | null };
+    expect(propOr('unknown', 'name', user)).toBe('unknown');
+    expect(propOr('none', 'age' as keyof typeof user, user)).toBe('none');
+  });
+});

package/src/implement/object/propOr.ts

@@ -0,0 +1,22 @@
+import curry from '../composition/curry';
+
+type PropOr = {
+  <D>(...args: [defaultValue: D]): <K extends PropertyKey>(
+    key: K
+  ) => <T extends Record<K, unknown>>(obj: T) => T[K] | D;
+  <D, K extends PropertyKey>(
+    ...args: [defaultValue: D, key: K]
+  ): <T extends Record<K, unknown>>(obj: T) => T[K] | D;
+  <T, K extends keyof T, D>(...args: [defaultValue: D, key: K, obj: T]): T[K] | D;
+};
+
+/**
+ * propOr - 기본값이 있는 프로퍼티 접근
+ */
+function propOr<T, K extends keyof T, D>(defaultValue: D, key: K, obj: T): T[K] | D {
+  const value = obj?.[key];
+  return value == null ? defaultValue : value;
+}
+
+const curriedPropOr = curry(propOr) as PropOr;
+export default curriedPropOr;

package/src/implement/object/values.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import values from './values';
+
+describe('values', () => {
+  it('returns object values', () => {
+    const user = { id: 1, name: 'A' };
+    expect(values(user)).toEqual([1, 'A']);
+  });
+});

package/src/implement/object/values.ts

@@ -0,0 +1,8 @@
+/**
+ * values - 객체 값 배열
+ */
+function values<T extends object>(obj: T): Array<T[keyof T]> {
+  return Object.values(obj) as Array<T[keyof T]>;
+}
+
+export default values;

package/src/implement/string/curried.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import split from './split';
+import join from './join';
+import replace from './replace';
+import match from './match';
+
+describe('string (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(split(',', 'a,b,c')).toEqual(['a', 'b', 'c']);
+    expect(split(',')('a,b,c')).toEqual(['a', 'b', 'c']);
+
+    expect(join('-', ['a', 'b', 'c'])).toBe('a-b-c');
+    expect(join('-')(['a', 'b', 'c'])).toBe('a-b-c');
+
+    expect(replace('a', 'b', 'a-a')).toBe('b-a');
+    expect(replace('a', 'b')('a-a')).toBe('b-a');
+
+    expect(match(/a/g, 'a1a2')).toEqual(['a', 'a']);
+    expect(match(/a/g)('a1a2')).toEqual(['a', 'a']);
+  });
+});

package/src/implement/string/endsWith.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import endsWith from './endsWith';
+
+describe('endsWith', () => {
+  it('returns true when string ends with suffix', () => {
+    expect(endsWith('c', 'abc')).toBe(true);
+    expect(endsWith('abc', 'abc')).toBe(true);
+  });
+
+  it('returns false when string does not end with suffix', () => {
+    expect(endsWith('b', 'abc')).toBe(false);
+  });
+
+  it('works with empty suffix', () => {
+    expect(endsWith('', 'abc')).toBe(true);
+  });
+
+  it('handles array suffix', () => {
+    expect(endsWith(['c'], ['a', 'b', 'c'])).toBe(true);
+    expect(endsWith(['b'], ['a', 'b', 'c'])).toBe(false);
+    expect(endsWith(['b', 'c'], ['a', 'b', 'c'])).toBe(true);
+  });
+});

package/src/implement/string/endsWith.ts

@@ -0,0 +1,21 @@
+/** endsWith - 끝 문자열/배열 확인 */
+function endsWith(suffix: string, str: string): boolean;
+function endsWith<T>(suffix: T[], arr: T[]): boolean;
+function endsWith(suffix: string | any[], target: string | any[]): boolean {
+  if (typeof target === 'string' && typeof suffix === 'string') {
+    return target.endsWith(suffix);
+  }
+
+  if (Array.isArray(suffix) && Array.isArray(target)) {
+    if (suffix.length === 0) return true;
+    if (suffix.length > target.length) return false;
+    for (let i = 0; i < suffix.length; i++) {
+      const targetIdx = target.length - suffix.length + i;
+      if (target[targetIdx] !== suffix[i]) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+export default endsWith;

package/src/implement/string/index.ts

@@ -0,0 +1,9 @@
+export { default as trim } from './trim';
+export { default as split } from './split';
+export { default as join } from './join';
+export { default as replace } from './replace';
+export { default as toUpper } from './toUpper';
+export { default as toLower } from './toLower';
+export { default as startsWith } from './startsWith';
+export { default as endsWith } from './endsWith';
+export { default as match } from './match';

package/src/implement/string/join.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import join from './join';
+
+describe('join', () => {
+  it('joins array with separator', () => {
+    expect(join(',', ['a', 'b', 'c'])).toBe('a,b,c');
+  });
+
+  it('handles empty arrays', () => {
+    expect(join(',', [])).toBe('');
+  });
+
+  it('works with single element', () => {
+    expect(join('-', ['solo'])).toBe('solo');
+  });
+});

package/src/implement/string/join.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** join - 배열 결합 */
+function join(separator: string, arr: string[]): string {
+  return arr.join(separator);
+}
+export default curry(join);

package/src/implement/string/match.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import match from './match';
+
+describe('match', () => {
+  it('returns matches for regex', () => {
+    const result = match(/ba./g, 'banana');
+    expect(result).toEqual(['ban']);
+  });
+
+  it('returns null when no match', () => {
+    expect(match(/xyz/, 'banana')).toBeNull();
+  });
+});

package/src/implement/string/match.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** match - 정규식 매칭 */
+function match(pattern: RegExp, str: string): RegExpMatchArray | null {
+  return str.match(pattern);
+}
+export default curry(match);

package/src/implement/string/replace.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import replace from './replace';
+
+describe('replace', () => {
+  it('replaces substring occurrences', () => {
+    expect(replace('foo', 'bar', 'foo foo')).toBe('bar foo');
+  });
+
+  it('supports regex replacements', () => {
+    expect(replace(/a./g, 'x', 'abcdab')).toBe('xcdx');
+  });
+});

package/src/implement/string/replace.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** replace - 부분 치환 */
+function replace(pattern: string | RegExp, replacement: string, str: string): string {
+  return str.replace(pattern, replacement);
+}
+export default curry(replace);

package/src/implement/string/split.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import split from './split';
+
+describe('split', () => {
+  it('splits by separator', () => {
+    expect(split(',', 'a,b,c')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('handles missing separator occurrences', () => {
+    expect(split(',', 'abc')).toEqual(['abc']);
+  });
+});

package/src/implement/string/split.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** split - 문자열 분할 */
+function split(separator: string, str: string): string[] {
+  return str.split(separator);
+}
+export default curry(split);

package/src/implement/string/startsWith.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import startsWith from './startsWith';
+
+describe('startsWith', () => {
+  it('returns true when the string starts with the prefix', () => {
+    expect(startsWith('he', 'hello')).toBe(true);
+  });
+
+  it('returns false when the string does not start with the prefix', () => {
+    expect(startsWith('no', 'hello')).toBe(false);
+  });
+
+  it('treats empty prefix as true', () => {
+    expect(startsWith('', 'hello')).toBe(true);
+  });
+
+  it('supports array prefix checks', () => {
+    expect(startsWith([1, 2], [1, 2, 3])).toBe(true);
+    expect(startsWith([2, 3], [1, 2, 3])).toBe(false);
+  });
+});

package/src/implement/string/startsWith.ts

@@ -0,0 +1,20 @@
+/** startsWith - 시작 문자열/배열 확인 */
+function startsWith(prefix: string, str: string): boolean;
+function startsWith<T>(prefix: T[], arr: T[]): boolean;
+function startsWith(prefix: string | any[], target: string | any[]): boolean {
+  if (typeof target === 'string' && typeof prefix === 'string') {
+    return target.startsWith(prefix);
+  }
+
+  if (Array.isArray(prefix) && Array.isArray(target)) {
+    if (prefix.length === 0) return true;
+    if (prefix.length > target.length) return false;
+    for (let i = 0; i < prefix.length; i++) {
+      if (target[i] !== prefix[i]) return false;
+    }
+    return true;
+  }
+
+  return false;
+}
+export default startsWith;

package/src/implement/string/toLower.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import toLower from './toLower';
+
+describe('toLower', () => {
+  it('converts a string to lowercase', () => {
+    expect(toLower('HELLO')).toBe('hello');
+    expect(toLower('HeLLo')).toBe('hello');
+  });
+
+  it('returns the same string when already lowercase', () => {
+    expect(toLower('fp-pack')).toBe('fp-pack');
+  });
+});

package/src/implement/string/toLower.ts

@@ -0,0 +1,5 @@
+/** toLower - 소문자 변환 */
+function toLower(str: string): string {
+  return str.toLowerCase();
+}
+export default toLower;

package/src/implement/string/toUpper.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import toUpper from './toUpper';
+
+describe('toUpper', () => {
+  it('converts a string to uppercase', () => {
+    expect(toUpper('hello')).toBe('HELLO');
+    expect(toUpper('HeLLo')).toBe('HELLO');
+  });
+
+  it('returns the same string when already uppercase', () => {
+    expect(toUpper('FP-PACK')).toBe('FP-PACK');
+  });
+});

package/src/implement/string/toUpper.ts

@@ -0,0 +1,5 @@
+/** toUpper - 대문자 변환 */
+function toUpper(str: string): string {
+  return str.toUpperCase();
+}
+export default toUpper;

package/src/implement/string/trim.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import trim from './trim';
+
+describe('trim', () => {
+  it('removes whitespace from both ends', () => {
+    expect(trim('  hello  ')).toBe('hello');
+  });
+
+  it('returns the same string when no trim needed', () => {
+    expect(trim('fp-pack')).toBe('fp-pack');
+  });
+});

package/src/implement/string/trim.ts

@@ -0,0 +1,5 @@
+/** trim - 공백 제거 */
+function trim(str: string): string {
+  return str.trim();
+}
+export default trim;