♻️ [util] 新增func_lazy

Author: Gaubee

util/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaubee/util",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "exports": {
     "./abort": "./src/abort.ts",
     "./bigint": "./src/bigint.ts",

util/src/func.test.ts

@@ -1,4 +1,4 @@
-import { func_catch, func_remember } from "./func.ts";
+import { func_catch, func_lazy, func_remember } from "./func.ts";
 import assert from "node:assert";
 
 Deno.test("func_remember", async () => {
@@ -34,3 +34,43 @@ Deno.test("func_catch", async () => {
     assert.deepEqual(await fn3(1, "2"), [undefined, `async 1+2`]);
     assert.deepEqual(await fn4(1, "2"), [`async 1+2`, undefined]);
 });
+
+Deno.test("func_lazy", () => {
+    let factoryCallCount = 0;
+
+    const lazyFn = func_lazy(() => {
+        factoryCallCount++;
+        return (x: number) => x * 2;
+    });
+
+    // Factory should not be called until first use
+    assert.equal(factoryCallCount, 0);
+
+    // First call should create the function
+    assert.equal(lazyFn(5), 10);
+    assert.equal(factoryCallCount, 1);
+
+    // Subsequent calls should reuse the same function
+    assert.equal(lazyFn(7), 14);
+    assert.equal(factoryCallCount, 1);
+});
+
+Deno.test("func_lazy with this context", () => {
+    let factoryCallCount = 0;
+
+    const lazyFn = func_lazy(() => {
+        factoryCallCount++;
+        return function (this: { multiplier: number }, x: number) {
+            return x * this.multiplier;
+        };
+    });
+    const obj = { multiplier: 3, fn: lazyFn };
+
+    // Test with this context
+    assert.equal(obj.fn(5), 15);
+    assert.equal(factoryCallCount, 1);
+
+    // Should reuse the same function
+    assert.equal(obj.fn(7), 21);
+    assert.equal(factoryCallCount, 1);
+});

util/src/func.ts

@@ -251,3 +251,15 @@ export const func_catch: FuncCatch = Object.assign(
         wrapError,
     },
 );
+
+export const func_lazy = <T extends Func>(factory: Func.SetReturn<T, T>): T => {
+    let fn: T | undefined;
+    return new Proxy(factory as unknown as T, {
+        apply(_, thisArg, argArray) {
+            if (fn == undefined) {
+                fn = Reflect.apply(factory, thisArg, argArray);
+            }
+            return Reflect.apply(fn!, thisArg, argArray);
+        },
+    });
+};