@satoshibits/functional 1.0.2

package/dist/performance.mjs

@@ -0,0 +1,453 @@
+"use strict";
+/**
+ * @module performance
+ * @description Functional utilities for optimizing performance through timing control,
+ * batching, and caching. These utilities help manage expensive operations
+ * and prevent performance issues in applications. All utilities are designed
+ * to be composable and work well with functional programming patterns.
+ *
+ * @example
+ * ```typescript
+ * import { debounce, throttle, batch, cache, Performance } from './performance.mts';
+ *
+ * // debounce user input
+ * const search = debounce((query: string) => {
+ *   performSearch(query);
+ * }, 300);
+ *
+ * // throttle scroll events
+ * const handleScroll = throttle(() => {
+ *   updateScrollPosition();
+ * }, 100);
+ *
+ * // batch API calls
+ * const saveItem = batch<Item>(async (items) => {
+ *   await api.saveMany(items);
+ * }, { maxSize: 100, maxWait: 1000 });
+ *
+ * // cache expensive computations
+ * const fibonacci = cache((n: number): number => {
+ *   if (n <= 1) return n;
+ *   return fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ * ```
+ *
+ * @category Performance
+ * @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));
+};
+/**
+ * Debounce function execution.
+ * @description Delays invoking the function until after the specified delay has elapsed
+ * since the last time it was invoked. Useful for expensive operations triggered
+ * by user input like search or resize events. Each new call resets the timer.
+ *
+ * @template T - The types of the function arguments
+ * @param {function(...T): void} fn - The function to debounce
+ * @param {number} delay - The delay in milliseconds
+ * @returns {function(...T): void} The debounced function
+ *
+ * @category Timing
+ * @example
+ * // Basic debounce
+ * const saveChanges = debounce((text: string) => {
+ *   console.log('Saving:', text);
+ * }, 1000);
+ *
+ * saveChanges('H');
+ * saveChanges('He');
+ * saveChanges('Hello'); // Only this will execute after 1 second
+ *
+ * @example
+ * // Search input debouncing
+ * const searchInput = document.getElementById('search');
+ * const performSearch = debounce((query: string) => {
+ *   fetch(`/api/search?q=${query}`)
+ *     .then(res => res.json())
+ *     .then(results => displayResults(results));
+ * }, 300);
+ *
+ * searchInput.addEventListener('input', (e) => {
+ *   performSearch(e.target.value);
+ * });
+ *
+ * @example
+ * // Window resize handler
+ * const handleResize = debounce(() => {
+ *   const width = window.innerWidth;
+ *   const height = window.innerHeight;
+ *   console.log(`Resized to ${width}x${height}`);
+ *   recalculateLayout();
+ * }, 250);
+ *
+ * window.addEventListener('resize', handleResize);
+ *
+ * @see throttle - Limit execution rate without delaying
+ * @since 2025-07-03
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export var debounce = function (fn, delay) {
+    var timeoutId;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(function () { return fn.apply(void 0, args); }, delay);
+    };
+};
+/**
+ * Throttle function execution.
+ * @description Ensures the function is called at most once per specified time period.
+ * Unlike debounce, throttle guarantees regular execution for continuous events.
+ * The first call is executed immediately, then subsequent calls are rate-limited.
+ *
+ * @template T - The types of the function arguments
+ * @param {function(...T): void} fn - The function to throttle
+ * @param {number} delay - The minimum delay between calls in milliseconds
+ * @returns {function(...T): void} The throttled function
+ *
+ * @category Timing
+ * @example
+ * // Basic throttle
+ * const logScroll = throttle(() => {
+ *   console.log('Scroll position:', window.scrollY);
+ * }, 100);
+ *
+ * window.addEventListener('scroll', logScroll);
+ * // Logs at most once every 100ms during scrolling
+ *
+ * @example
+ * // API rate limiting
+ * const trackEvent = throttle((event: string, data: any) => {
+ *   fetch('/api/analytics', {
+ *     method: 'POST',
+ *     body: JSON.stringify({ event, data, timestamp: Date.now() })
+ *   });
+ * }, 1000);
+ *
+ * // Won't exceed 1 request per second
+ * button.addEventListener('click', () => trackEvent('button_click', { id: 'submit' }));
+ *
+ * @example
+ * // Game loop or animation
+ * const updateGame = throttle(() => {
+ *   player.updatePosition();
+ *   enemies.forEach(e => e.update());
+ *   renderer.draw();
+ * }, 16); // ~60 FPS
+ *
+ * setInterval(updateGame, 0);
+ *
+ * @see debounce - Delay execution until activity stops
+ * @since 2025-07-03
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export var throttle = function (fn, limit) {
+    var inThrottle = false;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!inThrottle) {
+            inThrottle = true;
+            setTimeout(function () {
+                inThrottle = false;
+            }, limit);
+            return fn.apply(void 0, args);
+        }
+        return undefined;
+    };
+};
+/**
+ * Batch async operations to avoid overwhelming external services.
+ * @description Processes items in chunks with optional delays between batches.
+ * Essential for rate-limited APIs or resource-intensive operations.
+ * Executes operations in parallel within each batch but sequential between batches.
+ *
+ * @template T - The type of items to process
+ * @template R - The type of results
+ * @param {T[]} items - Array of items to process
+ * @param {function(T): Promise<R>} fn - Async function to process each item
+ * @param {number} batchSize - Maximum number of items to process in parallel
+ * @param {number} [delayMs=0] - Delay in milliseconds between batches
+ * @returns {Promise<R[]>} Array of results in the same order as input
+ *
+ * @category Batching
+ * @example
+ * // Basic batch processing
+ * const userIds = Array.from({ length: 100 }, (_, i) => i + 1);
+ * const fetchUser = async (id: number) => {
+ *   const res = await fetch(`/api/users/${id}`);
+ *   return res.json();
+ * };
+ *
+ * const users = await batchAsync(userIds, fetchUser, 10, 100);
+ * // Fetches 10 users at a time with 100ms delay between batches
+ *
+ * @example
+ * // Email sending with rate limits
+ * const recipients = [
+ *   { email: 'user1@example.com', name: 'User 1' },
+ *   { email: 'user2@example.com', name: 'User 2' },
+ *   // ... many more
+ * ];
+ *
+ * const sendEmail = async (recipient: typeof recipients[0]) => {
+ *   return await emailService.send({
+ *     to: recipient.email,
+ *     subject: 'Newsletter',
+ *     body: `Hello ${recipient.name}!`
+ *   });
+ * };
+ *
+ * // Send 20 emails per batch with 1 second delay (rate limit compliance)
+ * const results = await batchAsync(recipients, sendEmail, 20, 1000);
+ *
+ * @example
+ * // Image processing
+ * const imageUrls = ['img1.jpg', 'img2.jpg', // ... more images, 'img100.jpg'];
+ *
+ * const processImage = async (url: string) => {
+ *   const img = await loadImage(url);
+ *   const processed = await applyFilters(img);
+ *   return await saveImage(processed);
+ * };
+ *
+ * // Process 5 images at a time to avoid memory issues
+ * const processed = await batchAsync(imageUrls, processImage, 5, 200);
+ * console.log(`Processed ${processed.length} images`);
+ *
+ * @see Promise.all - Process all items concurrently without batching
+ */
+export var batchAsync = function (items_1, fn_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([items_1, fn_1], args_1, true), void 0, function (items, fn, batchSize, delayMs) {
+        var results, i, batch, batchResults;
+        if (batchSize === void 0) { batchSize = 10; }
+        if (delayMs === void 0) { delayMs = 100; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    results = [];
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < items.length)) return [3 /*break*/, 5];
+                    batch = items.slice(i, i + batchSize);
+                    return [4 /*yield*/, Promise.all(batch.map(function (item) { return fn(item); }))];
+                case 2:
+                    batchResults = _a.sent();
+                    results.push.apply(results, batchResults);
+                    if (!(i + batchSize < items.length && delayMs > 0)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, delayMs); })];
+                case 3:
+                    _a.sent();
+                    _a.label = 4;
+                case 4:
+                    i += batchSize;
+                    return [3 /*break*/, 1];
+                case 5: return [2 /*return*/, results];
+            }
+        });
+    });
+};
+/**
+ * Advanced timing utilities for specialized use cases.
+ *
+ * @category Advanced
+ */
+export var timingUtils = {
+    /**
+     * Debounce with immediate option.
+     * Optionally invokes the function immediately on the leading edge.
+     *
+     * @example
+     * // Execute immediately on first call, then debounce
+     * const saveWithFeedback = timingUtils.debounceWithImmediate(
+     *   (data: string) => {
+     *     showSaveIndicator();
+     *     saveToServer(data);
+     *   },
+     *   1000,
+     *   true // immediate
+     * );
+     *
+     * // First call executes immediately, subsequent calls are debounced
+     * saveWithFeedback('data1'); // Executes immediately
+     * saveWithFeedback('data2'); // Debounced
+     * saveWithFeedback('data3'); // Debounced, only this executes after 1s
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debounceWithImmediate: function (fn, delay, immediate) {
+        if (immediate === void 0) { immediate = false; }
+        var timeoutId = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var callNow = immediate && !timeoutId;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            timeoutId = setTimeout(function () {
+                timeoutId = null;
+                if (!immediate) {
+                    fn.apply(void 0, args);
+                }
+            }, delay);
+            if (callNow) {
+                fn.apply(void 0, args);
+            }
+        };
+    },
+    /**
+     * Throttle with trailing call option.
+     * Ensures the last call is always executed.
+     *
+     * @example
+     * // Progress updates with final state guarantee
+     * const updateProgress = timingUtils.throttleWithTrailing(
+     *   (percent: number) => {
+     *     progressBar.style.width = `${percent}%`;
+     *     if (percent === 100) {
+     *       showCompletionMessage();
+     *     }
+     *   },
+     *   100,
+     *   true // trailing
+     * );
+     *
+     * // Updates at most every 100ms, but guarantees the final 100% is shown
+     * for (let i = 0; i <= 100; i++) {
+     *   updateProgress(i);
+     * }
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    throttleWithTrailing: function (fn, limit, trailing) {
+        if (trailing === void 0) { trailing = true; }
+        var lastArgs = null;
+        var lastCallTime = 0;
+        var timeoutId = null;
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var now = Date.now();
+            var timeSinceLastCall = now - lastCallTime;
+            if (timeSinceLastCall >= limit) {
+                fn.apply(void 0, args);
+                lastCallTime = now;
+                lastArgs = null;
+            }
+            else {
+                lastArgs = args;
+                if (trailing && !timeoutId) {
+                    var remainingTime = limit - timeSinceLastCall;
+                    timeoutId = setTimeout(function () {
+                        if (lastArgs) {
+                            fn.apply(void 0, lastArgs);
+                            lastCallTime = Date.now();
+                            lastArgs = null;
+                        }
+                        timeoutId = null;
+                    }, remainingTime);
+                }
+            }
+        };
+    },
+    /**
+     * Create a function that measures its execution time.
+     *
+     * @example
+     * const timedFetch = timingUtils.measureTime(
+     *   async (url: string) => {
+     *     const response = await fetch(url);
+     *     return response.json();
+     *   },
+     *   (duration, result) => {
+     *     console.log(`Fetch took ${duration}ms`);
+     *     analytics.track('api_call_duration', { duration, url: result.url });
+     *   }
+     * );
+     *
+     * const data = await timedFetch('/api/data');
+     */
+    measureTime: function (fn, onComplete) {
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var start = performance.now();
+            var result = fn.apply(void 0, args);
+            if (onComplete) {
+                if (result instanceof Promise) {
+                    // Handle async functions
+                    var promiseWithTiming = result.then(function (value) {
+                        var totalDuration = performance.now() - start;
+                        onComplete(totalDuration, value);
+                        return value;
+                    });
+                    return promiseWithTiming;
+                }
+                // Handle sync functions
+                var duration = performance.now() - start;
+                onComplete(duration, result);
+            }
+            return result;
+        };
+    },
+};
+//# sourceMappingURL=performance.mjs.map

package/dist/performance.mjs.map

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