Julius MarmingeT3 Code Mobile [WIP] (#2013)b3e8c035 months agoHistory
339 lines · 9.4 KB · TypeScript
RawDownload
import type { FilesystemBrowseInput, FilesystemBrowseResult } from "@t3tools/contracts";import * as Effect from "effect/Effect";import { Atom, type AtomRegistry } from "effect/unstable/reactivity"; export interface FilesystemBrowseState {  readonly data: FilesystemBrowseResult | null;  readonly error: string | null;  readonly isPending: boolean;} export interface FilesystemBrowseTarget<TKey extends string = string> {  readonly key: TKey | null;  readonly input: FilesystemBrowseInput | null;} export interface FilesystemBrowseClient {  readonly browse: (input: FilesystemBrowseInput) => Promise<FilesystemBrowseResult>;} interface WatchedEntry {  refCount: number;  teardown: () => void;} export const EMPTY_FILESYSTEM_BROWSE_STATE = Object.freeze<FilesystemBrowseState>({  data: null,  error: null,  isPending: false,}); const INITIAL_FILESYSTEM_BROWSE_STATE = Object.freeze<FilesystemBrowseState>({  data: null,  error: null,  isPending: true,}); const knownFilesystemBrowseKeys = new Set<string>(); export const filesystemBrowseStateAtom = Atom.family((targetKey: string) => {  knownFilesystemBrowseKeys.add(targetKey);  return Atom.make(INITIAL_FILESYSTEM_BROWSE_STATE).pipe(    Atom.keepAlive,    Atom.withLabel(`filesystem-browse:${targetKey}`),  );}); export const EMPTY_FILESYSTEM_BROWSE_ATOM = Atom.make(EMPTY_FILESYSTEM_BROWSE_STATE).pipe(  Atom.keepAlive,  Atom.withLabel("filesystem-browse:null"),); const NOOP: () => void = () => undefined;const DEFAULT_STALE_TIME_MS = 30_000;const DEFAULT_IDLE_TTL_MS = 5 * 60_000; export function getFilesystemBrowseTargetKey<TKey extends string>(  target: FilesystemBrowseTarget<TKey>,): string | null {  const key = target.key;  const input = target.input;  if (!key || !input || input.partialPath.length === 0) {    return null;  }   return JSON.stringify([key, input.cwd ?? null, input.partialPath]);} export interface FilesystemBrowseManagerConfig<TKey extends string = string> {  readonly getRegistry: () => AtomRegistry.AtomRegistry;  readonly getClient: (key: TKey) => FilesystemBrowseClient | null;  readonly subscribeClientChanges?: (listener: () => void) => () => void;  readonly staleTimeMs?: number;  readonly idleTtlMs?: number;} export function createFilesystemBrowseManager<TKey extends string = string>(  config: FilesystemBrowseManagerConfig<TKey>,) {  const refreshInFlight = new Map<    string,    {      readonly client: FilesystemBrowseClient;      readonly promise: Promise<FilesystemBrowseResult | null>;    }  >();  const refreshVersions = new Map<string, number>();  const watched = new Map<string, WatchedEntry>();  const refreshTargets = new Map<string, FilesystemBrowseTarget<TKey>>();  const staleTimeMs = config.staleTimeMs ?? DEFAULT_STALE_TIME_MS;  const idleTtlMs = config.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;   const watchedRefreshAtom = Atom.family((targetKey: string) =>    Atom.make(() =>      Effect.promise(() => {        const target = refreshTargets.get(targetKey);        return target ? refresh(target) : Promise.resolve(null);      }),    ).pipe(      Atom.swr({        staleTime: staleTimeMs,        revalidateOnMount: true,      }),      Atom.setIdleTTL(idleTtlMs),      Atom.withLabel(`filesystem-browse:watched-refresh:${targetKey}`),    ),  );   function getRefreshVersion(targetKey: string): number {    return refreshVersions.get(targetKey) ?? 0;  }   function bumpRefreshVersion(targetKey: string): void {    refreshVersions.set(targetKey, getRefreshVersion(targetKey) + 1);  }   function setState(targetKey: string, nextState: FilesystemBrowseState): void {    config.getRegistry().set(filesystemBrowseStateAtom(targetKey), nextState);  }   function markPending(targetKey: string): void {    const current = config.getRegistry().get(filesystemBrowseStateAtom(targetKey));    const next: FilesystemBrowseState =      current.data === null        ? INITIAL_FILESYSTEM_BROWSE_STATE        : {            data: current.data,            error: null,            isPending: true,          };     if (      current.data === next.data &&      current.error === next.error &&      current.isPending === next.isPending    ) {      return;    }     setState(targetKey, next);  }   function setData(targetKey: string, data: FilesystemBrowseResult): void {    setState(targetKey, {      data,      error: null,      isPending: false,    });  }   function setError(targetKey: string, error: unknown): void {    const current = config.getRegistry().get(filesystemBrowseStateAtom(targetKey));    setState(targetKey, {      data: current.data,      error: error instanceof Error ? error.message : "Failed to browse folder.",      isPending: false,    });  }   function refresh(    target: FilesystemBrowseTarget<TKey>,    client?: FilesystemBrowseClient,  ): Promise<FilesystemBrowseResult | null> {    const targetKey = getFilesystemBrowseTargetKey(target);    if (targetKey === null || target.key === null || target.input === null) {      return Promise.resolve(null);    }    refreshTargets.set(targetKey, target);     const resolvedClient = client ?? config.getClient(target.key);    if (!resolvedClient) {      setError(targetKey, new Error("Filesystem browser client is unavailable."));      return Promise.resolve(getSnapshot(target).data);    }     const existing = refreshInFlight.get(targetKey);    if (existing) {      if (!client || existing.client === resolvedClient) {        return existing.promise;      }      return existing.promise.then(() => refresh(target, resolvedClient));    }     markPending(targetKey);    const refreshVersion = getRefreshVersion(targetKey);    const promise = resolvedClient.browse(target.input).then(      (result) => {        if (getRefreshVersion(targetKey) === refreshVersion) {          setData(targetKey, result);        }        return result;      },      (error: unknown) => {        if (getRefreshVersion(targetKey) === refreshVersion) {          setError(targetKey, error);        }        return getSnapshot(target).data;      },    );     let tracked: Promise<FilesystemBrowseResult | null>;    tracked = promise.finally(() => {      if (refreshInFlight.get(targetKey)?.promise === tracked) {        refreshInFlight.delete(targetKey);      }    });    refreshInFlight.set(targetKey, {      client: resolvedClient,      promise: tracked,    });    return tracked;  }   function invalidate(target?: FilesystemBrowseTarget<TKey>): void {    if (!target) {      reset();      return;    }     const targetKey = getFilesystemBrowseTargetKey(target);    if (targetKey === null) {      return;    }     bumpRefreshVersion(targetKey);    refreshInFlight.delete(targetKey);    setState(targetKey, INITIAL_FILESYSTEM_BROWSE_STATE);  }   function getSnapshot(target: FilesystemBrowseTarget<TKey>): FilesystemBrowseState {    const targetKey = getFilesystemBrowseTargetKey(target);    if (targetKey === null) {      return EMPTY_FILESYSTEM_BROWSE_STATE;    }     return config.getRegistry().get(filesystemBrowseStateAtom(targetKey));  }   function watch(    target: FilesystemBrowseTarget<TKey>,    client?: FilesystemBrowseClient,  ): () => void {    const targetKey = getFilesystemBrowseTargetKey(target);    if (targetKey === null || target.key === null) {      return NOOP;    }    refreshTargets.set(targetKey, target);     const existing = watched.get(targetKey);    if (existing) {      existing.refCount += 1;      return () => unwatch(targetKey);    }     let teardown: () => void;     if (client) {      void refresh(target, client);      teardown = NOOP;    } else if (config.subscribeClientChanges) {      let currentClient: FilesystemBrowseClient | null = null;       const sync = () => {        const resolved = config.getClient(target.key!);        if (!resolved) {          currentClient = null;          markPending(targetKey);          return;        }         if (currentClient === resolved) {          return;        }         const isClientReplacement = currentClient !== null;        currentClient = resolved;        refreshWatchedTarget(targetKey, target, isClientReplacement ? resolved : undefined);      };       const unsubChanges = config.subscribeClientChanges(sync);      sync();      teardown = unsubChanges;    } else {      if (!config.getClient(target.key)) {        return NOOP;      }      refreshWatchedTarget(targetKey, target);      teardown = NOOP;    }     watched.set(targetKey, { refCount: 1, teardown });    return () => unwatch(targetKey);  }   function unwatch(targetKey: string): void {    const entry = watched.get(targetKey);    if (!entry) {      return;    }     entry.refCount -= 1;    if (entry.refCount > 0) {      return;    }     entry.teardown();    watched.delete(targetKey);  }   function refreshWatchedTarget(    targetKey: string,    target: FilesystemBrowseTarget<TKey>,    client?: FilesystemBrowseClient,  ): void {    refreshTargets.set(targetKey, target);    const registry = config.getRegistry();    void registry.get(watchedRefreshAtom(targetKey));    if (client) {      void refresh(target, client);    }  }   function reset(): void {    refreshInFlight.clear();    watched.clear();    refreshTargets.clear();    for (const targetKey of knownFilesystemBrowseKeys) {      bumpRefreshVersion(targetKey);      setState(targetKey, INITIAL_FILESYSTEM_BROWSE_STATE);    }  }   return {    refresh,    invalidate,    getSnapshot,    watch,    reset,  };}