@pithos/core 2.2.2 → 2.4.0

package/dist/autocompletion.d.ts

@@ -10,7 +10,7 @@
  * ❌ const distance = math.geometry.distance; // from autocompletion
  * ✅ import { distance } from 'pithos/math/geometry';
  * 
- * Generated on: 2026-03-08T14:22:02.640Z
+ * Generated on: 2026-03-29T23:24:53.486Z
  * */
 
 /** 
@@ -568,6 +568,111 @@ declare const _autocompletion: {
       ensurePromise: typeof import('./bridges/ensurePromise.js')['ensurePromise'];
     };
   };
+  eidos: {
+        abstract_factory: {
+          createAbstractFactory: typeof import('./eidos/abstract-factory/abstract-factory.js')['createAbstractFactory'];
+        };
+        adapter: {
+          adapt: typeof import('./eidos/adapter/adapter.js')['adapt'];
+          createAdapter: typeof import('./eidos/adapter/adapter.js')['createAdapter'];
+        };
+        bridge: {
+          composeBridges: typeof import('./eidos/bridge/bridge.js')['composeBridges'];
+          createBridge: typeof import('./eidos/bridge/bridge.js')['createBridge'];
+        };
+        builder: {
+          createBuilder: typeof import('./eidos/builder/builder.js')['createBuilder'];
+          createValidatedBuilder: typeof import('./eidos/builder/builder.js')['createValidatedBuilder'];
+        };
+        chain: {
+          createChain: typeof import('./eidos/chain/chain.js')['createChain'];
+          safeChain: typeof import('./eidos/chain/chain.js')['safeChain'];
+        };
+        command: {
+          createCommandStack: typeof import('./eidos/command/command.js')['createCommandStack'];
+          createReactiveCommandStack: typeof import('./eidos/command/command.js')['createReactiveCommandStack'];
+          safeExecute: typeof import('./eidos/command/command.js')['safeExecute'];
+          undoable: typeof import('./eidos/command/command.js')['undoable'];
+          undoableState: typeof import('./eidos/command/command.js')['undoableState'];
+        };
+        composite: {
+          branch: typeof import('./eidos/composite/composite.js')['branch'];
+          find: typeof import('./eidos/composite/composite.js')['find'];
+          flatten: typeof import('./eidos/composite/composite.js')['flatten'];
+          fold: typeof import('./eidos/composite/composite.js')['fold'];
+          leaf: typeof import('./eidos/composite/composite.js')['leaf'];
+          map: typeof import('./eidos/composite/composite.js')['map'];
+        };
+        decorator: {
+          after: typeof import('./eidos/decorator/decorator.js')['after'];
+          around: typeof import('./eidos/decorator/decorator.js')['around'];
+          before: typeof import('./eidos/decorator/decorator.js')['before'];
+          decorate: typeof import('./eidos/decorator/decorator.js')['decorate'];
+        };
+        facade: {
+          createFacade: typeof import('./eidos/facade/facade.js')['createFacade'];
+        };
+        factory_method: {
+          createFactoryMethod: typeof import('./eidos/factory-method/factory-method.js')['createFactoryMethod'];
+        };
+        flyweight: {
+          memoize: typeof import('./eidos/flyweight/flyweight.js')['memoize'];
+        };
+        interpreter: {
+          interpret: typeof import('./eidos/interpreter/interpreter.js')['interpret'];
+        };
+        iterator: {
+          createIterable: typeof import('./eidos/iterator/iterator.js')['createIterable'];
+          filter: typeof import('./eidos/iterator/iterator.js')['filter'];
+          iterate: typeof import('./eidos/iterator/iterator.js')['iterate'];
+          lazyRange: typeof import('./eidos/iterator/iterator.js')['lazyRange'];
+          map: typeof import('./eidos/iterator/iterator.js')['map'];
+          reduce: typeof import('./eidos/iterator/iterator.js')['reduce'];
+          take: typeof import('./eidos/iterator/iterator.js')['take'];
+          toArray: typeof import('./eidos/iterator/iterator.js')['toArray'];
+        };
+        mediator: {
+          createMediator: typeof import('./eidos/mediator/mediator.js')['createMediator'];
+        };
+        memento: {
+          createHistory: typeof import('./eidos/memento/memento.js')['createHistory'];
+        };
+        observer: {
+          createObservable: typeof import('./eidos/observer/observer.js')['createObservable'];
+        };
+        prototype: {
+          deepClone: typeof import('./eidos/prototype/prototype.js')['deepClone'];
+          deepCloneFull: typeof import('./eidos/prototype/prototype.js')['deepCloneFull'];
+        };
+        proxy: {
+          debounce: typeof import('./eidos/proxy/proxy.js')['debounce'];
+          guarded: typeof import('./eidos/proxy/proxy.js')['guarded'];
+          lazy: typeof import('./eidos/proxy/proxy.js')['lazy'];
+          memoize: typeof import('./eidos/proxy/proxy.js')['memoize'];
+          once: typeof import('./eidos/proxy/proxy.js')['once'];
+          throttle: typeof import('./eidos/proxy/proxy.js')['throttle'];
+        };
+        singleton: {
+          once: typeof import('./eidos/singleton/singleton.js')['once'];
+          singleton: typeof import('./eidos/singleton/singleton.js')['singleton'];
+        };
+        state: {
+          createMachine: typeof import('./eidos/state/state.js')['createMachine'];
+        };
+        strategy: {
+          createStrategies: typeof import('./eidos/strategy/strategy.js')['createStrategies'];
+          safeStrategy: typeof import('./eidos/strategy/strategy.js')['safeStrategy'];
+          withFallback: typeof import('./eidos/strategy/strategy.js')['withFallback'];
+          withValidation: typeof import('./eidos/strategy/strategy.js')['withValidation'];
+        };
+        template: {
+          template: typeof import('./eidos/template/template.js')['template'];
+          templateWithDefaults: typeof import('./eidos/template/template.js')['templateWithDefaults'];
+        };
+        visitor: {
+          visit: typeof import('./eidos/visitor/visitor.js')['visit'];
+        };
+  };
   kanon: {
     index: {
       any: typeof import('./kanon/index.js')['any'];
@@ -1559,6 +1664,20 @@ declare const _autocompletion: {
       map: typeof import('./zygos/task.js')['map'];
       of: typeof import('./zygos/task.js')['of'];
     };
+        index: {
+          err: typeof import('./zygos/result/index.js')['err'];
+          Err: typeof import('./zygos/result/index.js')['Err'];
+          errAsync: typeof import('./zygos/result/index.js')['errAsync'];
+          fromEither: typeof import('./zygos/result/index.js')['fromEither'];
+          fromOption: typeof import('./zygos/result/index.js')['fromOption'];
+          ok: typeof import('./zygos/result/index.js')['ok'];
+          Ok: typeof import('./zygos/result/index.js')['Ok'];
+          okAsync: typeof import('./zygos/result/index.js')['okAsync'];
+          ResultAsync: typeof import('./zygos/result/index.js')['ResultAsync'];
+          safeAsyncTry: typeof import('./zygos/result/index.js')['safeAsyncTry'];
+          safeTry: typeof import('./zygos/result/index.js')['safeTry'];
+          toEither: typeof import('./zygos/result/index.js')['toEither'];
+        };
         result: {
           err: typeof import('./zygos/result/result.js')['err'];
           Err: typeof import('./zygos/result/result.js')['Err'];
@@ -1611,6 +1730,15 @@ export { arkhe };
 declare const bridges: typeof _autocompletion.bridges;
 export { bridges };
 
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'eidos/...' to preserve tree-shaking.
+ * @example
+ * import { createAbstractFactory } from 'pithos/eidos/abstract-factory/abstract-factory';
+ */
+declare const eidos: typeof _autocompletion.eidos;
+export { eidos };
+
 /** 
  * @deprecated ⚠️ For autocompletion only.
  * Use direct imports from 'kanon/...' to preserve tree-shaking.

package/dist/eidos/abstract-factory/abstract-factory.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Functional Abstract Factory Pattern.
+ *
+ * In OOP, the Abstract Factory pattern requires an AbstractFactory interface,
+ * concrete factory classes, abstract product interfaces, and concrete product
+ * classes — a deep hierarchy just to produce families of related objects.
+ * In functional TypeScript, an abstract factory is a function that returns
+ * a record of creator functions. Swapping families is just swapping the factory.
+ *
+ * The core value of the pattern is intra-family consistency: products created
+ * by the same family are guaranteed to be compatible and can collaborate.
+ * A single `create("variant")` call returns a coherent record where every
+ * creator shares the same family context.
+ *
+ * @module eidos/abstract-factory
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { createAbstractFactory } from "@pithos/core/eidos/abstract-factory/abstract-factory";
+ *
+ * // Products collaborate: renderForm uses both button and input from the
+ * // same family, guaranteeing visual consistency.
+ * type UIKit = {
+ *   button: (label: string) => string;
+ *   input: (placeholder: string) => string;
+ *   renderForm: (action: string) => string;
+ * };
+ *
+ * const factory = createAbstractFactory<"light" | "dark", UIKit>({
+ *   light: () => {
+ *     const button = (label: string) => `<button class="light">${label}</button>`;
+ *     const input = (ph: string) => `<input class="light" placeholder="${ph}" />`;
+ *     return {
+ *       button,
+ *       input,
+ *       renderForm: (action) => `${input(action)}${button("Submit")}`,
+ *     };
+ *   },
+ *   dark: () => {
+ *     const button = (label: string) => `<button class="dark">${label}</button>`;
+ *     const input = (ph: string) => `<input class="dark" placeholder="${ph}" />`;
+ *     return {
+ *       button,
+ *       input,
+ *       renderForm: (action) => `${input(action)}${button("Submit")}`,
+ *     };
+ *   },
+ * });
+ *
+ * const ui = factory.create("dark");
+ * ui.renderForm("search");
+ * // `<input class="dark" ...><button class="dark">Submit</button>`
+ * ```
+ */
+import type { Option } from "../../zygos/option.js";
+/**
+ * A Factory is a zero-arg function that produces a product record.
+ * Each key in the record is a creator function for one product of the family.
+ *
+ * @template Products - The record of creator functions
+ * @since 2.4.0
+ */
+export type Factory<Products extends Record<string, (...args: never[]) => unknown>> = () => Products;
+/**
+ * Creates an abstract factory from a record of named family factories.
+ *
+ * Each key is a family name, each value is a factory function that produces
+ * the product record for that family. All families must produce the same
+ * product shape (same keys, same signatures).
+ *
+ * The real power is intra-family collaboration: since `create` returns a
+ * coherent record, products from the same family can reference each other
+ * via closure, guaranteeing compatibility without type gymnastics.
+ *
+ * @template K - Union of family keys
+ * @template Products - The record of creator functions each family produces
+ * @param families - Record mapping family keys to factory functions
+ * @returns An abstract factory with `create`, `get`, and `keys`
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Products that collaborate: encoder uses the separator from its family
+ * type Codec = {
+ *   encode: (parts: string[]) => string;
+ *   decode: (raw: string) => string[];
+ * };
+ *
+ * const codecs = createAbstractFactory<"csv" | "tsv", Codec>({
+ *   csv: () => {
+ *     const sep = ",";
+ *     return {
+ *       encode: (parts) => parts.join(sep),
+ *       decode: (raw) => raw.split(sep),
+ *     };
+ *   },
+ *   tsv: () => {
+ *     const sep = "\t";
+ *     return {
+ *       encode: (parts) => parts.join(sep),
+ *       decode: (raw) => raw.split(sep),
+ *     };
+ *   },
+ * });
+ *
+ * const csv = codecs.create("csv");
+ * csv.decode(csv.encode(["a", "b"])); // ["a", "b"] — round-trip guaranteed
+ * ```
+ */
+export declare function createAbstractFactory<K extends string, Products extends Record<string, (...args: never[]) => unknown>>(families: Record<K, Factory<Products>>): {
+    /**
+     * Create a product family by key. The factory is called each time,
+     * producing a fresh product record.
+     */
+    create: (key: K) => Products;
+    /**
+     * Safe lookup for dynamic/runtime keys.
+     * Returns `Some(factory)` if the key exists, `None` otherwise.
+     */
+    get: (key: string) => Option<Factory<Products>>;
+    /** Returns all registered family keys. */
+    keys: () => K[];
+};
+//# sourceMappingURL=abstract-factory.d.ts.map

package/dist/eidos/abstract-factory/abstract-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-factory.d.ts","sourceRoot":"","sources":["../../../src/eidos/abstract-factory/abstract-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,IAChF,MAAM,QAAQ,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,SAAS,MAAM,EAChB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,EAC9D,QAAQ,EAAE,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEpC;;;OAGG;kBACW,CAAC,KAAG,QAAQ;IAE1B;;;OAGG;eACQ,MAAM,KAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAQ7C,0CAA0C;gBAChC,CAAC,EAAE;EAKhB"}

package/dist/eidos/abstract-factory/abstract-factory.js

@@ -0,0 +1,128 @@
+/**
+ * Functional Abstract Factory Pattern.
+ *
+ * In OOP, the Abstract Factory pattern requires an AbstractFactory interface,
+ * concrete factory classes, abstract product interfaces, and concrete product
+ * classes — a deep hierarchy just to produce families of related objects.
+ * In functional TypeScript, an abstract factory is a function that returns
+ * a record of creator functions. Swapping families is just swapping the factory.
+ *
+ * The core value of the pattern is intra-family consistency: products created
+ * by the same family are guaranteed to be compatible and can collaborate.
+ * A single `create("variant")` call returns a coherent record where every
+ * creator shares the same family context.
+ *
+ * @module eidos/abstract-factory
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { createAbstractFactory } from "@pithos/core/eidos/abstract-factory/abstract-factory";
+ *
+ * // Products collaborate: renderForm uses both button and input from the
+ * // same family, guaranteeing visual consistency.
+ * type UIKit = {
+ *   button: (label: string) => string;
+ *   input: (placeholder: string) => string;
+ *   renderForm: (action: string) => string;
+ * };
+ *
+ * const factory = createAbstractFactory<"light" | "dark", UIKit>({
+ *   light: () => {
+ *     const button = (label: string) => `<button class="light">${label}</button>`;
+ *     const input = (ph: string) => `<input class="light" placeholder="${ph}" />`;
+ *     return {
+ *       button,
+ *       input,
+ *       renderForm: (action) => `${input(action)}${button("Submit")}`,
+ *     };
+ *   },
+ *   dark: () => {
+ *     const button = (label: string) => `<button class="dark">${label}</button>`;
+ *     const input = (ph: string) => `<input class="dark" placeholder="${ph}" />`;
+ *     return {
+ *       button,
+ *       input,
+ *       renderForm: (action) => `${input(action)}${button("Submit")}`,
+ *     };
+ *   },
+ * });
+ *
+ * const ui = factory.create("dark");
+ * ui.renderForm("search");
+ * // `<input class="dark" ...><button class="dark">Submit</button>`
+ * ```
+ */
+import { some, none } from "../../zygos/option.js";
+/**
+ * Creates an abstract factory from a record of named family factories.
+ *
+ * Each key is a family name, each value is a factory function that produces
+ * the product record for that family. All families must produce the same
+ * product shape (same keys, same signatures).
+ *
+ * The real power is intra-family collaboration: since `create` returns a
+ * coherent record, products from the same family can reference each other
+ * via closure, guaranteeing compatibility without type gymnastics.
+ *
+ * @template K - Union of family keys
+ * @template Products - The record of creator functions each family produces
+ * @param families - Record mapping family keys to factory functions
+ * @returns An abstract factory with `create`, `get`, and `keys`
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Products that collaborate: encoder uses the separator from its family
+ * type Codec = {
+ *   encode: (parts: string[]) => string;
+ *   decode: (raw: string) => string[];
+ * };
+ *
+ * const codecs = createAbstractFactory<"csv" | "tsv", Codec>({
+ *   csv: () => {
+ *     const sep = ",";
+ *     return {
+ *       encode: (parts) => parts.join(sep),
+ *       decode: (raw) => raw.split(sep),
+ *     };
+ *   },
+ *   tsv: () => {
+ *     const sep = "\t";
+ *     return {
+ *       encode: (parts) => parts.join(sep),
+ *       decode: (raw) => raw.split(sep),
+ *     };
+ *   },
+ * });
+ *
+ * const csv = codecs.create("csv");
+ * csv.decode(csv.encode(["a", "b"])); // ["a", "b"] — round-trip guaranteed
+ * ```
+ */
+export function createAbstractFactory(families) {
+    return {
+        /**
+         * Create a product family by key. The factory is called each time,
+         * producing a fresh product record.
+         */
+        create: (key) => families[key](),
+        /**
+         * Safe lookup for dynamic/runtime keys.
+         * Returns `Some(factory)` if the key exists, `None` otherwise.
+         */
+        get: (key) => {
+            if (key in families) {
+                // INTENTIONAL: key validated by `in` check, TS can't narrow string to K
+                return some(families[key]);
+            }
+            return none;
+        },
+        /** Returns all registered family keys. */
+        keys: () => {
+            // INTENTIONAL: Object.keys returns string[], but we know they're K
+            return Object.keys(families);
+        },
+    };
+}
+//# sourceMappingURL=abstract-factory.js.map

package/dist/eidos/abstract-factory/abstract-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-factory.js","sourceRoot":"","sources":["../../../src/eidos/abstract-factory/abstract-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAa3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,qBAAqB,CAGnC,QAAsC;IACtC,OAAO;QACL;;;WAGG;QACH,MAAM,EAAE,CAAC,GAAM,EAAY,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;QAE7C;;;WAGG;QACH,GAAG,EAAE,CAAC,GAAW,EAA6B,EAAE;YAC9C,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;gBACpB,wEAAwE;gBACxE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAQ,CAAC,CAAC,CAAC;YAClC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,0CAA0C;QAC1C,IAAI,EAAE,GAAQ,EAAE;YACd,mEAAmE;YACnE,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAQ,CAAC;QACtC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/eidos/adapter/adapter.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Functional Adapter Pattern.
+ *
+ * In OOP, the Adapter pattern requires a Target class, an Adaptee class with
+ * an incompatible interface, and an Adapter class that extends/wraps both.
+ * In functional TypeScript, an adapter is a pair of mapping functions
+ * that transform one function signature into another.
+ *
+ * @module eidos/adapter
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { adapt, createAdapter } from "@pithos/core/eidos/adapter/adapter";
+ *
+ * // Legacy API returns XML string
+ * const legacyFetch = (id: number) => `<user><name>Alice</name></user>`;
+ *
+ * // Adapt to new API shape: string id in, object out
+ * const fetchUser = adapt(
+ *   legacyFetch,
+ *   (id: string) => parseInt(id),       // map input
+ *   (xml) => ({ name: "Alice", xml }),   // map output
+ * );
+ *
+ * fetchUser("42"); // { name: "Alice", xml: "<user>..." }
+ * ```
+ */
+/**
+ * An Adapter transforms a function with one signature into a function
+ * with a different signature. Replaces the GoF Adapter class hierarchy.
+ *
+ * @template FromIn - The source function's input type
+ * @template FromOut - The source function's output type
+ * @template ToIn - The target input type
+ * @template ToOut - The target output type
+ * @since 2.4.0
+ */
+export type Adapter<FromIn, FromOut, ToIn, ToOut> = (source: (input: FromIn) => FromOut) => (input: ToIn) => ToOut;
+/**
+ * Creates a reusable adapter from input/output mappers.
+ * The adapter can then be applied to any source function
+ * with the matching signature.
+ *
+ * @template FromIn - The source function's input type
+ * @template FromOut - The source function's output type
+ * @template ToIn - The target input type
+ * @template ToOut - The target output type
+ * @param mapInput - Transforms target input into source input
+ * @param mapOutput - Transforms source output into target output
+ * @returns A reusable Adapter
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Adapter from Celsius to Fahrenheit API
+ * const celsiusToFahrenheit = createAdapter<number, string, number, string>(
+ *   (fahrenheit) => (fahrenheit - 32) * 5 / 9,  // °F -> °C input
+ *   (label) => label.replace("°C", "°F"),        // output label
+ * );
+ *
+ * const describeCelsius = (temp: number) => `${temp.toFixed(1)}°C`;
+ * const describeFahrenheit = celsiusToFahrenheit(describeCelsius);
+ *
+ * describeFahrenheit(212); // "100.0°F"
+ * ```
+ */
+export declare function createAdapter<FromIn, FromOut, ToIn, ToOut>(mapInput: (input: ToIn) => FromIn, mapOutput: (output: FromOut) => ToOut): Adapter<FromIn, FromOut, ToIn, ToOut>;
+/**
+ * Adapts a source function in one shot by mapping both input and output.
+ *
+ * @template FromIn - The source function's input type
+ * @template FromOut - The source function's output type
+ * @template ToIn - The target input type
+ * @template ToOut - The target output type
+ * @param source - The function to adapt
+ * @param mapInput - Transforms target input into source input
+ * @param mapOutput - Transforms source output into target output
+ * @returns The adapted function
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Adapt a sorting function to work with strings instead of numbers
+ * const sortNumbers = (nums: number[]) => [...nums].sort((a, b) => a - b);
+ *
+ * const sortStrings = adapt(
+ *   sortNumbers,
+ *   (strs: string[]) => strs.map(Number),
+ *   (nums) => nums.map(String),
+ * );
+ *
+ * sortStrings(["3", "1", "2"]); // ["1", "2", "3"]
+ * ```
+ */
+export declare function adapt<FromIn, FromOut, ToIn, ToOut>(source: (input: FromIn) => FromOut, mapInput: (input: ToIn) => FromIn, mapOutput: (output: FromOut) => ToOut): (input: ToIn) => ToOut;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/eidos/adapter/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/eidos/adapter/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,IAAI,CAClD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,KAC/B,CAAC,KAAK,EAAE,IAAI,KAAK,KAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EACxD,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,MAAM,EACjC,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,GACpC,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAEvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAChD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,MAAM,EACjC,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,GACpC,CAAC,KAAK,EAAE,IAAI,KAAK,KAAK,CAExB"}

package/dist/eidos/adapter/adapter.js

@@ -0,0 +1,90 @@
+/**
+ * Functional Adapter Pattern.
+ *
+ * In OOP, the Adapter pattern requires a Target class, an Adaptee class with
+ * an incompatible interface, and an Adapter class that extends/wraps both.
+ * In functional TypeScript, an adapter is a pair of mapping functions
+ * that transform one function signature into another.
+ *
+ * @module eidos/adapter
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { adapt, createAdapter } from "@pithos/core/eidos/adapter/adapter";
+ *
+ * // Legacy API returns XML string
+ * const legacyFetch = (id: number) => `<user><name>Alice</name></user>`;
+ *
+ * // Adapt to new API shape: string id in, object out
+ * const fetchUser = adapt(
+ *   legacyFetch,
+ *   (id: string) => parseInt(id),       // map input
+ *   (xml) => ({ name: "Alice", xml }),   // map output
+ * );
+ *
+ * fetchUser("42"); // { name: "Alice", xml: "<user>..." }
+ * ```
+ */
+/**
+ * Creates a reusable adapter from input/output mappers.
+ * The adapter can then be applied to any source function
+ * with the matching signature.
+ *
+ * @template FromIn - The source function's input type
+ * @template FromOut - The source function's output type
+ * @template ToIn - The target input type
+ * @template ToOut - The target output type
+ * @param mapInput - Transforms target input into source input
+ * @param mapOutput - Transforms source output into target output
+ * @returns A reusable Adapter
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Adapter from Celsius to Fahrenheit API
+ * const celsiusToFahrenheit = createAdapter<number, string, number, string>(
+ *   (fahrenheit) => (fahrenheit - 32) * 5 / 9,  // °F -> °C input
+ *   (label) => label.replace("°C", "°F"),        // output label
+ * );
+ *
+ * const describeCelsius = (temp: number) => `${temp.toFixed(1)}°C`;
+ * const describeFahrenheit = celsiusToFahrenheit(describeCelsius);
+ *
+ * describeFahrenheit(212); // "100.0°F"
+ * ```
+ */
+export function createAdapter(mapInput, mapOutput) {
+    return (source) => (input) => mapOutput(source(mapInput(input)));
+}
+/**
+ * Adapts a source function in one shot by mapping both input and output.
+ *
+ * @template FromIn - The source function's input type
+ * @template FromOut - The source function's output type
+ * @template ToIn - The target input type
+ * @template ToOut - The target output type
+ * @param source - The function to adapt
+ * @param mapInput - Transforms target input into source input
+ * @param mapOutput - Transforms source output into target output
+ * @returns The adapted function
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Adapt a sorting function to work with strings instead of numbers
+ * const sortNumbers = (nums: number[]) => [...nums].sort((a, b) => a - b);
+ *
+ * const sortStrings = adapt(
+ *   sortNumbers,
+ *   (strs: string[]) => strs.map(Number),
+ *   (nums) => nums.map(String),
+ * );
+ *
+ * sortStrings(["3", "1", "2"]); // ["1", "2", "3"]
+ * ```
+ */
+export function adapt(source, mapInput, mapOutput) {
+    return (input) => mapOutput(source(mapInput(input)));
+}
+//# sourceMappingURL=adapter.js.map

package/dist/eidos/adapter/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../src/eidos/adapter/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAgBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAiC,EACjC,SAAqC;IAErC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,KAAK,CACnB,MAAkC,EAClC,QAAiC,EACjC,SAAqC;IAErC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACvD,CAAC"}