@satoshibits/functional 1.0.2

package/dist/composition.mjs

@@ -0,0 +1,516 @@
+"use strict";
+/**
+ * @module composition
+ * @description Core functional composition utilities using TypeScript 4.0+ variadic tuple types.
+ * Provides type-safe function composition with automatic type inference
+ * for pipelines of any length. All functions follow functional programming principles,
+ * supporting both synchronous and asynchronous composition patterns.
+ *
+ * @example
+ * ```typescript
+ * import { pipe, flow, compose, tap, pipeAsync } from './composition.mts';
+ *
+ * // pipe - execute functions with an initial value
+ * const result = pipe(
+ *   5,
+ *   x => x * 2,
+ *   x => x + 1,
+ *   x => `Result: ${x}`
+ * );
+ * // => "Result: 11"
+ *
+ * // flow - create reusable pipelines
+ * const processUser = flow(
+ *   (user: User) => ({ ...user, name: user.name.trim() }),
+ *   user => ({ ...user, name: user.name.toUpperCase() }),
+ *   user => ({ ...user, isActive: true })
+ * );
+ *
+ * // compose - right-to-left composition
+ * const calculate = compose(
+ *   Math.round,
+ *   Math.sqrt,
+ *   Math.abs
+ * );
+ *
+ * // async composition
+ * const fetchAndProcess = pipeAsync(
+ *   async (id: string) => fetchUser(id),
+ *   async (user: User) => enrichUser(user),
+ *   async (enriched: EnrichedUser) => saveUser(enriched)
+ * );
+ * ```
+ *
+ * @category Core
+ * @since 2025-07-03
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// General case for more functions (less type safety but still works)
+export function pipe(value) {
+    var fns = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        fns[_i - 1] = arguments[_i];
+    }
+    return fns.reduce(function (acc, fn) { return fn(acc); }, value);
+}
+export function flow() {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    if (fns.length === 0)
+        return identity;
+    if (fns.length === 1)
+        return fns[0];
+    var firstFn = fns[0], restFns = fns.slice(1);
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var firstResult = firstFn.apply(void 0, args);
+        return restFns.reduce(function (acc, fn) { return fn(acc); }, firstResult);
+    };
+}
+/**
+ * Identity function - returns its input unchanged.
+ * @description A function that returns its argument without any modification.
+ * Useful as a default or placeholder in pipelines, for filtering truthy values,
+ * or when conditional transformations are needed.
+ *
+ * @template T - The type of the input and output
+ * @param {T} x - The value to return unchanged
+ * @returns {T} The same value that was passed in
+ *
+ * @category Utilities
+ * @example
+ * // As a default transformation
+ * const transform = shouldTransform ? (x: number) => x * 2 : identity;
+ * [1, 2, 3].map(transform); // => [1, 2, 3] or [2, 4, 6]
+ *
+ * @example
+ * // Filtering out falsy values while preserving types
+ * const values = [1, null, 2, undefined, 3];
+ * const nonNull = values.filter(identity); // => [1, 2, 3]
+ *
+ * @example
+ * // As a placeholder in conditional pipelines
+ * const pipeline = flow(
+ *   validateInput,
+ *   shouldNormalize ? normalizeData : identity,
+ *   saveToDatabase
+ * );
+ *
+ * @see constant - Create a function that always returns the same value
+ * @since 2025-07-03
+ */
+export var identity = function (x) { return x; };
+/**
+ * Constant function - creates a function that always returns the same value.
+ * @description Returns a function that ignores its arguments and always returns the specified value.
+ * Useful for providing default values, mocking in tests, or replacing complex logic with fixed results.
+ *
+ * @template T - The type of the constant value
+ * @param {T} x - The value to always return
+ * @returns {() => T} A function that always returns the constant value
+ *
+ * @category Utilities
+ * @example
+ * // Default value provider
+ * const getDefault = constant({ status: 'pending', count: 0 });
+ * const status = userStatus || getDefault();
+ *
+ * @example
+ * // Mock functions in tests
+ * const mockUserService = {
+ *   getCurrentUser: constant({ id: 1, name: 'Test User' }),
+ *   isAuthenticated: constant(true)
+ * };
+ *
+ * @example
+ * // Replacing conditional logic
+ * const getDiscount = isPremium
+ *   ? calculatePremiumDiscount
+ *   : constant(0);
+ *
+ * @see identity - Return the input unchanged
+ * @since 2025-07-03
+ */
+export var constant = function (x) { return function () { return x; }; };
+export function compose() {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    // Create a reversed copy to avoid mutation
+    var reversedFns = __spreadArray([], fns, true).reverse();
+    return flow.apply(void 0, reversedFns);
+}
+/**
+ * Tap - execute a side effect without changing the value.
+ * @description Executes a function for its side effects while passing the input value through unchanged.
+ * Useful for debugging, logging, or triggering external actions in pipelines without breaking the flow.
+ * The side effect function receives the value but its return value is ignored.
+ *
+ * @template T - The type of the value being passed through
+ * @param {function(T): void} fn - Function to execute for side effects
+ * @returns {function(T): T} A function that executes the side effect and returns the input
+ *
+ * @category Side Effects
+ * @example
+ * // Debugging pipeline steps
+ * const result = pipe(
+ *   { name: 'John', age: 30 },
+ *   tap(console.log),                    // Log initial value
+ *   user => ({ ...user, age: user.age + 1 }),
+ *   tap(user => console.log('After increment:', user)),
+ *   user => ({ ...user, status: 'active' })
+ * );
+ *
+ * @example
+ * // Triggering side effects
+ * const saveUser = pipe(
+ *   validateUser,
+ *   tap(user => analytics.track('user_validated', { id: user.id })),
+ *   normalizeUser,
+ *   tap(user => cache.set(user.id, user)),
+ *   saveToDatabase
+ * );
+ *
+ * @example
+ * // Conditional debugging
+ * const debug = process.env.DEBUG === 'true';
+ * const pipeline = flow(
+ *   parseData,
+ *   debug ? tap(data => console.log('Parsed:', data)) : identity,
+ *   transformData
+ * );
+ *
+ * @see identity - Pass through without side effects
+ * @since 2025-07-03
+ */
+export var tap = function (fn) { return function (x) {
+    fn(x);
+    return x;
+}; };
+/**
+ * Currying utility - converts a function of multiple arguments into a sequence of functions.
+ * Each function takes a single argument and returns another function until all arguments are provided.
+ *
+ * @category Function Transformation
+ * @example
+ * // Basic currying
+ * const add = (a: number, b: number) => a + b;
+ * const curriedAdd = curry(add);
+ * const add5 = curriedAdd(5);
+ * add5(3); // => 8
+ *
+ * @example
+ * // Building reusable functions
+ * const multiply = curry((factor: number, value: number) => value * factor);
+ * const double = multiply(2);
+ * const triple = multiply(3);
+ *
+ * [1, 2, 3].map(double); // => [2, 4, 6]
+ * [1, 2, 3].map(triple); // => [3, 6, 9]
+ *
+ * @example
+ * // Configuration functions
+ * const createLogger = curry((level: string, category: string, message: string) =>
+ *   console.log(`[${level}] ${category}: ${message}`)
+ * );
+ *
+ * const errorLogger = createLogger('ERROR');
+ * const authErrorLogger = errorLogger('AUTH');
+ * authErrorLogger('Invalid credentials'); // => "[ERROR] AUTH: Invalid credentials"
+ *
+ * @see partial - Fix some arguments of a function
+ * @see flip - Reverse argument order
+ */
+export var curry = function (fn) {
+    return function (a) {
+        return function (b) {
+            return fn(a, b);
+        };
+    };
+};
+/**
+ * Partial application - fixes some arguments of a function.
+ * Returns a new function that takes the remaining arguments.
+ *
+ * @category Function Transformation
+ * @example
+ * // Partially apply configuration
+ * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;
+ * const sayHello = partial(greet, 'Hello');
+ * sayHello('World'); // => "Hello, World!"
+ *
+ * @example
+ * // Creating specialized functions
+ * const fetchAPI = (method: string, endpoint: string, body?: unknown) =>
+ *   fetch(endpoint, { method, body: JSON.stringify(body) });
+ *
+ * const postAPI = partial(fetchAPI, 'POST');
+ * const getAPI = partial(fetchAPI, 'GET');
+ *
+ * postAPI('/users', { name: 'John' });
+ * getAPI('/users');
+ *
+ * @example
+ * // Event handler specialization
+ * const logEvent = (category: string, action: string, label: string) =>
+ *   analytics.track({ category, action, label });
+ *
+ * const logUserAction = partial(logEvent, 'USER');
+ * const logButtonClick = partial(logUserAction, 'CLICK');
+ *
+ * logButtonClick('submit-form'); // Logs: { category: 'USER', action: 'CLICK', label: 'submit-form' }
+ *
+ * @see curry - Convert to single-argument functions
+ * @see flip - Reverse argument order
+ */
+export var partial = function (fn) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return function (lastArg) {
+        return fn.apply(void 0, __spreadArray(__spreadArray([], args, false), [lastArg], false));
+    };
+};
+/**
+ * Flip - reverses the order of arguments for a binary function.
+ * Useful when you need to adapt a function to work with different argument orders.
+ *
+ * @category Function Transformation
+ * @example
+ * // Basic flip
+ * const divide = (a: number, b: number) => a / b;
+ * const divideBy = flip(divide);
+ * divideBy(2, 10); // => 5 (10 / 2)
+ *
+ * @example
+ * // Adapting functions for composition
+ * const concat = (a: string, b: string) => a + b;
+ * const prepend = flip(concat);
+ *
+ * const addPrefix = prepend('PREFIX_');
+ * addPrefix('value'); // => "valuePREFIX_"
+ *
+ * @example
+ * // Working with collections
+ * const has = (obj: Record<string, unknown>, key: string) => key in obj;
+ * const hasKey = flip(has);
+ *
+ * const users = [{ name: 'John' }, { name: 'Jane', admin: true }];
+ * users.filter(hasKey('admin')); // => [{ name: 'Jane', admin: true }]
+ *
+ * @see curry - Convert to single-argument functions
+ * @see partial - Fix some arguments
+ */
+export var flip = function (fn) {
+    return function (b, a) {
+        return fn(a, b);
+    };
+};
+/**
+ * Memoization - caches function results based on arguments.
+ * Improves performance for expensive pure functions by storing previously computed results.
+ *
+ * @category Performance
+ * @example
+ * // Memoize expensive calculations
+ * const fibonacci = memoize((n: number): number => {
+ *   if (n <= 1) return n;
+ *   return fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ *
+ * fibonacci(40); // First call: slow
+ * fibonacci(40); // Second call: instant (cached)
+ *
+ * @example
+ * // Custom cache key generation
+ * const processUser = memoize(
+ *   async (userId: string, options: { includeDetails: boolean }) => {
+ *     const user = await fetchUser(userId);
+ *     return options.includeDetails
+ *       ? { ...user, details: await fetchUserDetails(userId) }
+ *       : user;
+ *   },
+ *   (userId, options) => `${userId}-${options.includeDetails}`
+ * );
+ *
+ * @example
+ * // Memoizing API calls
+ * const fetchProductData = memoize(async (productId: string) => {
+ *   const response = await fetch(`/api/products/${productId}`);
+ *   return response.json();
+ * });
+ *
+ * // Multiple components can call this without duplicate requests
+ * await fetchProductData('123'); // Makes API call
+ * await fetchProductData('123'); // Returns cached result
+ *
+ * @see identity - For functions that don't need memoization
+ */
+export var memoize = function (fn, getKey) {
+    var cache = new Map();
+    var keyFn = getKey !== null && getKey !== void 0 ? getKey : (function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return JSON.stringify(args);
+    });
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var key = keyFn.apply(void 0, args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        var result = fn.apply(void 0, args);
+        cache.set(key, result);
+        return result;
+    };
+};
+export function composeAsync() {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    if (fns.length === 0) {
+        return function (x) { return Promise.resolve(x); };
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function (initial) {
+        // Process functions from right to left
+        return fns.reduceRight(function (acc, fn) { return acc.then(function (result) { return fn(result); }); }, Promise.resolve(initial));
+    };
+}
+export function pipeAsync() {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    if (fns.length === 0) {
+        return function (x) { return Promise.resolve(x); };
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function (initial) {
+        // Process functions from left to right
+        return fns.reduce(function (acc, fn) { return acc.then(function (result) { return fn(result); }); }, Promise.resolve(initial));
+    };
+}
+/**
+ * Sequential execution of async functions.
+ * @description Executes an array of async functions in order, waiting for each to complete before starting the next.
+ * Collects and returns all results in an array. Unlike Promise.all, this ensures sequential execution
+ * which is useful when operations depend on each other or when you need to limit concurrency.
+ *
+ * @template T - The type of values returned by the async functions
+ * @param {Array<() => Promise<T>>} fns - Array of async functions to execute
+ * @returns {Promise<T[]>} Promise resolving to array of all results in order
+ *
+ * @category Async
+ * @example
+ * // Execute initialization steps in order
+ * const initSteps = [
+ *   async () => connectDatabase(),
+ *   async () => loadConfiguration(),
+ *   async () => startServer()
+ * ];
+ *
+ * const results = await sequence(initSteps);
+ * // All steps completed in order
+ *
+ * @example
+ * // Data fetching sequence
+ * const fetchOperations = userIds.map(id =>
+ *   async () => fetchUserData(id)
+ * );
+ *
+ * const allUserData = await sequence(fetchOperations);
+ * // Fetches users one by one, not in parallel
+ *
+ * @example
+ * // Cleanup operations
+ * const cleanup = sequence([
+ *   async () => closeConnections(),
+ *   async () => flushCache(),
+ *   async () => logShutdown()
+ * ]);
+ *
+ * process.on('SIGTERM', () => cleanup());
+ *
+ * @see Promise.all - For parallel execution
+ * @see pipeAsync - For composing async functions
+ * @since 2025-07-03
+ */
+export var sequence = function (fns) {
+    return fns.reduce(function (promiseChain, currentFn) { return __awaiter(void 0, void 0, void 0, function () {
+        var chainResults, currentResult;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, promiseChain];
+                case 1:
+                    chainResults = _a.sent();
+                    return [4 /*yield*/, currentFn()];
+                case 2:
+                    currentResult = _a.sent();
+                    return [2 /*return*/, __spreadArray(__spreadArray([], chainResults, true), [currentResult], false)];
+            }
+        });
+    }); }, Promise.resolve([]));
+};
+//# sourceMappingURL=composition.mjs.map

package/dist/composition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.mjs","sourceRoot":"","sources":["../src/composition.mts"],"names":[],"mappings":"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"}