@pithos/core 2.3.0 → 2.5.0

package/dist/eidos/state/state.js

@@ -0,0 +1,85 @@
+/**
+ * Functional State Pattern.
+ *
+ * In OOP, the State pattern requires a Context class, a State interface,
+ * and concrete State subclasses that the Context delegates to.
+ * In functional TypeScript, a state machine is a record of transitions
+ * keyed by state, where each transition maps an event to the next state
+ * (and optionally updates context).
+ *
+ * @module eidos/state
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { createMachine } from "@pithos/core/eidos/state/state";
+ *
+ * const light = createMachine({
+ *   green:  { timer: { to: "yellow" } },
+ *   yellow: { timer: { to: "red" } },
+ *   red:    { timer: { to: "green" } },
+ * }, "green");
+ *
+ * light.current();      // "green"
+ * light.send("timer");  // "yellow"
+ * light.send("timer");  // "red"
+ * ```
+ */
+import { some, none } from "../../zygos/option.js";
+/**
+ * Type guard for context transitions.
+ */
+function hasUpdate(t) {
+    return "update" in t;
+}
+export function createMachine(definition, initial, initialContext) {
+    let state = initial;
+    let ctx = initialContext;
+    const listeners = new Set();
+    const send = (event) => {
+        const transitions = definition[state];
+        const transition = transitions[event];
+        if (transition === undefined)
+            return state;
+        const from = state;
+        state = transition.to;
+        // Stryker disable next-line ConditionalExpression: ctx check is defensive - TypeScript prevents update on machines without context
+        if (hasUpdate(transition) && ctx !== undefined) {
+            ctx = transition.update(ctx);
+        }
+        for (const listener of listeners) {
+            listener(from, event, state);
+        }
+        return state;
+    };
+    const trySend = (event) => {
+        const transitions = definition[state];
+        if (transitions[event] === undefined)
+            return none;
+        return some(send(event));
+    };
+    const onTransition = (listener) => {
+        listeners.add(listener);
+        return () => { listeners.delete(listener); };
+    };
+    const base = {
+        current: () => state,
+        send,
+        matches: (s) => state === s,
+        trySend,
+        onTransition,
+        reset: () => {
+            state = initial;
+            ctx = initialContext;
+        },
+    };
+    if (initialContext !== undefined) {
+        return {
+            ...base,
+            // INTENTIONAL: ctx is guaranteed to be C when initialContext is provided
+            context: () => ctx,
+        };
+    }
+    return base;
+}
+//# sourceMappingURL=state.js.map

package/dist/eidos/state/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../src/eidos/state/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAyE3C;;GAEG;AACH,SAAS,SAAS,CAChB,CAAmB;IAEnB,OAAO,QAAQ,IAAI,CAAC,CAAC;AACvB,CAAC;AA4ED,MAAM,UAAU,aAAa,CAC3B,UAAsC,EACtC,OAAU,EACV,cAAkB;IAElB,IAAI,KAAK,GAAM,OAAO,CAAC;IACvB,IAAI,GAAG,GAAkB,cAAc,CAAC;IACxC,MAAM,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;IAEtD,MAAM,IAAI,GAAG,CAAC,KAAQ,EAAK,EAAE;QAC3B,MAAM,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,UAAU,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QAE3C,MAAM,IAAI,GAAG,KAAK,CAAC;QACnB,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC;QAEtB,mIAAmI;QACnI,IAAI,SAAS,CAAC,UAAU,CAAC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YAC/C,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/B,CAAC;QAED,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,CAAC,KAAQ,EAAa,EAAE;QACtC,MAAM,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QAClD,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3B,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,CAAC,QAAkC,EAAgB,EAAE;QACxE,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,OAAO,GAAG,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG;QACX,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK;QACpB,IAAI;QACJ,OAAO,EAAE,CAAC,CAAI,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC;QAC9B,OAAO;QACP,YAAY;QACZ,KAAK,EAAE,GAAG,EAAE;YACV,KAAK,GAAG,OAAO,CAAC;YAChB,GAAG,GAAG,cAAc,CAAC;QACvB,CAAC;KACF,CAAC;IAEF,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,OAAO;YACL,GAAG,IAAI;YACP,yEAAyE;YACzE,OAAO,EAAE,GAAG,EAAE,CAAC,GAAQ;SACxB,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/eidos/strategy/strategy.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Functional Strategy Pattern.
+ *
+ * In OOP, the Strategy pattern requires an interface, concrete classes, and a
+ * context class to swap algorithms at runtime. In functional TypeScript, a
+ * strategy is simply a function - the pattern becomes composition.
+ *
+ * @module eidos/strategy
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * import { type Strategy, createStrategies, safeStrategy } from "@pithos/core/eidos/strategy";
+ *
+ * const sorting = createStrategies({
+ *   asc: (data: number[]) => [...data].sort((a, b) => a - b),
+ *   desc: (data: number[]) => [...data].sort((a, b) => b - a),
+ * });
+ *
+ * sorting.execute("asc", [3, 1, 2]);  // [1, 2, 3]
+ * sorting.use("desc")([3, 1, 2]);     // [3, 2, 1]
+ * ```
+ */
+import type { Result } from "../../zygos/result/result.js";
+import type { Option } from "../../zygos/option.js";
+import type { GenericSchema, Infer } from "../../kanon/types/base.js";
+/**
+ * A Strategy is a function that transforms an input into an output.
+ * This replaces the GoF Strategy interface + concrete classes.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @since 2.4.0
+ */
+export type Strategy<In, Out> = (input: In) => Out;
+/**
+ * Creates a strategy resolver from a record of named strategies.
+ * Replaces the GoF Context class - instead of `setStrategy()` + `execute()`,
+ * you simply pick a function by key and call it.
+ *
+ * @template K - Union of strategy keys
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategies - Record mapping keys to strategy functions
+ * @returns Resolver with `use` (get fn) and `execute` (run by key)
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const pricing = createStrategies({
+ *   regular: (price: number) => price,
+ *   vip: (price: number) => price * 0.8,
+ *   premium: (price: number) => price * 0.7,
+ * });
+ *
+ * const applyVip = pricing.use("vip");
+ * applyVip(100); // 80
+ *
+ * pricing.execute("premium", 100); // 70
+ *
+ * // Safe lookup for dynamic keys (e.g. from config)
+ * const key: string = getFromConfig();
+ * pricing.get(key); // Option<Strategy<number, number>>
+ * ```
+ */
+export declare function createStrategies<K extends string, In, Out>(strategies: Record<K, Strategy<In, Out>>): {
+    /** Get a strategy by key. Typed keys only. */
+    use: (key: K) => Strategy<In, Out>;
+    /** Execute a strategy by key with the given input. */
+    execute: (key: K, input: In) => Out;
+    /** Safe lookup for dynamic/runtime keys. Returns `Option<Strategy>`. */
+    get: (key: string) => Option<Strategy<In, Out>>;
+};
+/**
+ * Wraps a strategy to return a zygos `Result` instead of throwing.
+ * Catches any exception and wraps it in `Err<Error>`.
+ *
+ * @deprecated Use `Result.fromThrowable` from `@zygos/result/result` instead.
+ *
+ * ```ts
+ * import { Result } from "../../zygos/result/result.js";
+ *
+ * const safeParseJson = Result.fromThrowable(
+ *   (input: string) => JSON.parse(input),
+ *   (e) => e instanceof Error ? e : new Error(String(e)),
+ * );
+ * safeParseJson('{"ok":true}'); // Ok({ ok: true })
+ * safeParseJson("invalid");     // Err(SyntaxError(...))
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Full explanation, examples and live demo}
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategy - The strategy to make safe
+ * @returns A new strategy returning `Result<Out, Error>`
+ * @since 2.4.0
+ */
+export declare function safeStrategy<In, Out>(strategy: Strategy<In, Out>): Strategy<In, Result<Out, Error>>;
+/**
+ * Composes a primary strategy with a fallback.
+ * If the primary throws, the fallback is executed instead.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @param primary - The strategy to try first
+ * @param fallback - The strategy to use if primary throws
+ * @returns A new combined strategy
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const fromCache: Strategy<string, Data> = (key) => cache.get(key);
+ * const fromApi: Strategy<string, Data> = (key) => api.fetch(key);
+ *
+ * const fetchData = withFallback(fromCache, fromApi);
+ * fetchData("user:123"); // tries cache, falls back to API
+ * ```
+ */
+export declare function withFallback<In, Out>(primary: Strategy<In, Out>, fallback: Strategy<In, Out>): Strategy<In, Out>;
+/**
+ * Validates input against a kanon schema before executing the strategy.
+ * Bridges kanon validation, zygos Result, and the strategy pattern.
+ *
+ * @template S - The kanon schema type
+ * @template Out - The output type of the strategy
+ * @param schema - Kanon schema to validate input against
+ * @param strategy - Strategy to execute on validated input
+ * @returns A function accepting unknown input and returning `Result<Out, string>`
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { number } from "@pithos/core/kanon";
+ *
+ * const double = withValidation(
+ *   number().min(0),
+ *   (n) => n * 2,
+ * );
+ *
+ * double(5);       // Ok(10)
+ * double(-1);      // Err("Number must be >= 0")
+ * double("hello"); // Err("Expected number")
+ * ```
+ */
+export declare function withValidation<S extends GenericSchema, Out>(schema: S, strategy: Strategy<Infer<S>, Out>): (input: unknown) => Result<Out, string>;
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/eidos/strategy/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,GAAG,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,GAAG,EACxD,UAAU,EAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IAGtC,8CAA8C;eACnC,CAAC,KAAG,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC;IAChC,sDAAsD;mBACvC,CAAC,SAAS,EAAE,KAAG,GAAG;IACjC,wEAAwE;eAC7D,MAAM,KAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;EAQhD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,GAAG,EAClC,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,GAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAQlC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,GAAG,EAClC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,EAC1B,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,GAC1B,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAQnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,aAAa,EAAE,GAAG,EACzD,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,GAChC,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAEzC"}

package/dist/eidos/strategy/strategy.js

@@ -0,0 +1,167 @@
+/**
+ * Functional Strategy Pattern.
+ *
+ * In OOP, the Strategy pattern requires an interface, concrete classes, and a
+ * context class to swap algorithms at runtime. In functional TypeScript, a
+ * strategy is simply a function - the pattern becomes composition.
+ *
+ * @module eidos/strategy
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * import { type Strategy, createStrategies, safeStrategy } from "@pithos/core/eidos/strategy";
+ *
+ * const sorting = createStrategies({
+ *   asc: (data: number[]) => [...data].sort((a, b) => a - b),
+ *   desc: (data: number[]) => [...data].sort((a, b) => b - a),
+ * });
+ *
+ * sorting.execute("asc", [3, 1, 2]);  // [1, 2, 3]
+ * sorting.use("desc")([3, 1, 2]);     // [3, 2, 1]
+ * ```
+ */
+import { ok, err } from "../../zygos/result/result.js";
+import { some, none } from "../../zygos/option.js";
+import { ensure } from "../../bridges/ensure.js";
+/**
+ * Creates a strategy resolver from a record of named strategies.
+ * Replaces the GoF Context class - instead of `setStrategy()` + `execute()`,
+ * you simply pick a function by key and call it.
+ *
+ * @template K - Union of strategy keys
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategies - Record mapping keys to strategy functions
+ * @returns Resolver with `use` (get fn) and `execute` (run by key)
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const pricing = createStrategies({
+ *   regular: (price: number) => price,
+ *   vip: (price: number) => price * 0.8,
+ *   premium: (price: number) => price * 0.7,
+ * });
+ *
+ * const applyVip = pricing.use("vip");
+ * applyVip(100); // 80
+ *
+ * pricing.execute("premium", 100); // 70
+ *
+ * // Safe lookup for dynamic keys (e.g. from config)
+ * const key: string = getFromConfig();
+ * pricing.get(key); // Option<Strategy<number, number>>
+ * ```
+ */
+export function createStrategies(strategies) {
+    return {
+        /** Get a strategy by key. Typed keys only. */
+        use: (key) => strategies[key],
+        /** Execute a strategy by key with the given input. */
+        execute: (key, input) => strategies[key](input),
+        /** Safe lookup for dynamic/runtime keys. Returns `Option<Strategy>`. */
+        get: (key) => {
+            if (key in strategies) {
+                // INTENTIONAL: key validated by `in` check, TS can't narrow string to K
+                return some(strategies[key]);
+            }
+            return none;
+        },
+    };
+}
+/**
+ * Wraps a strategy to return a zygos `Result` instead of throwing.
+ * Catches any exception and wraps it in `Err<Error>`.
+ *
+ * @deprecated Use `Result.fromThrowable` from `@zygos/result/result` instead.
+ *
+ * ```ts
+ * import { Result } from "../../zygos/result/result.js";
+ *
+ * const safeParseJson = Result.fromThrowable(
+ *   (input: string) => JSON.parse(input),
+ *   (e) => e instanceof Error ? e : new Error(String(e)),
+ * );
+ * safeParseJson('{"ok":true}'); // Ok({ ok: true })
+ * safeParseJson("invalid");     // Err(SyntaxError(...))
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Full explanation, examples and live demo}
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategy - The strategy to make safe
+ * @returns A new strategy returning `Result<Out, Error>`
+ * @since 2.4.0
+ */
+export function safeStrategy(strategy) {
+    return (input) => {
+        try {
+            return ok(strategy(input));
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+}
+/**
+ * Composes a primary strategy with a fallback.
+ * If the primary throws, the fallback is executed instead.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @param primary - The strategy to try first
+ * @param fallback - The strategy to use if primary throws
+ * @returns A new combined strategy
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const fromCache: Strategy<string, Data> = (key) => cache.get(key);
+ * const fromApi: Strategy<string, Data> = (key) => api.fetch(key);
+ *
+ * const fetchData = withFallback(fromCache, fromApi);
+ * fetchData("user:123"); // tries cache, falls back to API
+ * ```
+ */
+export function withFallback(primary, fallback) {
+    return (input) => {
+        try {
+            return primary(input);
+        }
+        catch {
+            return fallback(input);
+        }
+    };
+}
+/**
+ * Validates input against a kanon schema before executing the strategy.
+ * Bridges kanon validation, zygos Result, and the strategy pattern.
+ *
+ * @template S - The kanon schema type
+ * @template Out - The output type of the strategy
+ * @param schema - Kanon schema to validate input against
+ * @param strategy - Strategy to execute on validated input
+ * @returns A function accepting unknown input and returning `Result<Out, string>`
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { number } from "@pithos/core/kanon";
+ *
+ * const double = withValidation(
+ *   number().min(0),
+ *   (n) => n * 2,
+ * );
+ *
+ * double(5);       // Ok(10)
+ * double(-1);      // Err("Number must be >= 0")
+ * double("hello"); // Err("Expected number")
+ * ```
+ */
+export function withValidation(schema, strategy) {
+    return (input) => ensure(schema, input).map(strategy);
+}
+//# sourceMappingURL=strategy.js.map

package/dist/eidos/strategy/strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.js","sourceRoot":"","sources":["../../../src/eidos/strategy/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAezC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAwC;IAExC,OAAO;QACL,8CAA8C;QAC9C,GAAG,EAAE,CAAC,GAAM,EAAqB,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QACnD,sDAAsD;QACtD,OAAO,EAAE,CAAC,GAAM,EAAE,KAAS,EAAO,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QAC3D,wEAAwE;QACxE,GAAG,EAAE,CAAC,GAAW,EAA6B,EAAE;YAC9C,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;gBACtB,wEAAwE;gBACxE,OAAO,IAAI,CAAC,UAAU,CAAC,GAAQ,CAAC,CAAC,CAAC;YACpC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,YAAY,CAC1B,QAA2B;IAE3B,OAAO,CAAC,KAAS,EAAE,EAAE;QACnB,IAAI,CAAC;YACH,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA0B,EAC1B,QAA2B;IAE3B,OAAO,CAAC,KAAS,EAAO,EAAE;QACxB,IAAI,CAAC;YACH,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAS,EACT,QAAiC;IAEjC,OAAO,CAAC,KAAc,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACjE,CAAC"}

package/dist/eidos/template/template.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Functional Template Method Pattern.
+ *
+ * In OOP, the Template Method pattern requires an abstract class that defines
+ * the algorithm skeleton with abstract/hook methods, and concrete subclasses
+ * that override specific steps.
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * The base pattern is absorbed by the language — no wrapper needed.
+ *
+ * However, {@link templateWithDefaults} provides real value: it handles
+ * merging default step implementations with caller overrides.
+ *
+ * @module eidos/template
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed for basic templates — just write a function:
+ * const processData = (steps: { parse: (raw: string) => number[]; analyze: (data: number[]) => string }) =>
+ *   (raw: string) => steps.analyze(steps.parse(raw));
+ *
+ * const csvProcessor = processData({
+ *   parse: (raw) => raw.split(",").map(Number),
+ *   analyze: (data) => `sum: ${data.reduce((a, b) => a + b, 0)}`,
+ * });
+ *
+ * // For templates with defaults, use templateWithDefaults:
+ * import { templateWithDefaults } from "@pithos/core/eidos/template/template";
+ *
+ * const report = templateWithDefaults(
+ *   (steps: { header: () => string; body: (d: string) => string }) =>
+ *     (data: string) => `${steps.header()}\n${steps.body(data)}`,
+ *   { header: () => "=== Report ===", body: (d) => d },
+ * );
+ *
+ * report({ header: () => "Custom" })("content");
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your template directly:
+ * ```ts
+ * const gameAI = (steps: { collect: () => number; attack: (n: number) => string }) =>
+ *   () => steps.attack(steps.collect());
+ * ```
+ *
+ * For templates with default steps, use {@link templateWithDefaults} which
+ * provides actual value (merging defaults with overrides).
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Full explanation, examples and live demo}
+ */
+export declare function template<Steps extends Record<string, (...args: any[]) => unknown>, Fn>(skeleton: (steps: Steps) => Fn): (steps: Steps) => Fn;
+/**
+ * Creates a template method with default steps that can be partially overridden.
+ *
+ * This is the functional equivalent of an abstract class with hook methods
+ * that have default implementations. Only the steps you want to customize
+ * need to be provided.
+ *
+ * @template Steps - The record type describing the customizable steps
+ * @template Fn - The resulting algorithm function type
+ * @param skeleton - A function that wires the steps into an algorithm
+ * @param defaults - Default implementations for all steps
+ * @returns A function that accepts partial step overrides and returns the algorithm
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const report = templateWithDefaults(
+ *   (steps: {
+ *     header: () => string;
+ *     body: (data: string) => string;
+ *     footer: () => string;
+ *   }) =>
+ *     (data: string) => [steps.header(), steps.body(data), steps.footer()].join("\n"),
+ *   {
+ *     header: () => "=== Report ===",
+ *     body: (data) => data,
+ *     footer: () => "=== End ===",
+ *   },
+ * );
+ *
+ * // Only override what you need
+ * const custom = report({ header: () => "** Custom **" });
+ * custom("content"); // "** Custom **\ncontent\n=== End ==="
+ * ```
+ */
+export declare function templateWithDefaults<Steps extends object, Fn>(skeleton: (steps: Steps) => Fn, defaults: NoInfer<Steps>): (overrides?: Partial<NoInfer<Steps>>) => Fn;
+//# sourceMappingURL=template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/eidos/template/template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,QAAQ,CAGtB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,EACzD,EAAE,EAEF,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,GAC7B,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,CAEtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,EAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,EAC9B,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,GACvB,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAY7C"}

package/dist/eidos/template/template.js

@@ -0,0 +1,110 @@
+/**
+ * Functional Template Method Pattern.
+ *
+ * In OOP, the Template Method pattern requires an abstract class that defines
+ * the algorithm skeleton with abstract/hook methods, and concrete subclasses
+ * that override specific steps.
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * The base pattern is absorbed by the language — no wrapper needed.
+ *
+ * However, {@link templateWithDefaults} provides real value: it handles
+ * merging default step implementations with caller overrides.
+ *
+ * @module eidos/template
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed for basic templates — just write a function:
+ * const processData = (steps: { parse: (raw: string) => number[]; analyze: (data: number[]) => string }) =>
+ *   (raw: string) => steps.analyze(steps.parse(raw));
+ *
+ * const csvProcessor = processData({
+ *   parse: (raw) => raw.split(",").map(Number),
+ *   analyze: (data) => `sum: ${data.reduce((a, b) => a + b, 0)}`,
+ * });
+ *
+ * // For templates with defaults, use templateWithDefaults:
+ * import { templateWithDefaults } from "@pithos/core/eidos/template/template";
+ *
+ * const report = templateWithDefaults(
+ *   (steps: { header: () => string; body: (d: string) => string }) =>
+ *     (data: string) => `${steps.header()}\n${steps.body(data)}`,
+ *   { header: () => "=== Report ===", body: (d) => d },
+ * );
+ *
+ * report({ header: () => "Custom" })("content");
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your template directly:
+ * ```ts
+ * const gameAI = (steps: { collect: () => number; attack: (n: number) => string }) =>
+ *   () => steps.attack(steps.collect());
+ * ```
+ *
+ * For templates with default steps, use {@link templateWithDefaults} which
+ * provides actual value (merging defaults with overrides).
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Full explanation, examples and live demo}
+ */
+export function template(skeleton) {
+    return skeleton;
+}
+/**
+ * Creates a template method with default steps that can be partially overridden.
+ *
+ * This is the functional equivalent of an abstract class with hook methods
+ * that have default implementations. Only the steps you want to customize
+ * need to be provided.
+ *
+ * @template Steps - The record type describing the customizable steps
+ * @template Fn - The resulting algorithm function type
+ * @param skeleton - A function that wires the steps into an algorithm
+ * @param defaults - Default implementations for all steps
+ * @returns A function that accepts partial step overrides and returns the algorithm
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const report = templateWithDefaults(
+ *   (steps: {
+ *     header: () => string;
+ *     body: (data: string) => string;
+ *     footer: () => string;
+ *   }) =>
+ *     (data: string) => [steps.header(), steps.body(data), steps.footer()].join("\n"),
+ *   {
+ *     header: () => "=== Report ===",
+ *     body: (data) => data,
+ *     footer: () => "=== End ===",
+ *   },
+ * );
+ *
+ * // Only override what you need
+ * const custom = report({ header: () => "** Custom **" });
+ * custom("content"); // "** Custom **\ncontent\n=== End ==="
+ * ```
+ */
+export function templateWithDefaults(skeleton, defaults) {
+    return (overrides) => {
+        // Stryker disable next-line ConditionalExpression: Stryker can't find related tests due to vitest.related config
+        if (!overrides)
+            return skeleton(defaults);
+        const merged = { ...defaults };
+        for (const key of Object.keys(overrides)) {
+            if (overrides[key] !== undefined) {
+                merged[key] = overrides[key];
+            }
+        }
+        return skeleton(merged);
+    };
+}
+//# sourceMappingURL=template.js.map

package/dist/eidos/template/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/eidos/template/template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,UAAU,QAAQ,CAMtB,QAA8B;IAE9B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAA8B,EAC9B,QAAwB;IAExB,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,iHAAiH;QACjH,IAAI,CAAC,SAAS;YAAE,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC/B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAoB,EAAE,CAAC;YAC5D,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;gBACjC,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAuB,CAAC;YACrD,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC"}