fp-pack 0.4.0 → 0.6.0

package/src/implement/composition/pipe.type-test.ts

@@ -1,4 +1,4 @@
-import SideEffect from './sideEffect';
+import SideEffect, { runPipeResult } from './sideEffect';
 import from from './from';
 import pipe from './pipe';
 import pipeSideEffect from './pipeSideEffect';
@@ -71,6 +71,13 @@ export const pipeFromTenValue = pipeFromTen('input');
 type PipeFromTenValueExpected = string;
 export type PipeFromTenValueIsStrict = Expect<Equal<typeof pipeFromTenValue, PipeFromTenValueExpected>>;
 
+export const pipeFromTenValueNoInput = pipeFromTen();
+
+type PipeFromTenValueNoInputExpected = string;
+export type PipeFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeFromTenValueNoInput, PipeFromTenValueNoInputExpected>
+>;
+
 export const pipeWithSideEffectInput = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -130,6 +137,13 @@ export type PipeSideEffectFromTenValueIsStrict = Expect<
   Equal<typeof pipeSideEffectFromTenValue, PipeSideEffectFromTenValueExpected>
 >;
 
+export const pipeSideEffectFromTenValueNoInput = pipeSideEffectFromTen();
+
+type PipeSideEffectFromTenValueNoInputExpected = string | SideEffect<any>;
+export type PipeSideEffectFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeSideEffectFromTenValueNoInput, PipeSideEffectFromTenValueNoInputExpected>
+>;
+
 export const purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -187,6 +201,13 @@ export type PipeAsyncFromTenValueIsStrict = Expect<
   Equal<typeof pipeAsyncFromTenValue, PipeAsyncFromTenValueExpected>
 >;
 
+export const pipeAsyncFromTenValueNoInput = pipeAsyncFromTen();
+
+type PipeAsyncFromTenValueNoInputExpected = Promise<string>;
+export type PipeAsyncFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeAsyncFromTenValueNoInput, PipeAsyncFromTenValueNoInputExpected>
+>;
+
 export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -252,6 +273,13 @@ export type PipeAsyncSideEffectFromTenValueIsStrict = Expect<
   Equal<typeof pipeAsyncSideEffectFromTenValue, PipeAsyncSideEffectFromTenValueExpected>
 >;
 
+export const pipeAsyncSideEffectFromTenValueNoInput = pipeAsyncSideEffectFromTen();
+
+type PipeAsyncSideEffectFromTenValueNoInputExpected = Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectFromTenValueNoInput, PipeAsyncSideEffectFromTenValueNoInputExpected>
+>;
+
 export const strictPipeSideEffect = pipeSideEffectStrict(
   (value: number) => value + 1,
   (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -268,6 +296,15 @@ type StrictSideEffectValue = ValueUnion<typeof strictPipeSideEffectResult>;
 type StrictSideEffectValueExpected = number;
 export type PipeSideEffectStrictValue = Expect<Equal<StrictSideEffectValue, StrictSideEffectValueExpected>>;
 
+export const strictPipeSideEffectRunResult = runPipeResult(strictPipeSideEffectResult);
+
+type StrictPipeSideEffectRunExpected =
+  | ValueUnion<typeof strictPipeSideEffectResult>
+  | EffectUnion<typeof strictPipeSideEffectResult>;
+export type PipeSideEffectStrictRunPipeResultIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectRunResult, StrictPipeSideEffectRunExpected>
+>;
+
 export const strictPipeSideEffectInput = strictPipeSideEffect(SideEffect.of(() => 'INPUT' as const));
 
 type StrictSideEffectInputEffects = EffectUnion<typeof strictPipeSideEffectInput>;
@@ -343,6 +380,20 @@ type StrictFromTenValue = ValueUnion<typeof strictPipeSideEffectFromTenResult>;
 type StrictFromTenValueExpected = number;
 export type PipeSideEffectStrictFromTenValue = Expect<Equal<StrictFromTenValue, StrictFromTenValueExpected>>;
 
+export const strictPipeSideEffectFromTenResultNoInput = strictPipeSideEffectFromTen();
+
+type StrictFromTenNoInputEffects = EffectUnion<typeof strictPipeSideEffectFromTenResultNoInput>;
+type StrictFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeSideEffectStrictFromTenNoInputEffects = Expect<
+  Equal<StrictFromTenNoInputEffects, StrictFromTenNoInputEffectsExpected>
+>;
+
+type StrictFromTenNoInputValue = ValueUnion<typeof strictPipeSideEffectFromTenResultNoInput>;
+type StrictFromTenNoInputValueExpected = number;
+export type PipeSideEffectStrictFromTenNoInputValue = Expect<
+  Equal<StrictFromTenNoInputValue, StrictFromTenNoInputValueExpected>
+>;
+
 export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -443,3 +494,18 @@ type StrictAsyncFromTenValueExpected = number;
 export type PipeAsyncSideEffectStrictFromTenValue = Expect<
   Equal<StrictAsyncFromTenValue, StrictAsyncFromTenValueExpected>
 >;
+
+export const strictPipeAsyncSideEffectFromTenResultNoInput = strictPipeAsyncSideEffectFromTen();
+
+type StrictAsyncFromTenNoInputResolved = Awaited<typeof strictPipeAsyncSideEffectFromTenResultNoInput>;
+type StrictAsyncFromTenNoInputEffects = EffectUnion<StrictAsyncFromTenNoInputResolved>;
+type StrictAsyncFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeAsyncSideEffectStrictFromTenNoInputEffects = Expect<
+  Equal<StrictAsyncFromTenNoInputEffects, StrictAsyncFromTenNoInputEffectsExpected>
+>;
+
+type StrictAsyncFromTenNoInputValue = ValueUnion<StrictAsyncFromTenNoInputResolved>;
+type StrictAsyncFromTenNoInputValueExpected = number;
+export type PipeAsyncSideEffectStrictFromTenNoInputValue = Expect<
+  Equal<StrictAsyncFromTenNoInputValue, StrictAsyncFromTenNoInputValueExpected>
+>;

package/src/implement/composition/pipeSideEffect.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from './from';
 import SideEffect, { isSideEffect } from './sideEffect';
 
 type MaybeSideEffect<T> = T | SideEffect<any>;
@@ -18,6 +19,9 @@ type Resolve<T> = T extends infer R ? R : never;
 type PipeSideEffect<Fns extends UnaryFn<any, any>[]> = (
   input: PipeInput<Fns> | SideEffect<any>
 ) => Resolve<PipeOutput<Fns>>;
+type PipeSideEffectFrom<Fns extends [FromFn<any>, ...UnaryFn<any, any>[]]> = (
+  input?: PipeInput<Fns> | SideEffect<any>
+) => Resolve<PipeOutput<Fns>>;
 
 function pipeSideEffect<R>(ab: ZeroFn<R>): () => MaybeSideEffect<R>;
 function pipeSideEffect<B, R>(ab: ZeroFn<B>, bc: UnaryFn<B, R>): () => MaybeSideEffect<R>;
@@ -85,6 +89,7 @@ function pipeSideEffect<B, C, D, E, F, G, H, I, J, R>(
   ij: UnaryFn<I, J>,
   jk: UnaryFn<J, R>
 ): () => MaybeSideEffect<R>;
+function pipeSideEffect<Fns extends [FromFn<any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeSideEffectFrom<Fns>;
 function pipeSideEffect<A, R>(ab: UnaryFn<A, R>): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
 function pipeSideEffect<A, B, R>(
   ab: UnaryFn<A, B>,

package/src/implement/composition/pipeSideEffectStrict.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from './from';
 import SideEffect, { isSideEffect } from './sideEffect';
 
 type AnyFn = (...args: any[]) => any;
@@ -43,6 +44,12 @@ type PipeSideEffectStrictUnary<Fns extends [AnyFn, ...AnyFn[]]> = {
     input: PipeInputStrict<Fns> | SideEffect<EIn>
   ): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>;
 };
+type PipeSideEffectStrictUnaryOptional<Fns extends [AnyFn, ...AnyFn[]]> = {
+  (input?: PipeInputStrict<Fns>): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>;
+  <EIn>(
+    input?: PipeInputStrict<Fns> | SideEffect<EIn>
+  ): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>;
+};
 
 type PipeSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
   ? () => Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>
@@ -177,6 +184,9 @@ function pipeSideEffectStrict<B, C, D, E, F, G, H, I, J, R>(
   UnaryFn<NonSideEffect<I>, J>,
   UnaryFn<NonSideEffect<J>, R>
 ]>;
+function pipeSideEffectStrict<Fns extends [FromFn<any>, ...AnyFn[]]>(
+  ...funcs: Fns
+): PipeSideEffectStrictUnaryOptional<Fns>;
 function pipeSideEffectStrict<A, R>(ab: UnaryFn<A, R>): PipeSideEffectStrict<[UnaryFn<A, R>]>;
 function pipeSideEffectStrict<A, B, R>(
   ab: UnaryFn<A, B>,

package/src/implement/composition/sideEffect.ts

@@ -15,7 +15,7 @@ export class SideEffect<T = unknown> {
   }
 }
 
-type MatchHandlers<T, RValue, REffect> = {
+export type MatchHandlers<T, RValue, REffect> = {
   value: (value: T) => RValue;
   effect: (sideEffect: SideEffect) => REffect;
 };

package/src/implement/object/assocPath.ts

@@ -1,6 +1,5 @@
 import curry from '../composition/curry';
-
-type PathKey = string | number | symbol;
+import type { PathKey } from './pathKey';
 
 const isIndexKey = (key: PathKey): key is number | `${number}` => {
   if (typeof key === 'number') {
@@ -62,3 +61,4 @@ function assocPath<T = unknown>(pathArray: PathKey[], value: unknown, obj: unkno
 
 const curriedAssocPath = curry(assocPath) as AssocPath;
 export default curriedAssocPath;
+export type { PathKey };

package/src/implement/object/dissocPath.ts

@@ -1,6 +1,5 @@
 import curry from '../composition/curry';
-
-type PathKey = string | number | symbol;
+import type { PathKey } from './pathKey';
 
 const isIndexKey = (key: PathKey): key is number | `${number}` => {
   if (typeof key === 'number') {
@@ -78,3 +77,4 @@ function dissocPath<T = unknown>(pathArray: PathKey[], obj: T): T {
 
 const curriedDissocPath = curry(dissocPath) as DissocPath;
 export default curriedDissocPath;
+export type { PathKey };

package/src/implement/object/index.ts

@@ -19,3 +19,4 @@ export { default as mapValues } from './mapValues';
 export { default as evolve } from './evolve';
 export { default as has } from './has';
 export { default as hasPath } from './hasPath';
+export type { PathKey } from './pathKey';

package/src/implement/object/path.ts

@@ -1,16 +1,18 @@
 import curry from '../composition/curry';
+import type { PathKey } from './pathKey';
 
 type Path = {
-  (pathArray: string[]): <T>(obj: any) => T | undefined;
-  <T>(...args: [pathArray: string[], obj: any]): T | undefined;
+  (pathArray: PathKey[]): <T>(obj: any) => T | undefined;
+  <T>(...args: [pathArray: PathKey[], obj: any]): T | undefined;
 };
 
 /**
  * path - 안전한 깊은 프로퍼티 접근
  */
-function path<T>(pathArray: string[], obj: any): T | undefined {
+function path<T>(pathArray: PathKey[], 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;
+export type { PathKey };

package/src/implement/object/pathKey.ts

@@ -0,0 +1 @@
+export type PathKey = string | number | symbol;

package/src/implement/object/pathOr.ts

@@ -1,18 +1,20 @@
 import curry from '../composition/curry';
+import type { PathKey } from './pathKey';
 
 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;
+  <D>(...args: [defaultValue: D]): <T>(pathArray: PathKey[]) => (obj: any) => T | D;
+  <D>(...args: [defaultValue: D, pathArray: PathKey[]]): <T>(obj: any) => T | D;
+  <T, D>(...args: [defaultValue: D, pathArray: PathKey[], obj: any]): T | D;
 };
 
 /**
  * pathOr - 기본값이 있는 깊은 프로퍼티 접근
  */
-function pathOr<T, D>(defaultValue: D, pathArray: string[], obj: any): T | D {
+function pathOr<T, D>(defaultValue: D, pathArray: PathKey[], 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;
+export type { PathKey };

package/src/index.ts

@@ -30,3 +30,6 @@ export * from './implement/nullable';
 
 // Debug
 export * from './implement/debug';
+
+// Stream Types
+export type { AnyIterable, AnyIterableInput, PromiseLikeValue } from './stream/utils';

package/src/stream/index.ts

@@ -21,3 +21,4 @@ export { default as toArray } from './toArray';
 export { default as toAsync } from './toAsync';
 export { default as zip } from './zip';
 export { default as zipWith } from './zipWith';
+export type { AnyIterable, AnyIterableInput, PromiseLikeValue } from './utils';