@adviser/cement 0.5.2 → 0.5.4

package/cjs/resolve-once.test.cjs

@@ -34,12 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const cement_1 = require("@adviser/cement");
-const is_promise_js_1 = require("./is-promise.cjs");
-const promise_sleep_js_1 = require("./promise-sleep.cjs");
-describe("resolve-once", () => {
-    it("sequence", async () => {
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("resolve-once", () => {
+    (0, vitest_1.it)("sequence", async () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((resolve) => {
                 setTimeout(() => {
                     resolve(42);
@@ -48,20 +47,20 @@ describe("resolve-once", () => {
         });
         const start = performance.now();
         const fn = () => once.once(async () => reallyOnce());
-        expect(reallyOnce).toHaveBeenCalledTimes(0);
-        expect(await fn()).toBe(42);
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
-        expect(await fn()).toBe(42);
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
-        expect(await fn()).toBe(42);
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(0);
+        (0, vitest_1.expect)(await fn()).toBe(42);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(await fn()).toBe(42);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(await fn()).toBe(42);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(90);
-        expect(diff).toBeLessThan(150);
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(90);
+        (0, vitest_1.expect)(diff).toBeLessThan(150);
     });
-    it("parallel", async () => {
+    (0, vitest_1.it)("parallel", async () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((resolve) => {
                 setTimeout(() => {
                     resolve(42);
@@ -70,18 +69,18 @@ describe("resolve-once", () => {
         });
         const fn = () => once.once(async () => reallyOnce());
         const start = performance.now();
-        expect(await Promise.all(Array(100)
+        (0, vitest_1.expect)(await Promise.all(Array(100)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(100).fill(42));
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(95);
-        expect(diff).toBeLessThan(150);
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(95);
+        (0, vitest_1.expect)(diff).toBeLessThan(150);
     });
-    it("async works with void", async () => {
+    (0, vitest_1.it)("async works with void", async () => {
         const cnt = 1;
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((resolve) => {
                 setTimeout(() => {
                     resolve();
@@ -92,26 +91,26 @@ describe("resolve-once", () => {
             return reallyOnce();
         });
         const start = performance.now();
-        expect(await Promise.all(Array(cnt)
+        (0, vitest_1.expect)(await Promise.all(Array(cnt)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(cnt).fill(undefined));
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(95);
-        expect(diff).toBeLessThan(150);
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(95);
+        (0, vitest_1.expect)(diff).toBeLessThan(150);
     });
-    it("sync works with void", () => {
+    (0, vitest_1.it)("sync works with void", () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(() => 19);
+        const reallyOnce = vitest_1.vi.fn(() => 19);
         const val = once.once(() => {
             reallyOnce();
         });
-        expect(Array(100).fill(val)).toEqual(Array(100).fill(undefined));
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(Array(100).fill(val)).toEqual(Array(100).fill(undefined));
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
     });
-    it("throws", async () => {
+    (0, vitest_1.it)("throws", async () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((rs, rj) => {
                 setTimeout(() => {
                     rj(new Error("nope"));
@@ -124,11 +123,11 @@ describe("resolve-once", () => {
             for (let i = 0; i < 100; i++) {
                 fn()
                     .then(() => {
-                    assert.fail("should not happen");
+                    vitest_1.assert.fail("should not happen");
                 })
                     .catch((e) => {
-                    expect(e).toEqual(new Error("nope"));
-                    expect(reallyOnce).toHaveBeenCalledTimes(1);
+                    (0, vitest_1.expect)(e).toEqual(new Error("nope"));
+                    (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
                     if (i === 99) {
                         rs(undefined);
                     }
@@ -136,12 +135,12 @@ describe("resolve-once", () => {
             }
         });
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(99);
-        expect(diff).toBeLessThan(250);
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(99);
+        (0, vitest_1.expect)(diff).toBeLessThan(250);
     });
-    it("preserves order", async () => {
+    (0, vitest_1.it)("preserves order", async () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((resolve) => {
                 setTimeout(() => {
                     resolve(42);
@@ -155,19 +154,19 @@ describe("resolve-once", () => {
             return `${o}:${ret}`;
         };
         const start = performance.now();
-        expect(await Promise.all(Array(100)
+        (0, vitest_1.expect)(await Promise.all(Array(100)
             .fill(fn)
             .map((fn) => fn()))).toEqual(Array(100)
             .fill(undefined)
             .map((_, i) => `${i}:42`));
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(95);
-        expect(diff).toBeLessThan(150);
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(95);
+        (0, vitest_1.expect)(diff).toBeLessThan(150);
     });
-    it("preserves call order to resolv order", async () => {
+    (0, vitest_1.it)("preserves call order to resolv order", async () => {
         const once = new cement_1.ResolveOnce();
-        const reallyOnce = vi.fn(async () => {
+        const reallyOnce = vitest_1.vi.fn(async () => {
             return new Promise((resolve) => {
                 setTimeout(() => {
                     resolve(42);
@@ -175,7 +174,7 @@ describe("resolve-once", () => {
             });
         });
         const start = performance.now();
-        const orderFn = vi.fn();
+        const orderFn = vitest_1.vi.fn();
         const fns = Array(100)
             .fill(0)
             .map((_, i) => {
@@ -186,21 +185,21 @@ describe("resolve-once", () => {
                 return `${i}:${once}`;
             });
         });
-        expect(await Promise.all(fns)).toEqual(Array(100)
+        (0, vitest_1.expect)(await Promise.all(fns)).toEqual(Array(100)
             .fill(undefined)
             .map((_, i) => `${i}:42`));
-        expect(reallyOnce).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(reallyOnce).toHaveBeenCalledTimes(1);
         const diff = performance.now() - start;
-        expect(diff).toBeGreaterThanOrEqual(95);
-        expect(diff).toBeLessThan(150);
-        expect(orderFn).toHaveBeenCalledTimes(100);
-        expect(orderFn.mock.calls.map(([i]) => i)).toEqual(Array(100)
+        (0, vitest_1.expect)(diff).toBeGreaterThanOrEqual(95);
+        (0, vitest_1.expect)(diff).toBeLessThan(150);
+        (0, vitest_1.expect)(orderFn).toHaveBeenCalledTimes(100);
+        (0, vitest_1.expect)(orderFn.mock.calls.map(([i]) => i)).toEqual(Array(100)
             .fill(0)
             .map((_, i) => i));
     });
-    it("reset", async () => {
+    (0, vitest_1.it)("reset", async () => {
         const once = new cement_1.ResolveOnce();
-        const orderFn = vi.fn(() => Promise.resolve(42));
+        const orderFn = vitest_1.vi.fn(() => Promise.resolve(42));
         await once.once(orderFn);
         await once.once(orderFn);
         await once.once(orderFn);
@@ -211,105 +210,106 @@ describe("resolve-once", () => {
         await once.once(orderFn);
         await once.once(orderFn);
         void once.reset();
-        expect(orderFn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(orderFn).toHaveBeenCalledTimes(3);
     });
-    it("keyed", async () => {
+    (0, vitest_1.it)("keyed", async () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        const a_orderFn = vi.fn(() => Promise.resolve(42));
-        const b_orderFn = vi.fn(() => Promise.resolve(42));
+        const a_orderFn = vitest_1.vi.fn(() => Promise.resolve(42));
+        const b_orderFn = vitest_1.vi.fn(() => Promise.resolve(42));
         for (let i = 0; i < 5; i++) {
             await keyed.get("a").once(a_orderFn);
             await keyed.get(() => "a").once(a_orderFn);
             await keyed.get("b").once(b_orderFn);
             await keyed.get(() => "b").once(b_orderFn);
-            expect(a_orderFn).toHaveBeenCalledTimes(i + 1);
-            expect(b_orderFn).toHaveBeenCalledTimes(i + 1);
+            (0, vitest_1.expect)(a_orderFn).toHaveBeenCalledTimes(i + 1);
+            (0, vitest_1.expect)(b_orderFn).toHaveBeenCalledTimes(i + 1);
             keyed.reset();
         }
     });
-    it("keyed with pass ctx", async () => {
+    (0, vitest_1.it)("keyed with pass ctx", async () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        const a_orderFn = vi.fn((key) => Promise.resolve(key));
-        const b_orderFn = vi.fn((key) => Promise.resolve(key));
+        const a_orderFn = vitest_1.vi.fn((key) => Promise.resolve(key));
+        const b_orderFn = vitest_1.vi.fn((key) => Promise.resolve(key));
         await Promise.all([
             keyed.get("a").once(a_orderFn),
             keyed.get(() => "a").once(a_orderFn),
             keyed.get("b").once(b_orderFn),
             keyed.get(() => "b").once(b_orderFn),
         ]);
-        expect(a_orderFn).toHaveBeenCalledTimes(1);
-        expect(a_orderFn).toHaveBeenCalledWith({
+        (0, vitest_1.expect)(a_orderFn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(a_orderFn.mock.calls[0][0].ctx).toEqual({
             refKey: "a",
             givenKey: "a",
             value: undefined,
             ctx: {},
-        }, undefined);
-        expect(b_orderFn).toHaveBeenCalledTimes(1);
-        expect(b_orderFn).toHaveBeenCalledWith({
+        });
+        (0, vitest_1.expect)(b_orderFn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(b_orderFn.mock.calls[0][0].ctx).toEqual({
             refKey: "b",
             givenKey: "b",
             value: undefined,
             ctx: {},
-        }, undefined);
+        });
     });
-    it("keyedResolvOnce with pass ctx & {key: K}", () => {
+    (0, vitest_1.it)("keyedResolvOnce with pass ctx & {key: K}", () => {
         const my = new cement_1.KeyedResolvOnce({ ctx: { wurst: "world" } });
-        my.get(1).once((item) => {
-            assertType(item);
-            assertType(item);
-            assertType(item.givenKey);
-            assertType(item.ctx.wurst);
-            expect(item.givenKey).toBe(1);
-            expect(item.ctx.wurst).toBe("world");
+        my.get(1).once(({ ctx: item }) => {
+            (0, vitest_1.assertType)(item);
+            (0, vitest_1.assertType)(item);
+            (0, vitest_1.assertType)(item.givenKey);
+            (0, vitest_1.assertType)(item.ctx.wurst);
+            (0, vitest_1.expect)(item.givenKey).toBe(1);
+            (0, vitest_1.expect)(item.ctx.wurst).toBe("world");
             return { hello: "world" };
         });
     });
-    it("keyedResolvSeq with pass ctx & {key: K}", () => {
+    (0, vitest_1.it)("keyedResolvSeq with pass ctx & {key: K}", () => {
         const my = new cement_1.KeyedResolvSeq({ ctx: { wurst: "world" } });
         my.get(1).add((item) => {
-            assertType(item);
-            assertType(item);
-            assertType(item.givenKey);
-            assertType(item.ctx.wurst);
-            expect(item.ctx.wurst).toBe("world");
-            expect(item.givenKey).toBe(1);
+            (0, vitest_1.assertType)(item);
+            (0, vitest_1.assertType)(item);
+            (0, vitest_1.assertType)(item.givenKey);
+            (0, vitest_1.assertType)(item.ctx.wurst);
+            (0, vitest_1.expect)(item.ctx.wurst).toBe("world");
+            (0, vitest_1.expect)(item.givenKey).toBe(1);
             return { hello: "world" };
         });
     });
-    it("ResolveOnce plain", () => {
+    (0, vitest_1.it)("ResolveOnce plain", () => {
         const my = new cement_1.ResolveOnce();
         my.once(() => {
             return { hello: "world" };
         });
-        my.once((x) => {
-            return { hello: x.wurst };
+        my.once(({ ctx }) => {
+            return { hello: ctx.wurst };
         });
     });
-    it("keyedResolvOnce with pass decompose", () => {
+    (0, vitest_1.it)("keyedResolvOnce with pass decompose", () => {
         const my = new cement_1.KeyedResolvOnce();
-        my.get("1").once(({ refKey }) => {
-            assertType(refKey);
+        my.get("1").once(({ ctx }) => {
+            const { refKey } = ctx;
+            (0, vitest_1.assertType)(refKey);
             return { hello: "world" };
         });
         my.get("2").once(() => {
             return { hello: "world" };
         });
-        my.get("3").once((ctx) => {
-            assertType(ctx);
+        my.get("3").once(({ ctx }) => {
+            (0, vitest_1.assertType)(ctx);
             return { hello: "world" };
         });
     });
-    it("keyedResolvOnce with pass decompose", () => {
+    (0, vitest_1.it)("keyedResolvOnce with pass decompose", () => {
         const my = new cement_1.KeyedResolvSeq();
         my.get("1").add(({ refKey: key }) => {
-            assertType(key);
+            (0, vitest_1.assertType)(key);
             return { hello: "world" };
         });
     });
-    it("keyed asyncGet", async () => {
+    (0, vitest_1.it)("keyed asyncGet", async () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        const a_orderFn = vi.fn((key) => Promise.resolve(key));
-        const b_orderFn = vi.fn((key) => Promise.resolve(key));
+        const a_orderFn = vitest_1.vi.fn((key) => Promise.resolve(key));
+        const b_orderFn = vitest_1.vi.fn((key) => Promise.resolve(key));
         await Promise.all([
             keyed
                 .asyncGet(async () => {
@@ -324,20 +324,20 @@ describe("resolve-once", () => {
             })
                 .then((resolveOnce) => resolveOnce.once(b_orderFn)),
         ]);
-        expect(a_orderFn).toHaveBeenCalledTimes(1);
-        expect(a_orderFn).toHaveBeenCalledWith({
+        (0, vitest_1.expect)(a_orderFn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(a_orderFn.mock.calls[0][0].ctx).toEqual({
             ctx: {},
             givenKey: "a",
             refKey: "a",
             value: undefined,
-        }, undefined);
-        expect(b_orderFn).toHaveBeenCalledTimes(1);
-        expect(b_orderFn).toHaveBeenCalledWith({
+        });
+        (0, vitest_1.expect)(b_orderFn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(b_orderFn.mock.calls[0][0].ctx).toEqual({
             ctx: {},
             givenKey: "b",
             refKey: "b",
             value: undefined,
-        }, undefined);
+        });
     });
     function shuffle(array) {
         let currentIndex = array.length;
@@ -348,7 +348,7 @@ describe("resolve-once", () => {
         }
         return array;
     }
-    it("ResolveSeq", async () => {
+    (0, vitest_1.it)("ResolveSeq", async () => {
         const seq = new cement_1.ResolveSeq();
         let enter = 0;
         let leave = 0;
@@ -356,20 +356,20 @@ describe("resolve-once", () => {
             .fill(0)
             .map((_, i) => {
             return seq.add(async () => {
-                expect(enter++).toBe(i);
+                (0, vitest_1.expect)(enter++).toBe(i);
                 await new Promise((resolve) => setTimeout(resolve, i * 3));
                 await new Promise((resolve) => setTimeout(resolve, i * 2));
-                expect(leave++).toBe(i);
-                expect(leave).toBe(enter);
+                (0, vitest_1.expect)(leave++).toBe(i);
+                (0, vitest_1.expect)(leave).toBe(enter);
                 return i;
             }, i);
         });
         const ret = await Promise.all(shuffle(actions));
-        expect(ret.length).toBe(10);
-        expect(enter).toBe(10);
-        expect(leave).toBe(10);
+        (0, vitest_1.expect)(ret.length).toBe(10);
+        (0, vitest_1.expect)(enter).toBe(10);
+        (0, vitest_1.expect)(leave).toBe(10);
     });
-    it("with promise", async () => {
+    (0, vitest_1.it)("with promise", async () => {
         const once = new cement_1.ResolveOnce();
         let val = 42;
         const fn = async () => {
@@ -379,29 +379,29 @@ describe("resolve-once", () => {
                 }, 10);
             });
         };
-        expect(await once.once(fn)).toBe(42);
-        expect(await once.once(fn)).toBe(42);
+        (0, vitest_1.expect)(await once.once(fn)).toBe(42);
+        (0, vitest_1.expect)(await once.once(fn)).toBe(42);
     });
-    it("without promise", () => {
+    (0, vitest_1.it)("without promise", () => {
         const once = new cement_1.ResolveOnce();
         let val = 42;
         const fn = () => val++;
-        expect(once.once(fn)).toBe(42);
-        expect(once.once(fn)).toBe(42);
+        (0, vitest_1.expect)(once.once(fn)).toBe(42);
+        (0, vitest_1.expect)(once.once(fn)).toBe(42);
     });
-    it("without promise but exception", () => {
+    (0, vitest_1.it)("without promise but exception", () => {
         const once = new cement_1.ResolveOnce();
         let val = 42;
         const fn = () => {
             throw new Error(`nope ${val++}`);
         };
-        expect(() => once.once(fn)).toThrowError("nope 42");
-        expect(() => once.once(fn)).toThrowError("nope 42");
+        (0, vitest_1.expect)(() => once.once(fn)).toThrowError("nope 42");
+        (0, vitest_1.expect)(() => once.once(fn)).toThrowError("nope 42");
     });
-    it.each([() => new Promise((resolve) => setTimeout(resolve, 10)), () => Promise.resolve()])("async with unget", async (sleeper) => {
+    vitest_1.it.each([() => new Promise((resolve) => setTimeout(resolve, 10)), () => Promise.resolve()])("async with unget", async (sleeper) => {
         const once = new cement_1.KeyedResolvOnce();
         let triggerUnget = true;
-        const fn = vitest.fn();
+        const fn = vitest_1.vitest.fn();
         async function onceFn() {
             await sleeper();
             if (triggerUnget) {
@@ -412,23 +412,23 @@ describe("resolve-once", () => {
             fn("second");
             return await sleeper().then(() => "second");
         }
-        expect(await once.get("a").once(onceFn)).toBe("first");
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(await once.get("a").once(onceFn)).toBe("first");
-        expect(fn).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(await once.get("a").once(onceFn)).toBe("first");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(await once.get("a").once(onceFn)).toBe("first");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(2);
         triggerUnget = false;
-        expect(await once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(3);
-        expect(await once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(await once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(await once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(3);
         once.unget("a");
-        expect(await once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(4);
+        (0, vitest_1.expect)(await once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(4);
     });
-    it("sync with unget", () => {
+    (0, vitest_1.it)("sync with unget", () => {
         const once = new cement_1.KeyedResolvOnce();
         let triggerUnget = true;
-        const fn = vitest.fn();
+        const fn = vitest_1.vitest.fn();
         function onceFn() {
             if (triggerUnget) {
                 fn("first");
@@ -438,23 +438,23 @@ describe("resolve-once", () => {
             fn("second");
             return "second";
         }
-        expect(once.get("a").once(onceFn)).toBe("first");
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(once.get("a").once(onceFn)).toBe("first");
-        expect(fn).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(once.get("a").once(onceFn)).toBe("first");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(once.get("a").once(onceFn)).toBe("first");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(2);
         triggerUnget = false;
-        expect(once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(3);
-        expect(once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(3);
         once.unget("a");
-        expect(once.get("a").once(onceFn)).toBe("second");
-        expect(fn).toHaveBeenCalledTimes(4);
+        (0, vitest_1.expect)(once.get("a").once(onceFn)).toBe("second");
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(4);
     });
-    it("flush on seq", async () => {
+    (0, vitest_1.it)("flush on seq", async () => {
         const seq = new cement_1.ResolveSeq();
         let call = 42;
-        const fn = vitest.fn(async () => {
+        const fn = vitest_1.vitest.fn(async () => {
             await new Promise((resolve) => setTimeout(resolve, 10));
             return call++;
         });
@@ -463,32 +463,32 @@ describe("resolve-once", () => {
             .map((_, i) => {
             return seq.add(fn, i);
         });
-        expect(seq._seqFutures.length).toBe(10);
+        (0, vitest_1.expect)(seq._seqFutures.length).toBe(10);
         const flushes = [seq.flush(), seq.flush(), seq.flush(), seq.flush(), seq.flush()];
         await Promise.all(flushes);
-        expect(seq._seqFutures.length).toBe(0);
-        expect(await Promise.all(results)).toEqual(Array(10)
+        (0, vitest_1.expect)(seq._seqFutures.length).toBe(0);
+        (0, vitest_1.expect)(await Promise.all(results)).toEqual(Array(10)
             .fill(0)
             .map((_, i) => 42 + i));
-        expect(fn).toHaveBeenCalledTimes(10);
+        (0, vitest_1.expect)(fn).toHaveBeenCalledTimes(10);
     });
-    it("KeyedResolvOnce values", () => {
+    (0, vitest_1.it)("KeyedResolvOnce values", () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        expect(keyed.values()).toEqual([]);
+        (0, vitest_1.expect)(keyed.values()).toEqual([]);
         const a = keyed.get("a");
-        expect(keyed.values()).toEqual([]);
+        (0, vitest_1.expect)(keyed.values()).toEqual([]);
         a.once(() => 42);
-        expect(keyed.values()).toEqual([
+        (0, vitest_1.expect)(keyed.values()).toEqual([
             {
                 key: "a",
                 value: cement_1.Result.Ok(42),
-                item: expect.objectContaining({ givenKey: "a", refKey: "a" }),
+                item: vitest_1.expect.objectContaining({ givenKey: "a", refKey: "a" }),
             },
         ]);
         keyed.get("b").once(() => 43);
-        expect(keyed.values()).toEqual([
-            { key: "a", value: cement_1.Result.Ok(42), item: expect.objectContaining({ givenKey: "a", refKey: "a" }) },
-            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
+        (0, vitest_1.expect)(keyed.values()).toEqual([
+            { key: "a", value: cement_1.Result.Ok(42), item: vitest_1.expect.objectContaining({ givenKey: "a", refKey: "a" }) },
+            { key: "b", value: cement_1.Result.Ok(43), item: vitest_1.expect.objectContaining({ givenKey: "b", refKey: "b" }) },
         ]);
         try {
             keyed.get("c").once(() => {
@@ -496,28 +496,28 @@ describe("resolve-once", () => {
             });
         }
         catch (e) {
-            expect(e).toEqual(new Error("nope"));
+            (0, vitest_1.expect)(e).toEqual(new Error("nope"));
         }
-        expect(keyed.values()).toEqual([
-            { key: "a", value: cement_1.Result.Ok(42), item: expect.objectContaining({ givenKey: "a", refKey: "a" }) },
-            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
-            { key: "c", value: cement_1.Result.Err(new Error("nope")), item: expect.objectContaining({ givenKey: "c", refKey: "c" }) },
+        (0, vitest_1.expect)(keyed.values()).toEqual([
+            { key: "a", value: cement_1.Result.Ok(42), item: vitest_1.expect.objectContaining({ givenKey: "a", refKey: "a" }) },
+            { key: "b", value: cement_1.Result.Ok(43), item: vitest_1.expect.objectContaining({ givenKey: "b", refKey: "b" }) },
+            { key: "c", value: cement_1.Result.Err(new Error("nope")), item: vitest_1.expect.objectContaining({ givenKey: "c", refKey: "c" }) },
         ]);
         keyed.unget("a");
         keyed.unget("c");
-        expect(keyed.values()).toEqual([
-            { key: "b", value: cement_1.Result.Ok(43), item: expect.objectContaining({ givenKey: "b", refKey: "b" }) },
+        (0, vitest_1.expect)(keyed.values()).toEqual([
+            { key: "b", value: cement_1.Result.Ok(43), item: vitest_1.expect.objectContaining({ givenKey: "b", refKey: "b" }) },
         ]);
     });
-    it("KeyedResolvOnce entries", () => {
+    (0, vitest_1.it)("KeyedResolvOnce entries", () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        expect(Array.from(keyed.entries())).toEqual([]);
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([]);
         const a = keyed.get("a");
-        expect(Array.from(keyed.entries())).toEqual([]);
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([]);
         a.once(() => 42);
-        expect(Array.from(keyed.entries())).toEqual([{ key: "a", value: cement_1.Result.Ok(42) }]);
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([{ key: "a", value: cement_1.Result.Ok(42) }]);
         keyed.get("b").once(() => 43);
-        expect(Array.from(keyed.entries())).toEqual([
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([
             { key: "a", value: cement_1.Result.Ok(42) },
             { key: "b", value: cement_1.Result.Ok(43) },
         ]);
@@ -527,93 +527,93 @@ describe("resolve-once", () => {
             });
         }
         catch (e) {
-            expect(e).toEqual(new Error("nope"));
+            (0, vitest_1.expect)(e).toEqual(new Error("nope"));
         }
-        expect(Array.from(keyed.entries())).toEqual([
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([
             { key: "a", value: cement_1.Result.Ok(42) },
             { key: "b", value: cement_1.Result.Ok(43) },
             { key: "c", value: cement_1.Result.Err(new Error("nope")) },
         ]);
         keyed.unget("a");
         keyed.unget("c");
-        expect(Array.from(keyed.entries())).toEqual([{ key: "b", value: cement_1.Result.Ok(43) }]);
+        (0, vitest_1.expect)(Array.from(keyed.entries())).toEqual([{ key: "b", value: cement_1.Result.Ok(43) }]);
     });
-    it("uses lru cache", () => {
+    (0, vitest_1.it)("uses lru cache", () => {
         const keyed = new cement_1.KeyedResolvOnce({ lru: { maxEntries: 2 } });
         for (let i = 0; i < 10; i++) {
             keyed.get(i.toString()).once(() => i);
         }
-        expect(keyed.values()).toEqual([
-            { key: "8", value: cement_1.Result.Ok(8), item: expect.objectContaining({ givenKey: "8", refKey: "8" }) },
-            { key: "9", value: cement_1.Result.Ok(9), item: expect.objectContaining({ givenKey: "9", refKey: "9" }) },
+        (0, vitest_1.expect)(keyed.values()).toEqual([
+            { key: "8", value: cement_1.Result.Ok(8), item: vitest_1.expect.objectContaining({ givenKey: "8", refKey: "8" }) },
+            { key: "9", value: cement_1.Result.Ok(9), item: vitest_1.expect.objectContaining({ givenKey: "9", refKey: "9" }) },
         ]);
     });
-    it("resolve once serves ready and value", () => {
+    (0, vitest_1.it)("resolve once serves ready and value", () => {
         const once = new cement_1.ResolveOnce();
-        expect(once.ready).toBe(false);
-        expect(once.value).toBe(undefined);
+        (0, vitest_1.expect)(once.ready).toBe(false);
+        (0, vitest_1.expect)(once.value).toBe(undefined);
         once.once(() => 42);
-        expect(once.ready).toBe(true);
-        expect(once.value).toBe(42);
+        (0, vitest_1.expect)(once.ready).toBe(true);
+        (0, vitest_1.expect)(once.value).toBe(42);
         void once.reset();
-        expect(once.ready).toBe(false);
-        expect(once.value).toBe(undefined);
+        (0, vitest_1.expect)(once.ready).toBe(false);
+        (0, vitest_1.expect)(once.value).toBe(undefined);
     });
-    it("async resolve once serves ready and value", async () => {
+    (0, vitest_1.it)("async resolve once serves ready and value", async () => {
         const once = new cement_1.ResolveOnce();
-        expect(once.ready).toBe(false);
-        expect(once.value).toBe(undefined);
+        (0, vitest_1.expect)(once.ready).toBe(false);
+        (0, vitest_1.expect)(once.value).toBe(undefined);
         await once.once(() => Promise.resolve(42));
-        expect(once.ready).toBe(true);
-        expect(once.value).toBe(42);
+        (0, vitest_1.expect)(once.ready).toBe(true);
+        (0, vitest_1.expect)(once.value).toBe(42);
         void once.reset();
-        expect(once.ready).toBe(false);
-        expect(once.value).toBe(undefined);
+        (0, vitest_1.expect)(once.ready).toBe(false);
+        (0, vitest_1.expect)(once.value).toBe(undefined);
     });
-    it("keyed expose onAdd on onDelete", () => {
+    (0, vitest_1.it)("keyed expose onAdd on onDelete", () => {
         const k = new cement_1.KeyedResolvOnce();
-        const fn = vi.fn();
+        const fn = vitest_1.vi.fn();
         k.onSet(fn)();
         k.onDelete(fn)();
     });
-    it("test async version of once", () => {
+    (0, vitest_1.it)("test async version of once", () => {
         const r = new cement_1.ResolveOnce();
         const x = r.once(() => Promise.resolve(1));
-        assertType(x);
+        (0, vitest_1.assertType)(x);
         const rv = new cement_1.ResolveOnce();
         const xv = rv.once(async () => {
         });
-        assertType(xv);
+        (0, vitest_1.assertType)(xv);
     });
-    it("test sync version of once", () => {
+    (0, vitest_1.it)("test sync version of once", () => {
         const r = new cement_1.ResolveOnce();
         const x = r.once(() => 1);
-        assertType(x);
+        (0, vitest_1.assertType)(x);
         const rv = new cement_1.ResolveOnce();
         const xv = rv.once(() => {
         });
-        assertType(xv);
+        (0, vitest_1.assertType)(xv);
     });
-    it("once return undefined", () => {
+    (0, vitest_1.it)("once return undefined", () => {
         const once = new cement_1.ResolveOnce();
         const x = once.once(() => {
             return;
         });
-        expect(x).toBe(undefined);
+        (0, vitest_1.expect)(x).toBe(undefined);
     });
-    it("once return undefined", async () => {
+    (0, vitest_1.it)("once return undefined", async () => {
         const once = new cement_1.ResolveOnce();
         const x = once.once(() => {
             return Promise.resolve();
         });
-        assertType(x);
-        expect(await x).toBe(undefined);
+        (0, vitest_1.assertType)(x);
+        (0, vitest_1.expect)(await x).toBe(undefined);
     });
-    it("keyed has a has method", () => {
+    (0, vitest_1.it)("keyed has a has method", () => {
         const keyed = new cement_1.KeyedResolvOnce();
-        expect(keyed.has("a")).toBe(false);
+        (0, vitest_1.expect)(keyed.has("a")).toBe(false);
         keyed.get("a").once(() => 42);
-        expect(keyed.has("a")).toBe(true);
+        (0, vitest_1.expect)(keyed.has("a")).toBe(true);
     });
 });
 class MyLazy {
@@ -635,8 +635,8 @@ class MyLazy {
         };
     }
 }
-describe("Reset does not remove pending futures", () => {
-    it("reset are queued", async () => {
+(0, vitest_1.describe)("Reset does not remove pending futures", () => {
+    (0, vitest_1.it)("reset are queued", async () => {
         const once = new cement_1.ResolveOnce();
         const actions = [];
         const actionCnt = 3;
@@ -663,22 +663,22 @@ describe("Reset does not remove pending futures", () => {
                 }),
             });
         }
-        expect(once.queueLength).toBe(actionCnt * onceCallCnt + actionCnt + actionCnt + 1);
+        (0, vitest_1.expect)(once.queueLength).toBe(actionCnt * onceCallCnt + actionCnt + actionCnt + 1);
         [...actions].reverse().forEach((a) => {
             [...a.futures].reverse().forEach((f) => {
                 f.resolve();
             });
         });
         await Promise.all(actions.map((a) => a.reset));
-        expect(once.queueLength).toBe(actionCnt + 1);
+        (0, vitest_1.expect)(once.queueLength).toBe(actionCnt + 1);
         for (let i = 0; i < actionCnt; i++) {
             const a = actions[i];
-            expect(await Promise.all(a.results)).toEqual(Array(onceCallCnt)
+            (0, vitest_1.expect)(await Promise.all(a.results)).toEqual(Array(onceCallCnt)
                 .fill(0)
                 .map(() => (i ? i + 96 : i + 63)));
         }
     });
-    it("Reset does not remove pending futures", async () => {
+    (0, vitest_1.it)("Reset does not remove pending futures", async () => {
         const cnt = 10;
         const once = new cement_1.ResolveOnce();
         const releaseOnce = new cement_1.Future();
@@ -689,7 +689,7 @@ describe("Reset does not remove pending futures", () => {
         }));
         const newValue = new cement_1.Future();
         let newWaiting = undefined;
-        const never = vi.fn();
+        const never = vitest_1.vi.fn();
         const resetResult = once.reset(async () => {
             newWaiting = Promise.all(Array(cnt)
                 .fill(0)
@@ -702,97 +702,97 @@ describe("Reset does not remove pending futures", () => {
         });
         releaseOnce.resolve();
         newValue.resolve();
-        expect(await resetResult).toBe(42);
+        (0, vitest_1.expect)(await resetResult).toBe(42);
         const resWaiting = await waiting;
-        expect(resWaiting).toEqual(Array(cnt).fill(24));
-        if (!(0, is_promise_js_1.isPromise)(newWaiting)) {
-            assert.fail("newWaiting is undefined");
+        (0, vitest_1.expect)(resWaiting).toEqual(Array(cnt).fill(24));
+        if (!(0, cement_1.isPromise)(newWaiting)) {
+            vitest_1.assert.fail("newWaiting is undefined");
             return;
         }
         const newWaitingResult = await Promise.resolve(newWaiting);
-        expect(newWaitingResult).toEqual(Array(cnt).fill(24));
-        expect(never).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(newWaitingResult).toEqual(Array(cnt).fill(24));
+        (0, vitest_1.expect)(never).not.toHaveBeenCalled();
         const resolvedReset = await resetResult;
-        expect(resolvedReset).toBe(42);
-        expect(await Promise.all(Array(cnt)
+        (0, vitest_1.expect)(resolvedReset).toBe(42);
+        (0, vitest_1.expect)(await Promise.all(Array(cnt)
             .fill(0)
             .map(() => once.once(() => {
             never();
             return 49;
         })))).toEqual(Array(cnt).fill(42));
     });
-    it("Keyed Resolve ReturnType of once", () => {
+    (0, vitest_1.it)("Keyed Resolve ReturnType of once", () => {
         const keyed = new cement_1.KeyedResolvOnce();
         const type1 = keyed.get("type1").once(() => ({ type1: "1" }));
-        assertType(type1);
-        assertType(type1);
+        (0, vitest_1.assertType)(type1);
+        (0, vitest_1.assertType)(type1);
         const type2 = keyed.get("type2").once(() => ({ type2: 1 }));
-        assertType(type2);
-        assertType(type2);
+        (0, vitest_1.assertType)(type2);
+        (0, vitest_1.assertType)(type2);
         const type3 = keyed.get("type3").once(() => ({ type3: true }));
-        assertType(type3);
-        assertType(type3);
+        (0, vitest_1.assertType)(type3);
+        (0, vitest_1.assertType)(type3);
     });
-    it("ResolveOnce ReturnType of once", async () => {
+    (0, vitest_1.it)("ResolveOnce ReturnType of once", async () => {
         const ronce = new cement_1.ResolveOnce();
         const type1 = ronce.once(() => ({ type1: "1" }));
-        assertType(type1);
-        assertType(type1);
+        (0, vitest_1.assertType)(type1);
+        (0, vitest_1.assertType)(type1);
         const type2 = ronce.once(() => ({ type2: 1 }));
-        assertType(type2);
-        assertType(type2);
+        (0, vitest_1.assertType)(type2);
+        (0, vitest_1.assertType)(type2);
         const type3 = ronce.once(() => ({ type3: true }));
-        assertType(type3);
-        assertType(type3);
+        (0, vitest_1.assertType)(type3);
+        (0, vitest_1.assertType)(type3);
         const atype1 = await ronce.once(() => Promise.resolve({ type1: "1" }));
-        assertType(atype1);
-        assertType(atype1);
+        (0, vitest_1.assertType)(atype1);
+        (0, vitest_1.assertType)(atype1);
         const atype2 = await ronce.once(() => Promise.resolve({ type2: 1 }));
-        assertType(atype2);
-        assertType(atype2);
+        (0, vitest_1.assertType)(atype2);
+        (0, vitest_1.assertType)(atype2);
         const atype3 = await ronce.once(() => Promise.resolve({ type3: true }));
-        assertType(atype3);
-        assertType(atype3);
+        (0, vitest_1.assertType)(atype3);
+        (0, vitest_1.assertType)(atype3);
     });
 });
-describe("Lazy Initialization", () => {
-    it("ResolveOnce could be used for LazyInitialization", async () => {
+(0, vitest_1.describe)("Lazy Initialization", () => {
+    (0, vitest_1.it)("ResolveOnce could be used for LazyInitialization", async () => {
         const my = new MyLazy();
-        expect(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
-        expect(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
-        expect(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
+        (0, vitest_1.expect)(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
+        (0, vitest_1.expect)(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
+        (0, vitest_1.expect)(await my.action()).toEqual({ sync: 43, async: 44, asyncPass: 46, passIn: 42 });
     });
-    it("Sync Lazy With Renew Timer", async () => {
+    (0, vitest_1.it)("Sync Lazy With Renew Timer", async () => {
         let initVal = 0;
         const lazy = (0, cement_1.Lazy)(() => {
             return ++initVal;
         }, { resetAfter: 50 });
-        expect(lazy()).toBe(1);
-        await (0, promise_sleep_js_1.sleep)(10);
-        expect(lazy()).toBe(1);
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(lazy()).toBe(2);
-        expect(lazy()).toBe(2);
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(lazy()).toBe(3);
-        expect(lazy()).toBe(3);
-    });
-    it("Async Lazy With Renew Timer", async () => {
+        (0, vitest_1.expect)(lazy()).toBe(1);
+        await (0, cement_1.sleep)(10);
+        (0, vitest_1.expect)(lazy()).toBe(1);
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(lazy()).toBe(2);
+        (0, vitest_1.expect)(lazy()).toBe(2);
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(lazy()).toBe(3);
+        (0, vitest_1.expect)(lazy()).toBe(3);
+    });
+    (0, vitest_1.it)("Async Lazy With Renew Timer", async () => {
         let initVal = 0;
         const lazy = (0, cement_1.Lazy)(() => {
             return Promise.resolve(++initVal);
         }, { resetAfter: 50 });
-        expect(await lazy()).toBe(1);
-        await (0, promise_sleep_js_1.sleep)(10);
-        expect(await lazy()).toBe(1);
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(await lazy()).toBe(2);
-        expect(await lazy()).toBe(2);
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(await lazy()).toBe(3);
-        expect(await lazy()).toBe(3);
-    });
-    it("KeyedResolveOnce and resetAfter", async () => {
+        (0, vitest_1.expect)(await lazy()).toBe(1);
+        await (0, cement_1.sleep)(10);
+        (0, vitest_1.expect)(await lazy()).toBe(1);
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(await lazy()).toBe(2);
+        (0, vitest_1.expect)(await lazy()).toBe(2);
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(await lazy()).toBe(3);
+        (0, vitest_1.expect)(await lazy()).toBe(3);
+    });
+    (0, vitest_1.it)("KeyedResolveOnce and resetAfter", async () => {
         const keyed = new cement_1.KeyedResolvOnce({
             resetAfter: 50,
         });
@@ -802,25 +802,25 @@ describe("Lazy Initialization", () => {
                 .fill(0)
                 .map((_, idx) => keyed.get(idx).once(() => initVal));
         }
-        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
-        await (0, promise_sleep_js_1.sleep)(10);
-        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
-        await (0, promise_sleep_js_1.sleep)(10);
-        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
-        await (0, promise_sleep_js_1.sleep)(60);
-        expect(onces(++initVal)).toEqual(Array(5).fill(initVal));
-        expect(onces(initVal)).toEqual(Array(5).fill(initVal));
+        (0, vitest_1.expect)(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        await (0, cement_1.sleep)(10);
+        (0, vitest_1.expect)(onces(initVal)).toEqual(Array(5).fill(initVal));
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        await (0, cement_1.sleep)(10);
+        (0, vitest_1.expect)(onces(initVal)).toEqual(Array(5).fill(initVal));
+        await (0, cement_1.sleep)(60);
+        (0, vitest_1.expect)(onces(++initVal)).toEqual(Array(5).fill(initVal));
+        (0, vitest_1.expect)(onces(initVal)).toEqual(Array(5).fill(initVal));
     });
 });
-describe("KeyToHash", () => {
-    it("KeyedResolvSeq could use default KeyToHash", async () => {
+(0, vitest_1.describe)("KeyToHash", () => {
+    (0, vitest_1.it)("KeyedResolvSeq could use default KeyToHash", async () => {
         const keyed = new cement_1.KeyedResolvSeq({
             key2string: (key) => `${key.id}:${key.name}`,
             ctx: { ctx: "test" },
         });
-        const addFn = vi
+        const addFn = vitest_1.vi
             .fn()
             .mockImplementation((item) => {
             return Promise.resolve({ item });
@@ -828,45 +828,47 @@ describe("KeyToHash", () => {
         await keyed.get({ id: 1, name: "test" }).add(addFn);
         await keyed.get({ id: 1, name: "test" }).add(addFn);
         await keyed.get({ id: 2, name: "test" }).add(addFn);
-        expect(addFn).toHaveBeenCalledTimes(3);
-        expect(addFn).toHaveBeenNthCalledWith(1, {
+        (0, vitest_1.expect)(addFn).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(addFn).toHaveBeenNthCalledWith(1, {
             refKey: "1:test",
             givenKey: { id: 1, name: "test" },
             value: undefined,
             ctx: { ctx: "test" },
         });
-        expect(addFn).toHaveBeenNthCalledWith(2, {
+        (0, vitest_1.expect)(addFn).toHaveBeenNthCalledWith(2, {
             refKey: "1:test",
             givenKey: { id: 1, name: "test" },
             value: undefined,
             ctx: { ctx: "test" },
         });
-        expect(addFn).toHaveBeenNthCalledWith(3, {
+        (0, vitest_1.expect)(addFn).toHaveBeenNthCalledWith(3, {
             refKey: "2:test",
             givenKey: { id: 2, name: "test" },
             value: undefined,
             ctx: { ctx: "test" },
         });
     });
-    it("KeyedResolvOnce could use custom KeyToHash", async () => {
+    (0, vitest_1.it)("KeyedResolvOnce could use custom KeyToHash", async () => {
         const keyed = new cement_1.KeyedResolvOnce({
             key2string: (key) => `${key.id}:${key.name}`,
             ctx: { ctx: "test" },
         });
-        const onceFn = vi.fn().mockImplementation((item) => {
+        const onceFn = vitest_1.vi
+            .fn()
+            .mockImplementation(({ ctx }) => {
             return {
-                id: item.givenKey.id,
-                name: item.givenKey.name,
+                id: ctx.givenKey.id,
+                name: ctx.givenKey.name,
             };
         });
         for (let i = 0; i < 3; i++) {
             const res = await keyed.get({ id: 1, name: "test" }).once((item) => {
                 return Promise.resolve(onceFn(item));
             });
-            expect(res).toEqual({ id: 1, name: "test" });
+            (0, vitest_1.expect)(res).toEqual({ id: 1, name: "test" });
         }
-        expect(onceFn).toHaveBeenCalledTimes(1);
-        expect(onceFn).toHaveBeenCalledWith({
+        (0, vitest_1.expect)(onceFn).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onceFn.mock.calls[0][0].ctx).toEqual({
             refKey: "1:test",
             givenKey: { id: 1, name: "test" },
             value: undefined,
@@ -874,41 +876,61 @@ describe("KeyToHash", () => {
         });
     });
 });
-it("ResolveOnce gets is prev value if reset", () => {
+(0, vitest_1.it)("ResolveOnce gets is prev value if reset", () => {
     const once = new cement_1.ResolveOnce();
     once.once(() => ({
         value: 42,
         stats: 1,
     }));
-    once.reset();
-    const res1 = once.once((_, prev) => {
-        if (!prev) {
+    void once.reset();
+    const res1 = once.once((my) => {
+        if (!my.self.value) {
             throw new Error("prev is undefined");
         }
         return {
             value: 45,
-            stats: prev.stats + 1,
+            stats: my.self.value.stats + 1,
         };
     });
-    expect(res1).toEqual({
+    (0, vitest_1.expect)(res1).toEqual({
         value: 45,
         stats: 2,
     });
-    once.reset();
-    const res2 = once.once((_, prev) => {
-        if (!prev) {
+    void once.reset();
+    const res2 = once.once((my) => {
+        if (!my.self.value) {
             throw new Error("prev is undefined");
         }
-        prev.stats++;
-        prev.value += 3;
-        return prev;
+        my.self.value.stats++;
+        my.self.value.value += 3;
+        return my.self.value;
     });
-    expect(res2).toEqual({
+    (0, vitest_1.expect)(res2).toEqual({
         value: 48,
         stats: 3,
     });
 });
-it("does not block node on process exit", async () => {
+(0, vitest_1.it)("dynamic setting of resetAfter switch off", async () => {
+    const once = new cement_1.ResolveOnce(undefined, { resetAfter: 30 });
+    once.once((my) => {
+        my.self.setResetAfter();
+        return 42;
+    });
+    await (0, cement_1.sleep)(40);
+    (0, vitest_1.expect)(once.once(() => 43)).toBe(42);
+});
+(0, vitest_1.it)("dynamic setting of resetAfter change time", async () => {
+    const once = new cement_1.ResolveOnce(undefined, { resetAfter: 30 });
+    once.once((my) => {
+        my.self.setResetAfter(10);
+        return 42;
+    });
+    await (0, cement_1.sleep)(15);
+    (0, vitest_1.expect)(once.once(() => 43)).toBe(43);
+    await (0, cement_1.sleep)(15);
+    (0, vitest_1.expect)(once.once(() => 44)).toBe(44);
+});
+(0, vitest_1.it)("does not block node on process exit", async () => {
     let runtime = undefined;
     if ((0, cement_1.runtimeFn)().isNodeIsh) {
         runtime = ["tsx", "-e"];
@@ -925,9 +947,15 @@ it("does not block node on process exit", async () => {
             `.finally(() => console.log("done"));`,
         ].join("");
         const res = await $ `${runtime} ${[code]}`;
-        expect(res.ok).toBe(true);
+        (0, vitest_1.expect)(res.ok).toBe(true);
         const duration = Date.now() - start;
-        expect(duration).toBeLessThan(1000);
+        (0, vitest_1.expect)(duration).toBeLessThan(2000);
     }
 });
+(0, vitest_1.it)("KeyedResolvOnce in void", () => {
+    const keyed = new cement_1.KeyedResolvOnce();
+    keyed.get("a").once(() => {
+        void 0;
+    });
+});
 //# sourceMappingURL=resolve-once.test.js.map