@golemui/core 1.3.0 → 1.4.0-rc.0

package/lib/store/reducers/utils.d.ts

@@ -1,30 +1,8 @@
-import { State } from '../model';
-/**
- * Conditionally applies a reducer function based on a predicate
- *
- * This higher-order reducer creates a new reducer that only applies the given
- * reducer function when the predicate function returns true for the current state.
- * If the predicate returns false, the state is returned unchanged.
- *
- * @param predicate - A function that takes the current state and returns a boolean
- * indicating whether the reducer should be applied
- * @param reducerFn - The reducer function to apply when the predicate returns true
- *
- * @returns A new reducer function that conditionally applies the given reducer
- *
- * @example
- * ```typescript
- * // Only increment if count is less than 10
- * const conditionalIncrement = reduceIf(
- *   (state: { count: number }) => state.count < 10,
- *   (state) => ({ ...state, count: state.count + 1 })
- * );
- *
- * conditionalIncrement({ count: 5 }); // returns { count: 6 }
- * conditionalIncrement({ count: 10 }); // returns { count: 10 } (unchanged)
- * ```
- */
-export declare const reduceIf: (predicate: (state: State) => boolean, reducerFn: (state: State) => State) => (state: State) => State;
 export declare const hasWhen: (val: unknown) => val is {
     when: string;
 };
+/**
+ * Compares arrays by their elements and plain objects by their properties,
+ * everything else is comppared by reference using `===`.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/lib/store/selectors.d.ts

@@ -1,25 +1,3 @@
 import { Observable } from 'rxjs';
-import { LayoutWidget } from '../form-widget';
-import { DotPath, Uid } from '../shared';
 import { State } from './model';
-export declare const dataByPath$: <T = any>(path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<T>>;
-export declare const validationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
-export declare const injectedValidationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
-/**
- * Emits the current calculated widget for the given uid
- * Re triggers on widget changes OR store.lang changes
- */
-export declare const calculatedWidgetsByUid$: (uid: Uid) => (state$: Observable<State>) => Observable<import('../form-widget').NonFunctionWidget<string, any, any>>;
-export declare const calculatedLayoutChildrenByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<(import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, /*elided*/ any> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]>>;
-export declare const selectWidgetFlags: import('rxjs').UnaryFunction<Observable<State>, Observable<Record<string, {
-    hidden?: boolean;
-    readonly?: boolean;
-    disabled?: boolean;
-}>>>;
-export declare const widgetFlagsByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<{
-    hidden?: boolean;
-    readonly?: boolean;
-    disabled?: boolean;
-}>>;
-export declare const touchedControlsByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<boolean>>;
 export declare const formHealth: (store: Observable<State>) => Observable<import('./model').FormHealth>;

package/lib/store/view-model.d.ts

@@ -0,0 +1,92 @@
+import { Observable } from 'rxjs';
+import { FormWidget, NonFunctionWidget } from '../form-widget';
+import { Uid } from '../shared';
+import { State } from './model';
+/**
+ * One render-ready snapshot of everything a widget component needs from the store, so a binding
+ * can serve a widget from a single subscription (or a single snapshot read) instead of one
+ * subscription per store slice.
+ *
+ * Hidden widgets are reported as they are: `widget` is `undefined` and `hidden` is `true`. This
+ * differs from the calculated-widget lookup, which holds no entry for a hidden widget and
+ * therefore leaves subscribers holding the last visible value.
+ */
+export type WidgetViewModel<T = unknown> = {
+    uid: Uid;
+    /**
+     * The fully calculated widget (`calculatedWidgets[uid].current`), `undefined` while the widget
+     * is hidden or absent from the current derive.
+     */
+    widget: NonFunctionWidget<string> | undefined;
+    /**
+     * A layout widget's visible children, with repeater row indexes already applied to each child's
+     * `uid` and `path`. Empty for non-layout widgets and while hidden. Bindings can hand these nodes
+     * straight to their widget renderer without applying the indexes themselves.
+     */
+    children: FormWidget<string>[];
+    /**
+     * For a repeater input, one fully indexed row layout node per row of its array value, ready to
+     * render. Empty for non-repeater widgets and while hidden. Row order matches the data array, so
+     * a row's position in this list is also its index in the value. The one exception is an errored
+     * derive, where a row the failed derive never resolved is left out until the form recovers.
+     */
+    rows: NonFunctionWidget<string>[];
+    /** The BCP 47 language tag of the current locale. */
+    lang: string;
+    /** The form data at the widget's path, `undefined` for widgets without a path. */
+    value: T | undefined;
+    /**
+     * Schema and injected validation messages merged into one list. Empty until the form has been
+     * touched, so nothing shows before the user interacts.
+     */
+    errors: string[];
+    /** Whether this control has been touched and may display its errors. */
+    touched: boolean;
+    /**
+     * True when the form has been touched and is currently invalid. This is what action widgets
+     * (submit buttons) render as their `invalid` state.
+     */
+    formInvalid: boolean;
+    /** The widget's `hidden` flag for the current derive. */
+    hidden: boolean;
+};
+/**
+ * Reads one widget's view model out of a state snapshot. Pure and uncached: every call builds
+ * fresh objects. Use {@link createWidgetViewModelReader} when reference stability across calls
+ * matters (change detection, `distinctUntilChanged`, React's `useSyncExternalStore`).
+ *
+ * @param state - A store state snapshot (`store.getState()`).
+ * @param uid - The widget's uid, including repeater row indexes when the widget lives inside a
+ *   repeater row (e.g. `firstName[0]`).
+ * @returns The widget's view model.
+ * @example
+ * const vm = widgetViewModel<string>(store.getState(), 'firstName');
+ * vm.value; // the data at the widget's path
+ * vm.errors; // [] until the form is touched
+ */
+export declare function widgetViewModel<T = unknown>(state: State, uid: Uid): WidgetViewModel<T>;
+/**
+ * Creates a memoizing reader over {@link widgetViewModel}: for a given uid it returns the exact
+ * same object until one of that widget's state slices changes, and reuses the `children` / `rows`
+ * / `errors` arrays while their own inputs are unchanged. Create one reader per store and keep it
+ * for the store's lifetime.
+ *
+ * @returns A reader function over a state snapshot and a uid.
+ * @example
+ * const readViewModel = createWidgetViewModelReader();
+ * const a = readViewModel(store.getState(), 'firstName');
+ * // ... an unrelated widget changes ...
+ * const b = readViewModel(store.getState(), 'firstName');
+ * a === b; // true
+ */
+export declare function createWidgetViewModelReader(): <T = unknown>(state: State, uid: Uid) => WidgetViewModel<T>;
+/**
+ * RxJS operator form of {@link widgetViewModel} for subscribe-based bindings: maps the store's
+ * `state$` to the widget's view model and emits only when the view model actually changed.
+ *
+ * @param uid - The widget's uid, row indexes included when it lives inside a repeater row.
+ * @returns An operator from a state stream to a view model stream.
+ * @example
+ * store.state$.pipe(widgetViewModel$('firstName')).subscribe((vm) => { ... });
+ */
+export declare const widgetViewModel$: <T = unknown>(uid: Uid) => (state$: Observable<State>) => Observable<WidgetViewModel<T>>;

package/lib/utils/form.d.ts

@@ -1,5 +1,5 @@
 import { FormWidget } from '../form-widget';
-import { $Errors } from '../shared';
+import { $Errors, DotPath } from '../shared';
 import { State } from '../store/model';
 /**
  * Flattens the hierarchical form structure into a single-level array of form widgets.
@@ -21,16 +21,29 @@ import { State } from '../store/model';
  */
 export declare function flattenForm(widgets: FormWidget[]): FormWidget[];
 /**
- * Calculates validation variables to be used in reactive expressions
- * e.g. `{ invalidAge: '!!$errors.age' }` or { disabled { when: '$formIsInvalid' } }
+ * The validation variables reactive expressions can read.
  */
-export declare function calculateValidationVariables(state: State): {
+export type ValidationVariables = {
     $formIsInvalid: boolean;
     $errors: $Errors;
 };
+/**
+ * Calculates validation variables to be used in reactive expressions
+ * e.g. `{ invalidAge: '!!$errors.age' }` or { disabled { when: '$formIsInvalid' } }
+ */
+export declare function calculateValidationVariables(state: State): ValidationVariables;
+/**
+ * The data path a widget owns: an input widget's `path`, or a function widget's `path` when it
+ * returns a control. A function widget is stored as the callable itself, so `isInputWidget` is
+ * false for it and its path is the one the decoder stamped on the function object.
+ *
+ * @param widget - A `resolvedSources` entry, or a `calculatedWidgets` `current` / `source`.
+ * @returns The path, or `undefined` for a widget that owns none.
+ */
+export declare function inputPath(widget: FormWidget<string> | undefined): DotPath | undefined;
 /**
  * Returns a copy of the form data with values for currently-hidden input widgets removed.
- * Paths are derived from the flat form widget map so this works even though hidden widgets
- * are absent from calculatedWidgets.
+ * Paths come from `resolvedSources`, so hidden repeater row inputs are pruned too and hidden
+ * widgets absent from calculatedWidgets are still covered.
  */
 export declare function pruneHiddenData(state: State): Record<string, any>;

package/lib/utils/justin.d.ts

@@ -1,3 +1,4 @@
+import { Evaluator } from 'subscript/justin';
 import { $Errors, ExpressionFunctions, ReactiveExpression } from '../shared';
 import { State } from '../store/model';
 /**
@@ -13,5 +14,14 @@ export type RepeaterItemExpressionScope = {
 export type ExpressionExtraScope = RepeaterItemExpressionScope & {
     $fn?: ExpressionFunctions;
 };
+export declare const COMPILED_EXPRESSION_CACHE_LIMIT = 2000;
+/**
+ * Returns the compiled evaluator for an expression, compiling on the first call.
+ *
+ * Row-rewritten `when` expressions are distinct per row, so the cache grows with the row
+ * count and is cleared when it reaches the limit. The next call recompiles. A failed parse
+ * is never cached, so an invalid expression throws the same error on every call.
+ */
+export declare function compileExpression(expression: string): Evaluator;
 export declare function expressionIsTrue(expression: ReactiveExpression, $form: State['data'], $meta: State['meta'], $errors: $Errors, $formIsInvalid: boolean, extraScope?: ExpressionExtraScope): boolean;
 export declare function normalizeArrayIndexes(expression: string): string;

package/lib/utils/object.d.ts

@@ -48,6 +48,25 @@ import { DotPath } from '../shared';
  * ```
  */
 export declare const get: <T = any>(obj: Record<string, any>, path: DotPath) => T;
+/**
+ * Tells whether every segment of a dot-separated path is present in the object.
+ *
+ * Unlike `get`, a leaf that is present but holds `undefined` counts as existing, which is
+ * what distinguishes "the value was never written" from "the value was cleared".
+ *
+ * @param object - The object to look the path up in
+ * @param path - A dot-separated path (e.g. "user.profile.name" or "users.0.name").
+ *   An empty path returns false.
+ * @returns True when every segment exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * pathExists({ user: { name: undefined } }, 'user.name'); // true
+ * pathExists({ user: {} }, 'user.name');                  // false
+ * pathExists({ users: [{ name: 'Alice' }] }, 'users.1');  // false
+ * ```
+ */
+export declare const pathExists: (object: Record<string, any>, path: DotPath) => boolean;
 /**
  * Sets the value at path of object by mutation.
  * If a portion of path doesn't exist, it's created.
@@ -119,10 +138,25 @@ export declare const get: <T = any>(obj: Record<string, any>, path: DotPath) =>
  * ```
  */
 export declare const set: (object: Record<string, any>, path: DotPath, value: any) => Record<string, any>;
+/**
+ * Returns a copy of `object` with `value` set at `path`, copying only the containers along
+ * the path. Untouched siblings keep their references and `object` is never modified, so the
+ * result can be compared to the input by reference at any level. Missing containers are
+ * created like {@link set}: an array when the next key is an index, an object otherwise.
+ * @param object - The object to copy and write into.
+ * @param path - Dot-separated path, array indexes as numeric segments.
+ * @param value - The value to set at the path.
+ * @returns A new root object with the value set.
+ * @example
+ * const next = copyOnWriteSet({ a: { b: 1 }, c: { d: 2 } }, 'a.b', 3);
+ * next.a.b;           // 3
+ * next.c;             // the input's c, by reference
+ */
+export declare const copyOnWriteSet: (object: Record<string, any>, path: DotPath, value: any) => Record<string, any>;
 /**
  * Removes the property at the given dot-path from object by mutation.
  * After deletion, any ancestor plain objects that become empty are also removed.
- * Ancestor arrays that become empty are left in place — upward pruning stops as
+ * Ancestor arrays that become empty are left in place, upward pruning stops as
  * soon as an array boundary is encountered.
  *
  * @param object - The object to modify
@@ -144,7 +178,7 @@ export declare const set: (object: Record<string, any>, path: DotPath, value: an
  * ```typescript
  * const obj = { a: { b: { c: 1 } } };
  * unset(obj, 'a.b.c');
- * // Result: {} — 'b' and 'a' are pruned because they became empty objects
+ * // Result: {} ('b' and 'a' are pruned because they became empty objects)
  * ```
  *
  * @example
@@ -152,25 +186,10 @@ export declare const set: (object: Record<string, any>, path: DotPath, value: an
  * ```typescript
  * const obj = { items: [{ name: 'Alice' }] };
  * unset(obj, 'items.0.name');
- * // Result: { items: [{}] } — the empty object is kept inside the array
+ * // Result: { items: [{}] } (the empty object is kept inside the array)
  * ```
  */
 export declare const unset: <T extends Record<string, any>>(object: T, path: DotPath) => T;
-/**
- * Deletes a key from an object and returns the same mutated object.
- *
- * @param object - The object to remove the key from.
- * @param key - The property name to delete.
- * @returns The same object, with the specified key removed.
- *
- * @example
- * ```ts
- * const obj = { a: 1, b: 2, c: 3 };
- * deleteKey(obj, "b");
- * console.log(obj); // { a: 1, c: 3 }
- * ```
- */
-export declare const deleteKey: (object: Record<string, any>, key: string) => Record<string, any>;
 /**
  * Deep-clones plain objects and arrays while preserving function references
  * (and other non-plain values) by reference. Functions are stateless widget

package/lib/utils/repeater.d.ts

@@ -1,5 +1,45 @@
-import { FormWidget, NonFunctionWidget } from '../form-widget';
+import { FormWidget, InputWidget, LayoutWidget, NonFunctionWidget } from '../form-widget';
 import { Uid } from '../shared';
+import { RepeaterItemScope, State } from '../store/model';
+/**
+ * A repeater input widget as the core reads it: an input with a layout template under `props.template`.
+ */
+export type RepeaterTemplateWidget = InputWidget<string> & {
+    type: 'repeater';
+    props: {
+        template: LayoutWidget<string>;
+    };
+};
+export declare const isRepeaterWidget: (widget: FormWidget<string>) => widget is RepeaterTemplateWidget;
+/** `"abc[0][1]"` -> `[0, 1]`, `"abc"` -> `[]`. */
+export declare const extractRepeaterIndexes: (uid: string) => number[];
+/**
+ * The two maps `expandSources` builds from the form and the data.
+ */
+export type ExpandedSources = {
+    resolvedSources: Record<Uid, FormWidget<string>>;
+    repeaterItemScopes: Record<Uid, RepeaterItemScope>;
+};
+/**
+ * Walks the flat form and the current data and returns every widget that exists for that data.
+ *
+ * `resolvedSources` holds the `flatForm` widgets by reference plus, for every repeater row, one entry
+ * per template widget (the row layout node included) with the row indexes written into `uid` and `path`.
+ * Nested repeater containers are entries too and are recursed with their concrete path. Function widgets
+ * stay callable (see {@link makeRepeaterItemConfig}), `when` expressions are not rewritten here.
+ *
+ * `repeaterItemScopes` maps every row widget uid to the innermost item that owns it.
+ *
+ * @param flatForm - The flattened form definition keyed by uid.
+ * @param data - The current form data the repeater arrays are read from.
+ * @returns Both maps, rebuilt from scratch.
+ *
+ * @example
+ * const { resolvedSources, repeaterItemScopes } = expandSources(flatForm, { users: [{}, {}] });
+ * resolvedSources['name[1]'].path;      // 'users.1.name'
+ * repeaterItemScopes['name[1]'];        // { itemPath: 'users.1', index: 1 }
+ */
+export declare function expandSources(flatForm: State['flatForm'], data: Record<string, any>): ExpandedSources;
 /**
  * Derives a concrete widget config for a specific repeater item by materializing the provided indexes into the
  * widget's `uid` (and `path` for input widgets).
@@ -46,7 +86,8 @@ export declare function transformRepeaterItemWhenExpression(expression: string,
  *
  * @param widget - A widget already materialized for a repeater item (see {@link makeRepeaterItemConfig}).
  * @param repeaterIndexes - Ordered list of indexes for each nesting level.
- * @returns A new widget config with item-concrete `when` expressions. The original is not mutated.
+ * @returns A new widget config with item-concrete `when` expressions, or the input widget by
+ * reference when no flag field has a `when` expression. The original is never mutated.
  *
  * @example
  * // repeaterIndexes = [1]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golemui/core",
-  "version": "1.3.0",
+  "version": "1.4.0-rc.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"

package/lib/store/reducers/add-widget.d.ts

@@ -1,3 +0,0 @@
-import { ADD_WIDGET } from '../actions';
-import { State } from '../model';
-export declare function addWidget(state: State, action: ADD_WIDGET): State;

package/lib/store/reducers/materialize-repeater-items.d.ts

@@ -1,10 +0,0 @@
-import { State } from '../model';
-/**
- * Walks every repeater's live array data and derives, per item, the same concrete widgets the renderer mounts for that item.
- * Produces two maps keyed by materialized uid, both rebuilt from scratch on every run:
- * - `repeaterItemScopes`: which item owns each widget (binds `$item` / `$index`).
- * - `materializedRepeaterWidgets`: the item-concrete widget configs, with uid and path baked, `when` expressions rewritten for the item's row, and function widgets resolved.
- *
- * `calculateWidgetFlags` and `calculateWidgetProps` consume these maps, so this stage must run before them in the pipeline.
- */
-export declare const materializeRepeaterItems: (state: State) => State;

package/lib/store/reducers/remove-widget.d.ts

@@ -1,3 +0,0 @@
-import { REMOVE_WIDGET } from '../actions';
-import { State } from '../model';
-export declare function removeWidget(state: State, action: REMOVE_WIDGET): State;

package/lib/utils/function.d.ts

@@ -1,71 +0,0 @@
-/**
- * A function type that transforms a value of type A to type B
- */
-type Func<A, B> = (arg: A) => B;
-/**
- * Performs left-to-right function composition (pipeline).
- * The output of each function is passed as input to the next function.
- *
- * @typeParam A - The initial value type
- * @param value - The initial value to pipe through the functions
- * @param fns - Functions to apply in sequence
- * @returns The result after applying all functions
- *
- * @example
- * ```typescript
- * const addOne = (x: number) => x + 1;
- * const double = (x: number) => x * 2;
- * const toString = (x: number) => `Result: ${x}`;
- *
- * const result = pipe(5, addOne, double, toString); // 5 -> 6 -> 12 -> "Result: 12"
- * ```
- */
-declare function pipe<A>(value: A): A;
-/** @see {@link pipe} */
-declare function pipe<A, B>(value: A, fn1: Func<A, B>): B;
-/** @see {@link pipe} */
-declare function pipe<A, B, C>(value: A, fn1: Func<A, B>, fn2: Func<B, C>): C;
-/** @see {@link pipe} */
-declare function pipe<A, B, C, D>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>): D;
-/** @see {@link pipe} */
-declare function pipe<A, B, C, D, E>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>): E;
-/** @see {@link pipe} */
-declare function pipe<A, B, C, D, E, F>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>): F;
-/** @see {@link pipe} */
-declare function pipe<A, B, C, D, E, F, G>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>, fn6: Func<F, G>): G;
-/** @see {@link pipe} */
-declare function pipe<A, B, C, D, E, F, G, H>(value: A, fn1: Func<A, B>, fn2: Func<B, C>, fn3: Func<C, D>, fn4: Func<D, E>, fn5: Func<E, F>, fn6: Func<F, G>, fn7: Func<G, H>): H;
-/**
- * Performs right-to-left function composition.
- * The output of each function is passed as input to the previous function.
- *
- * @typeParam A - The input type of the composed function
- * @returns A new function that applies all the given functions from right to left
- *
- * @example
- * Basic composition
- * ```typescript
- * const addOne = (x: number) => x + 1;
- * const double = (x: number) => x * 2;
- * const toString = (x: number) => `Result: ${x}`;
- *
- * const transform = compose(toString, double, addOne); // Applies: addOne -> double -> toString
- * console.log(transform(5)); // "Result: 12"
- * ```
- */
-declare function compose<A>(fn1: Func<A, A>): Func<A, A>;
-/** @see {@link compose} */
-declare function compose<A, B>(fn1: Func<A, B>, fn2: Func<B, A>): Func<B, B>;
-/** @see {@link compose} */
-declare function compose<A, B, C>(fn1: Func<B, C>, fn2: Func<A, B>): Func<A, C>;
-/** @see {@link compose} */
-declare function compose<A, B, C, D>(fn1: Func<C, D>, fn2: Func<B, C>, fn3: Func<A, B>): Func<A, D>;
-/** @see {@link compose} */
-declare function compose<A, B, C, D, E>(fn1: Func<D, E>, fn2: Func<C, D>, fn3: Func<B, C>, fn4: Func<A, B>): Func<A, E>;
-/** @see {@link compose} */
-declare function compose<A, B, C, D, E, F>(fn1: Func<E, F>, fn2: Func<D, E>, fn3: Func<C, D>, fn4: Func<B, C>, fn5: Func<A, B>): Func<A, F>;
-/** @see {@link compose} */
-declare function compose<A, B, C, D, E, F, G>(fn1: Func<F, G>, fn2: Func<E, F>, fn3: Func<D, E>, fn4: Func<C, D>, fn5: Func<B, C>, fn6: Func<A, B>): Func<A, G>;
-/** @see {@link compose} */
-declare function compose<A, B, C, D, E, F, G, H>(fn1: Func<G, H>, fn2: Func<F, G>, fn3: Func<E, F>, fn4: Func<D, E>, fn5: Func<C, D>, fn6: Func<B, C>, fn7: Func<A, B>): Func<A, H>;
-export { compose, pipe };