@pistonite/pure 0.27.0 → 0.27.1

package/src/memory/async_erc.ts

@@ -82,9 +82,7 @@ export type AsyncErcRef<TName, TRepr = number> = {
  * @deprecated use Emp
  */
 export type AsyncErcRefType<T> =
-    T extends AsyncErc<infer TName, infer TRepr>
-        ? AsyncErcRef<TName, TRepr>
-        : never;
+    T extends AsyncErc<infer TName, infer TRepr> ? AsyncErcRef<TName, TRepr> : never;
 
 /**
  * @deprecated use Emp
@@ -121,12 +119,9 @@ export const makeAsyncErcType = <TName, TRepr>({
 }: AsyncErcTypeConstructor<TName, TRepr>): ((
     value: TRepr | undefined,
 ) => AsyncErc<TName, TRepr>) => {
-    const createStrongRef = (
-        value: TRepr | undefined,
-    ): AsyncErc<TName, TRepr> => {
-        let weakRef:
-            | (AsyncErcRef<TName, TRepr> & { invalidate: () => void })
-            | undefined = undefined;
+    const createStrongRef = (value: TRepr | undefined): AsyncErc<TName, TRepr> => {
+        let weakRef: (AsyncErcRef<TName, TRepr> & { invalidate: () => void }) | undefined =
+            undefined;
         const invalidateWeakRef = () => {
             if (!weakRef) {
                 return;

package/src/memory/cell.ts

@@ -14,10 +14,7 @@ export type CellConstructor<T> = {
 export type Cell<T> = {
     get(): T;
     set(value: T): void;
-    subscribe(
-        callback: (value: T) => void,
-        notifyImmediately?: boolean,
-    ): () => void;
+    subscribe(callback: (value: T) => void, notifyImmediately?: boolean): () => void;
 };
 
 class CellImpl<T> implements Cell<T> {
@@ -41,10 +38,7 @@ class CellImpl<T> implements Cell<T> {
         }
     }
 
-    public subscribe(
-        callback: (value: T) => void,
-        notifyImmediately?: boolean,
-    ): () => void {
+    public subscribe(callback: (value: T) => void, notifyImmediately?: boolean): () => void {
         this.subscribers.push(callback);
         const unsubscribe = () => {
             const index = this.subscribers.indexOf(callback);

package/src/memory/erc.test.ts

@@ -119,143 +119,140 @@ describe.each`
     indirection | allocator
     ${"single"} | ${new Allocator(false)}
     ${"double"} | ${new Allocator(true)}
-`(
-    "Erc - $indirection indirection",
-    ({ allocator }: { allocator: Allocator }) => {
-        afterEach(() => {
-            allocator.cleanup();
-        });
+`("Erc - $indirection indirection", ({ allocator }: { allocator: Allocator }) => {
+    afterEach(() => {
+        allocator.cleanup();
+    });
 
-        it("allocate and deallocate correctly", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            expect(allocator.getValue(test.value)).toBe("Hello");
-            test.free();
-            allocator.expectNoLeak();
-        });
+    it("allocate and deallocate correctly", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        expect(allocator.getValue(test.value)).toBe("Hello");
+        test.free();
+        allocator.expectNoLeak();
+    });
 
-        it("frees if assigned new value", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            test.assign(allocator.allocValue("World"));
-            expect(allocator.getValue(test.value)).toBe("World");
-            test.free();
-            allocator.expectNoLeak();
-        });
+    it("frees if assigned new value", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        test.assign(allocator.allocValue("World"));
+        expect(allocator.getValue(test.value)).toBe("World");
+        test.free();
+        allocator.expectNoLeak();
+    });
 
-        it("does not free when taking value", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const raw = test.take();
-            expect(allocator.getValue(raw)).toBe("Hello");
-            expect(test.value).toBeUndefined();
-            if (raw === undefined) {
-                throw new Error("Raw value is undefined");
-            }
-            allocator.makeTestErc(raw).free();
-            allocator.expectNoLeak();
-        });
+    it("does not free when taking value", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const raw = test.take();
+        expect(allocator.getValue(raw)).toBe("Hello");
+        expect(test.value).toBeUndefined();
+        if (raw === undefined) {
+            throw new Error("Raw value is undefined");
+        }
+        allocator.makeTestErc(raw).free();
+        allocator.expectNoLeak();
+    });
 
-        it("invalidates weak references on free", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const testWeak = test.getWeak();
-            expect(allocator.getValue(testWeak.value)).toBe("Hello");
-            test.free();
-            expect(testWeak.value).toBeUndefined();
-            allocator.expectNoLeak();
-        });
+    it("invalidates weak references on free", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const testWeak = test.getWeak();
+        expect(allocator.getValue(testWeak.value)).toBe("Hello");
+        test.free();
+        expect(testWeak.value).toBeUndefined();
+        allocator.expectNoLeak();
+    });
 
-        it("invalidates weak references on assign", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const testWeak = test.getWeak();
-            expect(allocator.getValue(testWeak.value)).toBe("Hello");
-            test.assign(allocator.allocValue("World"));
-            expect(testWeak.value).toBeUndefined();
-            test.free();
-            allocator.expectNoLeak();
-        });
+    it("invalidates weak references on assign", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const testWeak = test.getWeak();
+        expect(allocator.getValue(testWeak.value)).toBe("Hello");
+        test.assign(allocator.allocValue("World"));
+        expect(testWeak.value).toBeUndefined();
+        test.free();
+        allocator.expectNoLeak();
+    });
 
-        it("handles assign and take of different references correctly", () => {
-            const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const test2 = allocator.makeTestErc(allocator.allocValue("World"));
-            expect(allocator.getValue(test1.value)).toBe("Hello");
-            expect(allocator.getValue(test2.value)).toBe("World");
-            test1.assign(test2.take());
-            expect(allocator.getValue(test1.value)).toBe("World");
-            test1.free();
-            allocator.expectNoLeak();
-        });
+    it("handles assign and take of different references correctly", () => {
+        const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const test2 = allocator.makeTestErc(allocator.allocValue("World"));
+        expect(allocator.getValue(test1.value)).toBe("Hello");
+        expect(allocator.getValue(test2.value)).toBe("World");
+        test1.assign(test2.take());
+        expect(allocator.getValue(test1.value)).toBe("World");
+        test1.free();
+        allocator.expectNoLeak();
+    });
 
-        it("handles assign and take of same references correctly", () => {
-            const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const test2 = test1.getStrong();
-            test1.assign(test2.take());
-            expect(allocator.getValue(test1.value)).toBe("Hello");
-            test1.free();
-            test2.free(); // should be no-op
-            allocator.expectNoLeak();
-        });
+    it("handles assign and take of same references correctly", () => {
+        const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const test2 = test1.getStrong();
+        test1.assign(test2.take());
+        expect(allocator.getValue(test1.value)).toBe("Hello");
+        test1.free();
+        test2.free(); // should be no-op
+        allocator.expectNoLeak();
+    });
 
-        it("assigning another Erc directly should cause double free", async () => {
-            const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const test2 = test1.getStrong();
-            test1.assign(test2.value);
-            expect(allocator.getValue(test1.value)).toBe("Hello");
-            test1.free();
+    it("assigning another Erc directly should cause double free", async () => {
+        const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const test2 = test1.getStrong();
+        test1.assign(test2.value);
+        expect(allocator.getValue(test1.value)).toBe("Hello");
+        test1.free();
 
-            const freeTest2 = async () => {
-                test2.free();
-            };
-            await expect(freeTest2).rejects.toThrow("Double free detected");
-            allocator.expectNoLeak();
-        });
+        const freeTest2 = async () => {
+            test2.free();
+        };
+        await expect(freeTest2).rejects.toThrow("Double free detected");
+        allocator.expectNoLeak();
+    });
 
-        it("handles assign and take of same references correctly (same Erc)", () => {
-            const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
-            test1.assign(test1.take());
-            expect(allocator.getValue(test1.value)).toBe("Hello");
-            test1.free();
-            allocator.expectNoLeak();
-        });
+    it("handles assign and take of same references correctly (same Erc)", () => {
+        const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
+        test1.assign(test1.take());
+        expect(allocator.getValue(test1.value)).toBe("Hello");
+        test1.free();
+        allocator.expectNoLeak();
+    });
 
-        it("assigning another Erc directly should cause double free (same Erc)", async () => {
-            const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
-            test1.assign(test1.value);
-            const getTest1Value = async () => {
-                allocator.getValue(test1.value);
-            };
-            await expect(getTest1Value).rejects.toThrow("Dangling pointer");
+    it("assigning another Erc directly should cause double free (same Erc)", async () => {
+        const test1 = allocator.makeTestErc(allocator.allocValue("Hello"));
+        test1.assign(test1.value);
+        const getTest1Value = async () => {
+            allocator.getValue(test1.value);
+        };
+        await expect(getTest1Value).rejects.toThrow("Dangling pointer");
 
-            const freeTest1 = async () => {
-                test1.free();
-            };
-            await expect(freeTest1).rejects.toThrow("Double free detected");
-            allocator.expectNoLeak();
-        });
+        const freeTest1 = async () => {
+            test1.free();
+        };
+        await expect(freeTest1).rejects.toThrow("Double free detected");
+        allocator.expectNoLeak();
+    });
 
-        it("inc ref count with strong reference", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const test2 = test.getStrong();
-            expect(allocator.getValue(test.value)).toBe("Hello");
-            expect(allocator.getValue(test2.value)).toBe("Hello");
-            test.free();
-            expect(allocator.getValue(test2.value)).toBe("Hello");
-            test2.free();
-            allocator.expectNoLeak();
-        });
+    it("inc ref count with strong reference", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const test2 = test.getStrong();
+        expect(allocator.getValue(test.value)).toBe("Hello");
+        expect(allocator.getValue(test2.value)).toBe("Hello");
+        test.free();
+        expect(allocator.getValue(test2.value)).toBe("Hello");
+        test2.free();
+        allocator.expectNoLeak();
+    });
 
-        it("inc ref count with strong reference from weak reference", () => {
-            const test = allocator.makeTestErc(allocator.allocValue("Hello"));
-            const testWeak = test.getWeak();
-            expect(allocator.getValue(testWeak.value)).toBe("Hello");
-            const test2 = testWeak.getStrong();
-            expect(allocator.getValue(testWeak.value)).toBe("Hello");
-            expect(allocator.getValue(test2.value)).toBe("Hello");
-            const test2Weak = test2.getWeak();
-            test.free();
-            expect(testWeak.value).toBeUndefined();
-            expect(allocator.getValue(test2.value)).toBe("Hello");
-            expect(allocator.getValue(test2Weak.value)).toBe("Hello");
-            test2.free();
-            expect(test2Weak.value).toBeUndefined();
-            allocator.expectNoLeak();
-        });
-    },
-);
+    it("inc ref count with strong reference from weak reference", () => {
+        const test = allocator.makeTestErc(allocator.allocValue("Hello"));
+        const testWeak = test.getWeak();
+        expect(allocator.getValue(testWeak.value)).toBe("Hello");
+        const test2 = testWeak.getStrong();
+        expect(allocator.getValue(testWeak.value)).toBe("Hello");
+        expect(allocator.getValue(test2.value)).toBe("Hello");
+        const test2Weak = test2.getWeak();
+        test.free();
+        expect(testWeak.value).toBeUndefined();
+        expect(allocator.getValue(test2.value)).toBe("Hello");
+        expect(allocator.getValue(test2Weak.value)).toBe("Hello");
+        test2.free();
+        expect(test2Weak.value).toBeUndefined();
+        allocator.expectNoLeak();
+    });
+});

package/src/memory/erc.ts

@@ -78,8 +78,7 @@ export type ErcRef<TName, TRepr = number> = {
 /**
  * @deprecated use Emp
  */
-export type ErcRefType<T> =
-    T extends Erc<infer TName, infer TRepr> ? ErcRef<TName, TRepr> : never;
+export type ErcRefType<T> = T extends Erc<infer TName, infer TRepr> ? ErcRef<TName, TRepr> : never;
 
 /**
  * @deprecated use Emp
@@ -255,13 +254,9 @@ export const makeErcType = <TName, TRepr>({
     marker,
     free,
     addRef,
-}: ErcTypeConstructor<TName, TRepr>): ((
-    value: TRepr | undefined,
-) => Erc<TName, TRepr>) => {
+}: ErcTypeConstructor<TName, TRepr>): ((value: TRepr | undefined) => Erc<TName, TRepr>) => {
     const createStrongRef = (value: TRepr | undefined): Erc<TName, TRepr> => {
-        let weakRef:
-            | (ErcRef<TName, TRepr> & { invalidate: () => void })
-            | undefined = undefined;
+        let weakRef: (ErcRef<TName, TRepr> & { invalidate: () => void }) | undefined = undefined;
         const invalidateWeakRef = () => {
             if (!weakRef) {
                 return;

package/src/memory/persist.ts

@@ -106,10 +106,7 @@ class PersistImpl<T> implements Persist<T> {
         this.cell.set(value);
     }
 
-    public subscribe(
-        callback: (value: T) => void,
-        notifyImmediately?: boolean,
-    ): () => void {
+    public subscribe(callback: (value: T) => void, notifyImmediately?: boolean): () => void {
         return this.cell.subscribe(callback, notifyImmediately);
     }
 

package/src/pref/device.ts

@@ -82,15 +82,9 @@ export type DisplayModeOptions<T extends string> = {
  *
  * Use this only if the display mode needs to be detected programmatically.
  */
-export const initDisplayMode = <T extends string>(
-    options: DisplayModeOptions<T>,
-) => {
+export const initDisplayMode = <T extends string>(options: DisplayModeOptions<T>) => {
     const detectCallback = () => {
-        const mode = options.detect(
-            window.innerWidth,
-            window.innerHeight,
-            isMobile(),
-        );
+        const mode = options.detect(window.innerWidth, window.innerHeight, isMobile());
         displayMode.set(mode);
     };
     if (
@@ -115,10 +109,7 @@ export const addDisplayModeSubscriber = <T extends string>(
     subscriber: (mode: T) => void,
     notifyImmediately?: boolean,
 ) => {
-    return displayMode.subscribe(
-        subscriber as (x: string) => void,
-        notifyImmediately,
-    );
+    return displayMode.subscribe(subscriber as (x: string) => void, notifyImmediately);
 };
 
 /** Get the current display mode */

package/src/pref/locale.ts

@@ -5,9 +5,7 @@ import { serial } from "../sync/serial.ts";
 let supportedLocales: readonly string[] = [];
 let defaultLocale: string = "";
 let settingLocale: string = ""; // if locale is being set (setLocale called)
-let onBeforeChangeHook: (
-    newLocale: string,
-) => Promise<Result<void, "cancel">> = () => {
+let onBeforeChangeHook: (newLocale: string) => Promise<Result<void, "cancel">> = () => {
     return Promise.resolve({} as Result<void, "cancel">);
 };
 const locale = persist<string>({
@@ -81,10 +79,7 @@ export type LocaleOptions<TLocale extends string> = {
      *
      * Note that this hook will not be called during initialization.
      */
-    onBeforeChange?: (
-        newLocale: string,
-        checkCancel: () => void,
-    ) => void | Promise<void>;
+    onBeforeChange?: (newLocale: string, checkCancel: () => void) => void | Promise<void>;
 };
 
 /**
@@ -118,9 +113,7 @@ export type LocaleOptions<TLocale extends string> = {
  * Changing the locale from React components is the same as from outside React,
  * with `setLocale` or `i18next.changeLanguage`, depending on your setup.
  */
-export const initLocale = <TLocale extends string>(
-    options: LocaleOptions<TLocale>,
-): void => {
+export const initLocale = <TLocale extends string>(options: LocaleOptions<TLocale>): void => {
     if (options.onBeforeChange) {
         const onBeforeChange = options.onBeforeChange;
         onBeforeChangeHook = serial({
@@ -135,8 +128,7 @@ export const initLocale = <TLocale extends string>(
     if (options.initial) {
         _locale = options.initial;
     } else {
-        _locale =
-            convertToSupportedLocale(getPreferredLocale()) || options.default;
+        _locale = convertToSupportedLocale(getPreferredLocale()) || options.default;
     }
     defaultLocale = options.default;
     if (options.persist) {
@@ -221,9 +213,7 @@ export const setLocale = (newLocale: string): boolean => {
  * console.log(convertToSupportedLocale("es"));    // undefined
  * ```
  */
-export const convertToSupportedLocale = (
-    newLocale: string,
-): string | undefined => {
+export const convertToSupportedLocale = (newLocale: string): string | undefined => {
     return convertToSupportedLocaleIn(newLocale, supportedLocales);
 };
 
@@ -257,9 +247,7 @@ export const convertToSupportedLocaleIn = (
  * This is a thin wrapper for `convertToSupportedLocale`.
  * See that function for more details.
  */
-export const convertToSupportedLocaleOrDefault = (
-    newLocale: string,
-): string => {
+export const convertToSupportedLocaleOrDefault = (newLocale: string): string => {
     return convertToSupportedLocale(newLocale) || defaultLocale;
 };
 

package/src/result/index.ts

@@ -186,9 +186,7 @@ export function tryCatch<T, E = unknown>(fn: () => T): Result<T, E> {
 }
 
 /** Wrap an async function with try-catch and return a Promise<Result>. */
-export async function tryAsync<T, E = unknown>(
-    fn: () => Promise<T>,
-): Promise<Result<T, E>> {
+export async function tryAsync<T, E = unknown>(fn: () => Promise<T>): Promise<Result<T, E>> {
     try {
         return { val: await fn() };
     } catch (e) {

package/src/sync/batch.test.ts

@@ -81,12 +81,10 @@ describe("batch", () => {
     });
     test("unbatch", async () => {
         const fn = vi.fn();
-        const unbatch = vi.fn(
-            (inputs: [number][], output: number): number[] => {
-                // not actual meaningful unbatching
-                return [output / inputs.length, output / inputs.length];
-            },
-        );
+        const unbatch = vi.fn((inputs: [number][], output: number): number[] => {
+            // not actual meaningful unbatching
+            return [output / inputs.length, output / inputs.length];
+        });
         const execute = batch({
             fn: (x: number) => {
                 fn(x);

package/src/sync/batch.ts

@@ -1,9 +1,4 @@
-import {
-    type AnyFn,
-    makePromise,
-    type PromiseHandle,
-    type AwaitRet,
-} from "./util.ts";
+import { type AnyFn, makePromise, type PromiseHandle, type AwaitRet } from "./util.ts";
 
 /**
  * An async event wrapper that allows multiple calls in an interval
@@ -99,13 +94,7 @@ export function batch<TFn extends AnyFn>({
     interval,
     disregardExecutionTime,
 }: BatchConstructor<TFn>) {
-    const impl = new BatchImpl(
-        fn,
-        batch,
-        unbatch,
-        interval,
-        !!disregardExecutionTime,
-    );
+    const impl = new BatchImpl(fn, batch, unbatch, interval, !!disregardExecutionTime);
     return (...args: Parameters<TFn>) => impl.invoke(...args);
 }
 
@@ -124,10 +113,7 @@ export type BatchConstructor<TFn extends AnyFn> = {
      *
      * By default, each input will receive the same output from the batched call
      */
-    unbatch?: (
-        inputs: Parameters<TFn>[],
-        output: AwaitRet<TFn>,
-    ) => AwaitRet<TFn>[];
+    unbatch?: (inputs: Parameters<TFn>[], output: AwaitRet<TFn>) => AwaitRet<TFn>[];
 
     /**
      * Interval between each batched call
@@ -148,10 +134,7 @@ class BatchImpl<TFn extends AnyFn> {
         private fn: TFn,
         private batch: (inputs: Parameters<TFn>[]) => Parameters<TFn>,
         private unbatch:
-            | ((
-                  input: Parameters<TFn>[],
-                  output: AwaitRet<TFn>,
-              ) => AwaitRet<TFn>[])
+            | ((input: Parameters<TFn>[], output: AwaitRet<TFn>) => AwaitRet<TFn>[])
             | undefined,
         private interval: number,
         private disregardExecutionTime: boolean,

package/src/sync/capture.ts

@@ -4,10 +4,7 @@ const captured = new Set<unknown>();
  * Execute an async closure `fn`, and guarantee that `obj` will not be
  * garbage-collected, until the promise is resolved.
  */
-export const scopedCapture = async <T>(
-    fn: () => Promise<T>,
-    obj: unknown,
-): Promise<T> => {
+export const scopedCapture = async <T>(fn: () => Promise<T>, obj: unknown): Promise<T> => {
     // captures the object
     // technically, this is not needed, as the delete() call above
     // should make sure the captured object is not GC'ed.

package/src/sync/debounce.ts

@@ -1,9 +1,4 @@
-import {
-    type AnyFn,
-    type AwaitRet,
-    makePromise,
-    type PromiseHandle,
-} from "./util.ts";
+import { type AnyFn, type AwaitRet, makePromise, type PromiseHandle } from "./util.ts";
 
 /**
  * An async event wrapper that is guaranteed to:

package/src/sync/latest.ts

@@ -1,9 +1,4 @@
-import {
-    type AnyFn,
-    type AwaitRet,
-    makePromise,
-    type PromiseHandle,
-} from "./util.ts";
+import { type AnyFn, type AwaitRet, makePromise, type PromiseHandle } from "./util.ts";
 
 /**
  * An async event wrapper that always resolve to the result of the latest
@@ -112,12 +107,7 @@ export class LatestImpl<TFn extends AnyFn> {
         if (this.pending) {
             // pending means currentArgs is not undefined
             const currentArgs = this.currentArgs as Parameters<TFn>;
-            const nextArgs = this.updateArgs(
-                currentArgs,
-                this.middleArgs,
-                args,
-                this.nextArgs,
-            );
+            const nextArgs = this.updateArgs(currentArgs, this.middleArgs, args, this.nextArgs);
             if (this.areArgsEqual(nextArgs, currentArgs)) {
                 // do not schedule new call
                 this.nextArgs = undefined;

package/src/sync/serial.test.ts

@@ -5,8 +5,7 @@ import type { Result } from "../result/index.ts";
 
 test("example", async () => {
     // helper function to simulate async work
-    const wait = (ms: number) =>
-        new Promise((resolve) => setTimeout(resolve, ms));
+    const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
     // Create the wrapped function
     const doWork = serial({
         fn: (checkCancel) => async () => {

package/src/sync/serial.ts

@@ -133,10 +133,7 @@ import type { AnyFn } from "./util.ts";
  * If the underlying function throws, the exception will be re-thrown to the caller.
  */
 
-export function serial<TFn extends AnyFn>({
-    fn,
-    onCancel,
-}: SerialConstructor<TFn>) {
+export function serial<TFn extends AnyFn>({ fn, onCancel }: SerialConstructor<TFn>) {
     const impl = new SerialImpl(fn, onCancel);
     return (...args: Parameters<TFn>) => impl.invoke(...args);
 }
@@ -162,10 +159,7 @@ class SerialImpl<TFn extends AnyFn> {
     private fn: SerialFnCreator<TFn>;
     private onCancel: SerialEventCancelCallback;
 
-    constructor(
-        fn: SerialFnCreator<TFn>,
-        onCancel?: SerialEventCancelCallback,
-    ) {
+    constructor(fn: SerialFnCreator<TFn>, onCancel?: SerialEventCancelCallback) {
         this.fn = fn;
         this.serial = 0n;
         if (onCancel) {
@@ -212,10 +206,7 @@ type SerialFnCreator<T> = (checkCancel: CheckCancelFn, serial: SerialId) => T;
  * The callback type passed to SerialEvent constructor to be called
  * when the event is cancelled
  */
-export type SerialEventCancelCallback = (
-    current: SerialId,
-    latest: SerialId,
-) => void;
+export type SerialEventCancelCallback = (current: SerialId, latest: SerialId) => void;
 
 /** The error type received by caller when an event is cancelled */
 export type SerialCancelToken = "cancel";

package/src/sync/util.ts

@@ -26,9 +26,7 @@ export type PromiseHandle<T> = {
 
 /** Shorthand for Awaited<ReturnType<T>> */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AwaitRet<T> = T extends (...args: any[]) => infer R
-    ? Awaited<R>
-    : never;
+export type AwaitRet<T> = T extends (...args: any[]) => infer R ? Awaited<R> : never;
 
 /** Type for any function */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any