soseki 0.0.5 → 0.0.6

package/src/core/_use-singleton.ts

@@ -1,24 +0,0 @@
-import * as React from "react";
-
-/**
- * 初期化が一度だけ実行されることを保証するための特殊なシンボルです。`ref.current` の初期値として使用され、値がまだ設定されていない状態を示します。
- */
-const NONE = Symbol.for("soseki/none");
-
-/**
- * コンポーネントのライフサイクルを通じて、初期化関数 (`fn`) を一度だけ実行し、その結果を保持し続けるカスタムフックです。
- *
- * `useMemo` と異なり、依存配列が存在しないため、再レンダリングやフックの呼び出し順序に関係なく、最初のレンダリング時にのみ初期化が実行されることを保証します。
- *
- * @template T 初期化関数が返す値の型です。
- * @param fn 一度だけ実行される初期化関数です。引数は取りません。
- * @returns 初期化関数が返した、シングルトンとして保持される値です。
- */
-export default function useSingleton<T>(fn: () => T): T {
-  const ref = React.useRef<T | typeof NONE>(NONE);
-  if (ref.current === NONE) {
-    ref.current = fn();
-  }
-
-  return ref.current;
-}

package/src/core/_weak-id-registry.ts

@@ -1,125 +0,0 @@
-import unreachable from "./_unreachable.js";
-
-/**
- * 識別子（ID）の型エイリアスです。
- *
- * ID は増分カウンターを36進数エンコードしたものです。
- */
-export type Id = string;
-
-/**
- * `WeakIdRegistry` クラスは、オブジェクトに対する ID の割り当てと管理を行います。
- *
- * オブジェクト自体は `WeakMap` と `WeakRef` を使用して保持されるため、参照がなくなったオブジェクトはガベージコレクション（GC）の対象になります。
- *
- * @template TValue ID を割り当てる対象となるオブジェクトの型です。`object` 型のサブタイプである必要があります。
- */
-export default class WeakIdRegistry<TValue extends object> {
-  /**
-   * ID 生成のための内部カウンターです。BigInt を使用することで、非常に大きな数値まで ID を生成できます。
-   */
-  private counter: bigint;
-
-  /**
-   * オブジェクト (関数を含む) から、割り当てられた ID へのマッピングを保持する `WeakMap` です。
-   *
-   * `WeakMap` を使用することで、キーであるオブジェクトが他の場所から参照されなくなった場合、このマッピングも自動的に破棄され、GC が可能になります。
-   */
-  private readonly v2id: WeakMap<TValue, Id>;
-
-  /**
-   * ID から、対応するオブジェクトへの弱い参照 (`WeakRef`) のマッピングを保持する `Map` です。
-   *
-   * オブジェクト自体が GC される可能性があるため、`WeakRef` を使用しています。
-   */
-  private readonly id2v: Map<Id, WeakRef<TValue>>;
-
-  /**
-   * オブジェクトが GC されたときに実行されるコールバックを登録するための `FinalizationRegistry` です。
-   *
-   * オブジェクトが GC されると、登録された ID がコールバックに渡され、その ID に対応するエントリーを `id2v` マップから削除するために使用されます。
-   */
-  private readonly gc: FinalizationRegistry<Id>;
-
-  /**
-   * `WeakIdRegistry` クラスの新しいインスタンスを作成します。
-   */
-  public constructor() {
-    this.counter = 0n;
-    this.v2id = new WeakMap();
-    this.id2v = new Map();
-    this.gc = new FinalizationRegistry(id => {
-      this.id2v.delete(id);
-    });
-  }
-
-  /**
-   * 指定されたオブジェクトに一意の ID を割り当てて登録します。
-   *
-   * すでに ID が割り当てられているオブジェクトであれば、既存の ID を返します。
-   *
-   * @param value ID を割り当てる対象のオブジェクトです。
-   * @returns 割り当てられた、または既存の一意の ID です。
-   */
-  public set(value: TValue): Id {
-    if (!this.v2id.has(value)) {
-      const id = (this.counter++).toString(36);
-      this.v2id.set(value, id);
-      this.id2v.set(id, new WeakRef(value));
-      // `FinalizationRegistry` にオブジェクトとそれに対応する ID を登録します。
-      // これにより、オブジェクトが GC されたときに `id2v` からエントリーが削除されます。
-      this.gc.register(value, id);
-
-      return id;
-    }
-
-    const id = this.v2id.get(value)!;
-    switch (typeof id) {
-      case "string":
-        return id;
-      default:
-        // `id` は必ず文字列になるはずです。
-        unreachable(id);
-    }
-  }
-
-  /**
-   * 指定されたオブジェクトに ID が割り当てられているかどうかを確認します。
-   *
-   * @param value 確認するオブジェクトです。
-   * @returns ID が割り当てられていれば `true`、そうでなければ `false` を返します。
-   */
-  public has(value: TValue): boolean {
-    return this.v2id.has(value);
-  }
-
-  /**
-   * 指定されたオブジェクトに対応する ID を取得します。
-   *
-   * オブジェクトが未登録の場合は `undefined` を返します。
-   *
-   * @param value 取得したい ID のオブジェクトです。
-   * @returns 対応する ID、またはオブジェクトが未登録の場合は `undefined` を返します。
-   */
-  public get(value: TValue): Id | undefined;
-
-  /**
-   * 指定された ID に対応するオブジェクトを取得します。
-   *
-   * オブジェクトが既に GC されている場合は `undefined` を返します。
-   *
-   * @param id 取得したいオブジェクトの ID です。
-   * @returns 対応するオブジェクト、またはオブジェクトが GC されている場合は `undefined` を返します。
-   */
-  public get(id: Id): TValue | undefined;
-
-  public get(idOrValue: Id | TValue): unknown {
-    if (typeof idOrValue === "string") {
-      const id = idOrValue;
-      return this.id2v.get(id)?.deref();
-    } else {
-      const value = idOrValue;
-      return this.v2id.get(value);
-    }
-  }
-}

package/src/core/constants.ts

@@ -1,4 +0,0 @@
-/**
- * 特定のアクションを実行させるためのフォームフィールド名です。
- */
-export const ACTION_ID_FORM_DATA_NAME: string = "_soseki_action_id";

package/src/core/data-map.types.ts

@@ -1,28 +0,0 @@
-import type DeferredPromise from "./deferred-promise.js";
-import type { IAction, ILoader } from "./route.types.js";
-
-/**
- * 読み取り専用のデータマップを表すインターフェースです。
- *
- * ルートに関連付けられたアクションやローダーの関数をキーとし、その実行結果を値として保持します。
- *
- * @template TDataFunction アクションまたはローダーの型定義です。デフォルトは `IAction | ILoader` です。
- * @template TData 遅延評価されるプロミスの型定義です。デフォルトは `DeferredPromise<unknown>` です。
- */
-export interface IReadonlyDataMap<
-  TDataFunction extends IAction | ILoader = IAction | ILoader,
-  TData = DeferredPromise<unknown>,
-> extends ReadonlyMap<TDataFunction, TData> {}
-
-/**
- * 書き込み可能なデータマップを表すインターフェースです。
- *
- * ルートに関連付けられたアクションやローダーの関数をキーとし、その実行結果を値として保持・操作します。
- *
- * @template TDataFunction アクションまたはローダーの型定義です。デフォルトは `IAction | ILoader` です。
- * @template TData 遅延評価されるプロミスの型定義です。デフォルトは `DeferredPromise<unknown>` です。
- */
-export interface IDataMap<
-  TDataFunction extends IAction | ILoader = IAction | ILoader,
-  TData = DeferredPromise<unknown>,
-> extends Map<TDataFunction, TData> {}

package/src/core/data-store.types.ts

@@ -1,25 +0,0 @@
-import type { IDataMap } from "./data-map.types.js";
-import type { HistoryEntryId } from "./history-entry-id-schema.js";
-import type { IAction, ILoader } from "./route.types.js";
-
-/**
- * 読み取り専用のデータストアを表すインターフェースです。
- *
- * 履歴エントリーの ID をキーとし、それに関連付けられたデータマップを値として管理します。
- *
- * @template TDataFunction データマップ内で使用されるアクションまたはローダーの型定義です。
- */
-export interface IReadonlyDataStore<TDataFunction extends IAction | ILoader = IAction | ILoader>
-  extends Readonly<Map<HistoryEntryId, IDataMap<TDataFunction>>>
-{}
-
-/**
- * 書き込み可能なデータストアを表すインターフェースです。
- *
- *  履歴エントリーの ID ごとに、ルートに関連するデータの読み書きを行います。
- *
- * @template TDataFunction データマップ内で使用されるアクションまたはローダーの型定義です。
- */
-export interface IDataStore<TDataFunction extends IAction | ILoader = IAction | ILoader>
-  extends Map<HistoryEntryId, IDataMap<TDataFunction>>
-{}

package/src/core/deferred-promise.ts

@@ -1,408 +0,0 @@
-import isPromiseLike from "./_is-promise-like.js";
-
-/**
- * DeferredPromise の基本型です。
- *
- * @template T 非同期処理の結果として返される値の型です。
- */
-interface DeferredPromiseLike<T> {
-  /**
-   * Promise が解決または拒否された際のコールバックを登録します。
-   *
-   * @template TResult1 解決時コールバックの戻り値の型です。
-   * @template TResult2 拒否時コールバックの戻り値の型です。
-   * @param onfulfilled 解決時に実行されるコールバックです。
-   * @param onrejected 拒否時に実行されるコールバックです。
-   * @returns 新しい DeferredPromise インスタンスです。
-   */
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | PromiseLike<TResult1>)
-      | null
-      | undefined,
-    onrejected?:
-      | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
-      | null
-      | undefined,
-  ): DeferredPromise<TResult1 | TResult2>;
-}
-
-/**
- * 待機状態（pending）にある DeferredPromise を表すインターフェースです。
- *
- * @template T 非同期処理の結果として返される値の型です。
- */
-export interface PendingDeferredPromise<T> extends DeferredPromiseLike<T> {
-  /**
-   * 現在の状態を示します。
-   */
-  status: "pending";
-}
-
-/**
- * 完了状態（fulfilled）にある DeferredPromise を表すインターフェースです。
- *
- * @template T 非同期処理の結果として返される値の型です。
- */
-export interface FulfilledDeferredPromise<T> extends DeferredPromiseLike<T> {
-  /**
-   * 現在の状態を示します。
-   */
-  status: "fulfilled";
-
-  /**
-   * 解決された値です。
-   */
-  value: T;
-}
-
-/**
- * 拒否状態（rejected）にある DeferredPromise を表すインターフェースです。
- *
- * @template T 非同期処理の結果として期待されていた値の型です。
- */
-export interface RejectedDeferredPromise<T> extends DeferredPromiseLike<T> {
-  /**
-   * 現在の状態を示します。
-   */
-  status: "rejected";
-
-  /**
-   * 拒否された理由（エラー内容）です。
-   */
-  reason: unknown;
-}
-
-/**
- * Promise の状態を外部から同期的に参照できるようにしたクラスです。
- *
- * PromiseLike を実装しています。このクラスは主に `React.use` で使うことを想定して実装されています。
- *
- * @template T 非同期処理の結果として返される値の型です。
- */
-type DeferredPromise<T> =
-  | PendingDeferredPromise<T>
-  | FulfilledDeferredPromise<T>
-  | RejectedDeferredPromise<T>;
-
-/**
- * 外部から解決または拒否が可能な DeferredPromise のリゾルバー群を表すインターフェースです。
- *
- * @template T DeferredPromise が解決された際の値の型です。
- */
-export interface DeferredPromiseWithResolvers<T> {
-  /**
-   * 現在のステータスを持つ DeferredPromise オブジェクトです。
-   */
-  promise: DeferredPromise<T>;
-
-  /**
-   * DeferredPromise を解決（resolve）させる関数です。
-   *
-   * @param value 解決に用いる値です。
-   */
-  resolve(value: T | PromiseLike<T>): void;
-
-  /**
-   * DeferredPromise を拒否（reject）させる関数です。
-   *
-   * @param reason 拒否の理由です。
-   */
-  reject(reason?: unknown): void;
-}
-
-/**
- * DeferredPromise が取り得る状態のユニオン型です。
- */
-type DeferredPromiseState = "pending" | "fulfilled" | "rejected";
-
-/**
- * then メソッドで登録されるコールバックと、それに関連する解決・拒否関数を保持する型です。
- *
- * @template T 元の Promise が解決された際の値の型です。
- * @template TResult コールバックの実行結果として返される値の型です。
- */
-type PromiseCallback<T, TResult> = {
-  /**
-   * 後続の Promise を拒否するための関数です。
-   */
-  readonly reject: (reason?: unknown) => void;
-
-  /**
-   * 後続の Promise を解決するための関数です。
-   */
-  readonly resolve: (value: TResult) => void;
-
-  /**
-   * 拒否時に実行されるユーザー定義のコールバックです。
-   */
-  readonly onRejected:
-    | ((reason: unknown) => TResult | PromiseLike<TResult>)
-    | null
-    | undefined;
-
-  /**
-   * 解決時に実行されるユーザー定義のコールバックです。
-   */
-  readonly onFulfilled:
-    | ((value: T) => TResult | PromiseLike<TResult>)
-    | null
-    | undefined;
-};
-
-/**
- * 動的に解決された値や拒否理由を保持するためのベースクラスを生成する定数です。
- */
-const Options = (class {}) as {
-  new<T>(): {
-    /**
-     * 解決された値です。
-     */
-    value?: T;
-
-    /**
-     * 拒否された理由（エラー内容）です。
-     */
-    reason?: unknown;
-  };
-};
-
-const DeferredPromise = class DeferredPromise_<T> extends Options<T> implements PromiseLike<T> {
-  /**
-   * 指定された関数を実行し、その結果を DeferredPromise として返します。
-   * 関数が同期的に例外を投げた場合、拒否状態の Promise を返します。
-   *
-   * @template T 関数の戻り値の型です。
-   * @template TArgs 関数に渡す引数の型配列です。
-   * @param callbackFn 実行するコールバック関数です。
-   * @param args 関数に渡す引数です。
-   * @returns 実行結果をラップした DeferredPromise です。
-   */
-  public static try<T, TArgs extends unknown[]>(
-    callbackFn: (...args: TArgs) => T | PromiseLike<T>,
-    ...args: TArgs
-  ): DeferredPromise<Awaited<T>> {
-    let value;
-    try {
-      value = callbackFn(...args);
-      if (!isPromiseLike(value)) {
-        return this.resolve(value) as DeferredPromise<Awaited<T>>;
-      }
-    } catch (ex) {
-      return this.reject<T>(ex) as DeferredPromise<Awaited<T>>;
-    }
-
-    const {
-      reject,
-      resolve,
-      promise,
-    } = this.withResolvers<Awaited<T>>();
-    (async function runDeferredPromise() {
-      try {
-        resolve(await value);
-      } catch (ex) {
-        reject(ex);
-      }
-    })();
-
-    return promise as DeferredPromise<Awaited<T>>;
-  }
-
-  /**
-   * 既に拒否状態となっている DeferredPromise インスタンスを生成します。
-   *
-   * @template T DeferredPromise が期待していた値の型です。
-   * @param reason 拒否の理由です。
-   * @returns 拒否状態の DeferredPromise です。
-   */
-  public static reject<T = never>(reason?: unknown): RejectedDeferredPromise<T> {
-    const promise = new DeferredPromise_<T>();
-    promise.#reject(reason);
-
-    return promise as RejectedDeferredPromise<T>;
-  }
-
-  /**
-   * 既に解決状態となっている DeferredPromise インスタンスを生成します。
-   *
-   * @template T 解決される値の型です。
-   * @param value 解決に用いる値です。
-   * @returns 解決状態の DeferredPromise です。
-   */
-  public static resolve<T>(value: T): FulfilledDeferredPromise<T> {
-    const promise = new DeferredPromise_<T>();
-    promise.#resolve(value);
-
-    return promise as FulfilledDeferredPromise<T>;
-  }
-
-  /**
-   * DeferredPromise と、それを外部から制御するためのリゾルバー（resolve/reject）を生成します。
-   *
-   * @template T DeferredPromise が解決された際の値の型です。
-   * @returns DeferredPromise とリゾルバーを含むオブジェクトです。
-   */
-  public static withResolvers<T>(): DeferredPromiseWithResolvers<T> {
-    const promise = new DeferredPromise_<T>();
-
-    return {
-      reject(reason) {
-        promise.#reject(reason);
-      },
-      resolve(value) {
-        promise.#resolve(value);
-      },
-      // @ts-expect-error
-      promise,
-    };
-  }
-
-  /**
-   * 解決または拒否を待機しているコールバックのキューです。
-   */
-  readonly #queue: PromiseCallback<T, any>[] = [];
-
-  /**
-   * 内部的に Promise を拒否状態に遷移させます。
-   *
-   * @param reason 拒否の理由です。
-   */
-  #reject(reason?: unknown): void {
-    if (this.status !== "pending") {
-      return;
-    }
-
-    this.status = "rejected";
-    this.reason = reason;
-    this.#processQueue();
-  }
-
-  /**
-   * 内部的に Promise を解決状態に遷移させます。
-   *
-   * 引数が PromiseLike の場合は、その状態を継承します。
-   *
-   * @param value 解決に用いる値、または PromiseLike オブジェクトです。
-   */
-  #resolve(value: T | PromiseLike<T>): void {
-    if (this.status !== "pending") {
-      return;
-    }
-
-    if (!isPromiseLike(value)) {
-      // 値による解決を行います。
-      this.status = "fulfilled";
-      this.value = value;
-      this.#processQueue();
-      return;
-    }
-
-    // 受け取った値が PromiseLike だった場合、その状態を継承します。
-    try {
-      // 再帰的に待機します。
-      value.then.call(
-        value,
-        (y: T) => this.#resolve(y),
-        (r: unknown) => this.#reject(r),
-      );
-    } catch (ex) {
-      this.#reject(ex);
-    }
-  }
-
-  /**
-   * キューに積まれたコールバックを順次実行します。
-   *
-   * ステータスが確定していない場合は何もしません。
-   */
-  #processQueue(): void {
-    if (this.status === "pending") {
-      return;
-    }
-
-    // Promise の仕様に従い、マイクロタスクに入れて非同期実行を保証します。
-    queueMicrotask(() => {
-      while (this.#queue.length > 0) {
-        const callback = this.#queue.shift();
-        if (!callback) {
-          continue;
-        }
-
-        const {
-          reject,
-          resolve,
-          onRejected,
-          onFulfilled,
-        } = callback;
-        try {
-          if (this.status === "fulfilled") {
-            if (typeof onFulfilled === "function") {
-              const result = onFulfilled(this.value!);
-              resolve(result);
-            } else {
-              // コールバックがない場合は値を透過させます。
-              resolve(this.value);
-            }
-          } else if (this.status === "rejected") {
-            if (typeof onRejected === "function") {
-              const result = onRejected(this.reason);
-              resolve(result); // エラーハンドリング成功時は次の Promise は resolve されます。
-            } else {
-              // コールバックがない場合はエラーを透過させます。
-              reject(this.reason);
-            }
-          }
-        } catch (ex) {
-          // コールバック実行中にエラーが発生した場合は、後続の Promise を拒否します。
-          reject(ex);
-        }
-      }
-    });
-  }
-
-  /**
-   * 現在の Promise の状態です。
-   */
-  public status: DeferredPromiseState = "pending";
-
-  /**
-   * Promise が解決または拒否された際のコールバックを登録します。
-   *
-   * @template TResult1 解決時コールバックの戻り値の型です。
-   * @template TResult2 拒否時コールバックの戻り値の型です。
-   * @param onfulfilled 解決時に実行されるコールバックです。
-   * @param onrejected 拒否時に実行されるコールバックです。
-   * @returns 新しい DeferredPromise インスタンスです。
-   */
-  public then<TResult1 = T, TResult2 = never>(
-    onfulfilled?:
-      | ((value: T) => TResult1 | PromiseLike<TResult1>)
-      | null
-      | undefined,
-    onrejected?:
-      | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
-      | null
-      | undefined,
-  ): DeferredPromise<TResult1 | TResult2> {
-    // 新しい DeferredPromise を作成してチェーンをつなぎます。
-    const nextPromise = new DeferredPromise_<TResult1 | TResult2>();
-
-    this.#queue.push({
-      reject(reason) {
-        nextPromise.#reject(reason);
-      },
-      resolve(value) {
-        nextPromise.#resolve(value);
-      },
-      onRejected: onrejected,
-      onFulfilled: onfulfilled,
-    });
-
-    // すでに解決/拒否済みかもしれないのでキュー処理を試行します。
-    this.#processQueue();
-
-    return nextPromise as DeferredPromise<TResult1 | TResult2>;
-  }
-};
-
-export default DeferredPromise;