@pistonite/pure 0.26.8 → 0.27.1

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/RwLock.ts

@@ -6,6 +6,8 @@ import Deque from "denque";
  * Only guaranteed if no one else has reference to the inner object
  *
  * It can take a second type parameter to specify interface with write methods
+ *
+ * @deprecated unstable API
  */
 export class RwLock<TRead, TWrite extends TRead = TRead> {
     /**

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

@@ -0,0 +1,33 @@
+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> => {
+    // captures the object
+    // technically, this is not needed, as the delete() call above
+    // should make sure the captured object is not GC'ed.
+    // However, making it reachable from a global object will definitely
+    // prevent GC even with crazy optimization from any runtime
+    captured.add(obj);
+    try {
+        return await fn();
+    } finally {
+        captured.delete(obj);
+    }
+};
+
+/**
+ * Execute a closure `fn`, and guarantee that `obj` will not be
+ * garbage-collected during the execution
+ */
+export const scopedCaptureSync = <T>(fn: () => T, obj: unknown): T => {
+    // captures the object
+    captured.add(obj);
+    try {
+        return fn();
+    } finally {
+        captured.delete(obj);
+    }
+};

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/index.ts

@@ -15,6 +15,7 @@ export { debounce, type DebounceConstructor } from "./debounce.ts";
 export { batch, type BatchConstructor } from "./batch.ts";
 export { once, type OnceConstructor } from "./once.ts";
 export { makePromise, type PromiseHandle } from "./util.ts";
+export { scopedCapture, scopedCaptureSync } from "./capture.ts";
 
 // helper types
 export type { AnyFn, AwaitRet } from "./util.ts";

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/mutex.ts

@@ -0,0 +1,21 @@
+/**
+ * Non-reentrant mutex
+ *
+ * This allows only one context to enter a block at a time in a FIFO manner.
+ *
+ * This mutex is non-reentrant. Trying to lock it again while the same
+ * context already owns the lock will cause a dead lock.
+ *
+ * While a context id can be used to implement reentrant locks,
+ * it is very cumbersome to use. https://github.com/tc39/proposal-async-context
+ * will allow for a cleaner implementation.
+ */
+// TODO: implement it if needed
+// export class Mutex {
+//     private waiters: Deque;
+//
+//     constructor() {
+//         this.waiters = new
+//     }
+//
+// }

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