pi-one-ui 0.1.1

package/extensions/shell/project-refresh.ts

@@ -0,0 +1,130 @@
+export type StopProjectRefreshInterval = () => void;
+
+export type ScheduleProjectRefreshOptions = {
+  force?: boolean;
+};
+
+export type ProjectRefreshRun = {
+  isCurrent: () => boolean;
+};
+
+export type ProjectRefreshScheduler<T> = {
+  schedule: (target: T, options?: ScheduleProjectRefreshOptions) => void;
+  invalidate: () => void;
+  stop: () => void;
+};
+
+export const PROJECT_REFRESH_THROTTLE_MS = 5_000;
+
+export function startProjectRefreshInterval(
+  intervalMs: number,
+  refresh: () => void,
+): StopProjectRefreshInterval {
+  if (intervalMs <= 0) return () => {};
+
+  const timer = setInterval(refresh, intervalMs);
+  timer.unref?.();
+
+  return () => clearInterval(timer);
+}
+
+export function createProjectRefreshScheduler<T>(
+  refresh: (target: T, run: ProjectRefreshRun) => Promise<void>,
+  afterRefresh: () => void,
+  throttleMs = PROJECT_REFRESH_THROTTLE_MS,
+): ProjectRefreshScheduler<T> {
+  let refreshInFlight = false;
+  let refreshPending = false;
+  let pendingForce = false;
+  let pendingTarget: T | undefined;
+  let delayedRefresh: ReturnType<typeof setTimeout> | undefined;
+  let lastRefreshStartedAt: number | undefined;
+  let generation = 0;
+
+  const clearDelayedRefresh = () => {
+    if (!delayedRefresh) return;
+    clearTimeout(delayedRefresh);
+    delayedRefresh = undefined;
+  };
+
+  const runRefresh = (
+    target: T,
+    options: ScheduleProjectRefreshOptions = {},
+  ) => {
+    clearDelayedRefresh();
+    if (refreshInFlight) {
+      refreshPending = true;
+      pendingForce ||= options.force === true;
+      pendingTarget = target;
+      return;
+    }
+
+    const currentGeneration = generation;
+    const run: ProjectRefreshRun = {
+      isCurrent: () => currentGeneration === generation,
+    };
+    refreshInFlight = true;
+    lastRefreshStartedAt = Date.now();
+    void refresh(target, run)
+      .catch(() => undefined)
+      .finally(() => {
+        if (currentGeneration !== generation) return;
+        refreshInFlight = false;
+        afterRefresh();
+        if (refreshPending) {
+          refreshPending = false;
+          const nextForce = pendingForce;
+          pendingForce = false;
+          const nextTarget = pendingTarget ?? target;
+          pendingTarget = undefined;
+          schedule(nextTarget, { force: nextForce });
+        }
+      });
+  };
+
+  const schedule = (target: T, options: ScheduleProjectRefreshOptions = {}) => {
+    if (
+      options.force ||
+      throttleMs <= 0 ||
+      lastRefreshStartedAt === undefined
+    ) {
+      runRefresh(target, options);
+      return;
+    }
+
+    const delayMs = Math.max(
+      0,
+      throttleMs - (Date.now() - lastRefreshStartedAt),
+    );
+    if (delayMs === 0) {
+      runRefresh(target);
+      return;
+    }
+
+    pendingTarget = target;
+    if (delayedRefresh) return;
+    delayedRefresh = setTimeout(() => {
+      delayedRefresh = undefined;
+      const nextTarget = pendingTarget ?? target;
+      pendingTarget = undefined;
+      runRefresh(nextTarget);
+    }, delayMs);
+    delayedRefresh.unref?.();
+  };
+
+  const invalidate = () => {
+    generation += 1;
+    clearDelayedRefresh();
+    refreshInFlight = false;
+    refreshPending = false;
+    pendingForce = false;
+    pendingTarget = undefined;
+    lastRefreshStartedAt = undefined;
+  };
+
+  return {
+    schedule,
+    invalidate,
+    stop: invalidate,
+  };
+}

package/extensions/shell/project-state.ts

@@ -0,0 +1,60 @@
+import type { GitReadResult } from "./git.ts";
+import { emptyGitStatus } from "./git.ts";
+import type { PackageVersionReadResult } from "./package-version.ts";
+import type { RuntimeReadResult } from "./runtime.ts";
+import type { FooterState } from "./state.ts";
+
+/**
+ * Apply a project refresh (git + runtime) onto footer state, preserving
+ * last-good values on transient errors and clearing on cwd change / not-a-repo.
+ *
+ * Returns the cwd to store as `previousCwd` for the next refresh.
+ */
+export function applyProjectRefreshToState(
+  state: FooterState,
+  args: {
+    cwd: string;
+    previousCwd: string | undefined;
+    git: GitReadResult;
+    runtime: RuntimeReadResult;
+    packageVersion?: PackageVersionReadResult;
+  },
+): string {
+  const cwdChanged =
+    args.previousCwd !== undefined && args.previousCwd !== args.cwd;
+
+  if (cwdChanged) {
+    Object.assign(state, emptyGitStatus());
+    state.runtime = undefined;
+    state.packageVersion = undefined;
+  }
+
+  if (args.git.kind === "ok") {
+    Object.assign(state, args.git.status);
+  } else if (args.git.kind === "not_a_repo") {
+    Object.assign(state, emptyGitStatus());
+  }
+  // kind === "error": keep previous git fields (unless cwdChanged already cleared)
+
+  if (args.runtime.kind === "ok") {
+    state.runtime = args.runtime.runtime;
+  } else if (cwdChanged && args.runtime.kind === "error") {
+    // Already cleared above; keep undefined.
+    state.runtime = undefined;
+  }
+  // error + same cwd: keep previous runtime
+
+  if (args.packageVersion !== undefined) {
+    if (args.packageVersion.kind === "ok") {
+      // `null` means "no manifest in this cwd"; clear so the segment disappears
+      // even on the same cwd when the user removes their manifest.
+      state.packageVersion = args.packageVersion.result ?? undefined;
+    } else if (!cwdChanged) {
+      // error + same cwd: keep previous packageVersion (last-good semantics)
+    } else {
+      state.packageVersion = undefined;
+    }
+  }
+
+  return args.cwd;
+}

package/extensions/shell/prototype-patch-registry.ts

@@ -0,0 +1,183 @@
+export const ZENTUI_PROTOTYPE_PATCH_REGISTRY = Symbol.for(
+  "pi-zentui.prototype-patch-registry",
+);
+
+type PrototypePatchAdapter =
+  | "user-message-render"
+  | "user-message-invalidate"
+  | "selector-border-render";
+
+type PrototypeMethod = (this: unknown, ...args: unknown[]) => unknown;
+
+type PatchInvocation = {
+  predecessor: PrototypeMethod;
+  receiver: unknown;
+  args: unknown[];
+};
+
+type PatchBehavior = (invocation: PatchInvocation) => unknown;
+
+type Registration = {
+  token: symbol;
+  behavior?: PatchBehavior;
+};
+
+type PatchRecord = {
+  method: "render" | "invalidate";
+  predecessor: PrototypeMethod;
+  predecessorDescriptor?: PropertyDescriptor;
+  wrapper: PrototypeMethod;
+  registration?: Registration;
+};
+
+type PatchRegistry = Map<PrototypePatchAdapter, PatchRecord>;
+
+type PatchTarget = Record<PropertyKey, unknown>;
+
+function existingRegistry(target: PatchTarget): PatchRegistry | undefined {
+  const existing = target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+  return existing instanceof Map ? (existing as PatchRegistry) : undefined;
+}
+
+function registryFor(target: PatchTarget): PatchRegistry {
+  const existing = existingRegistry(target);
+  if (existing) return existing;
+  const registry: PatchRegistry = new Map();
+  Object.defineProperty(target, ZENTUI_PROTOTYPE_PATCH_REGISTRY, {
+    value: registry,
+    configurable: true,
+  });
+  return registry;
+}
+
+function deactivateRecord(record: PatchRecord): void {
+  if (!record.registration) return;
+  record.registration.behavior = undefined;
+  record.registration = undefined;
+}
+
+function restorePredecessor(target: PatchTarget, record: PatchRecord): void {
+  if (target[record.method] !== record.wrapper) return;
+  if (record.predecessorDescriptor) {
+    Object.defineProperty(target, record.method, record.predecessorDescriptor);
+  } else {
+    delete target[record.method];
+  }
+}
+
+function installWrapper(target: PatchTarget, record: PatchRecord): void {
+  const descriptor = record.predecessorDescriptor;
+  if (descriptor && "value" in descriptor) {
+    Object.defineProperty(target, record.method, {
+      ...descriptor,
+      value: record.wrapper,
+    });
+    return;
+  }
+  Object.defineProperty(target, record.method, {
+    value: record.wrapper,
+    writable: true,
+    enumerable: descriptor?.enumerable ?? true,
+    configurable: true,
+  });
+}
+
+function createCleanup(
+  target: PatchTarget,
+  adapter: PrototypePatchAdapter,
+  registry: PatchRegistry,
+  record: PatchRecord,
+  token: symbol,
+): () => void {
+  let cleaned = false;
+  return () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (record.registration?.token !== token) return;
+    deactivateRecord(record);
+
+    const current = registry.get(adapter);
+    if (current !== record) return;
+    restorePredecessor(target, record);
+    registry.delete(adapter);
+    if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+  };
+}
+
+export function installPrototypePatch(
+  targetValue: object,
+  method: "render" | "invalidate",
+  adapter: PrototypePatchAdapter,
+  behavior: PatchBehavior,
+): () => void {
+  const target = targetValue as PatchTarget;
+  const registry = registryFor(target);
+  let record = registry.get(adapter);
+
+  if (
+    !(record && record.method === method && target[method] === record.wrapper)
+  ) {
+    const displacedRecord = record;
+    const predecessorDescriptor = Object.getOwnPropertyDescriptor(
+      target,
+      method,
+    );
+    const predecessor = target[method];
+    if (typeof predecessor !== "function") {
+      if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+      throw new TypeError(
+        `Cannot patch ${method}: predecessor is not a function`,
+      );
+    }
+    const nextRecord: PatchRecord = {
+      method,
+      predecessor: predecessor as PrototypeMethod,
+      predecessorDescriptor,
+      wrapper: () => undefined,
+    };
+    const wrapper: PrototypeMethod = function zentuiPrototypeWrapper(
+      this: unknown,
+      ...args: unknown[]
+    ): unknown {
+      const activeBehavior = nextRecord.registration?.behavior;
+      return activeBehavior
+        ? activeBehavior({
+            predecessor: nextRecord.predecessor,
+            receiver: this,
+            args,
+          })
+        : Reflect.apply(nextRecord.predecessor, this, args);
+    };
+    nextRecord.wrapper = wrapper;
+    try {
+      installWrapper(target, nextRecord);
+    } catch (error) {
+      if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+      throw error;
+    }
+    record = nextRecord;
+    registry.set(adapter, record);
+    if (displacedRecord && displacedRecord !== record)
+      deactivateRecord(displacedRecord);
+  }
+
+  const token = Symbol(adapter);
+  record.registration = { token, behavior };
+  return createCleanup(target, adapter, registry, record, token);
+}
+
+export function removePrototypePatch(
+  targetValue: object,
+  method: "render" | "invalidate",
+  adapter: PrototypePatchAdapter,
+): void {
+  const target = targetValue as PatchTarget;
+  const registry = existingRegistry(target);
+  const record = registry?.get(adapter);
+  if (!registry || !record || record.method !== method) return;
+
+  deactivateRecord(record);
+  restorePredecessor(target, record);
+  registry.delete(adapter);
+  if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+}