@fluid-app/fluid-cli-theme-dev 0.1.15 → 0.1.17

package/src/plugin-state.ts

@@ -1,26 +1,171 @@
+import { existsSync } from "node:fs";
 import { readConfig, updateConfig } from "@fluid-app/fluid-cli";
 
+export interface DevThemeRef {
+  id: number;
+  name: string;
+}
+
 interface ThemeDevState {
+  /**
+   * Dev themes keyed per project, so `theme dev` in one working copy never
+   * reuses (and clobbers) another project's sandbox theme. See `devThemeKey`.
+   * Entries are pruned once their theme directory no longer exists, so the map
+   * can't grow without bound as projects (and one-off/temp dirs) come and go.
+   */
+  devThemes?: Record<string, DevThemeRef>;
+  /** Most recently started dev theme — `navigate`'s default target. */
+  lastDevThemeId?: number;
+  /**
+   * Legacy single global dev theme id. Older CLI versions stored one dev theme
+   * here regardless of project. Read once for migration (see `getDevTheme`),
+   * then dropped in favour of `devThemes`.
+   */
   devThemeId?: number;
+  /** Legacy companion to `devThemeId`. */
   devThemeName?: string;
 }
 
 const PLUGIN_KEY = "theme-dev";
 
-export function getPluginState(): ThemeDevState {
+function getState(): ThemeDevState {
   const config = readConfig();
   return (config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {};
 }
 
-export function setPluginState(updates: Partial<ThemeDevState>): void {
-  updateConfig((config) => ({
-    ...config,
-    plugins: {
-      ...config.plugins,
-      [PLUGIN_KEY]: {
-        ...((config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {}),
-        ...updates,
+/** Extract the absolute theme root from a `company:themeRoot` key. */
+function themeRootFromKey(key: string): string {
+  const sep = key.indexOf(":");
+  return sep === -1 ? key : key.slice(sep + 1);
+}
+
+/**
+ * Set `key` to `theme`, dropping any entries whose theme directory no longer
+ * exists. Tying an entry's lifetime to its directory keeps the map bounded —
+ * abandoned/deleted projects fall out the next time `theme dev` runs anywhere.
+ */
+function withDevTheme(
+  existing: Record<string, DevThemeRef> | undefined,
+  key: string,
+  theme: DevThemeRef,
+): Record<string, DevThemeRef> {
+  const next: Record<string, DevThemeRef> = {};
+  for (const [k, v] of Object.entries(existing ?? {})) {
+    if (existsSync(themeRootFromKey(k))) next[k] = v;
+  }
+  next[key] = theme;
+  return next;
+}
+
+/**
+ * Stable key identifying a dev theme's owning project: the Fluid company
+ * (subdomains are globally unique) plus the absolute theme root. Two working
+ * copies — or the same copy pulled from two companies — get distinct keys.
+ */
+export function devThemeKey(
+  company: string | undefined,
+  themeRoot: string,
+): string {
+  return `${company ?? "default"}:${themeRoot}`;
+}
+
+/**
+ * The dev theme stored for a project key, if any. Falls back once to the legacy
+ * global `devThemeId` (older CLI versions) and adopts it for this key — clearing
+ * the legacy fields so a second project can't adopt the same theme and collide.
+ */
+export function getDevTheme(key: string): DevThemeRef | undefined {
+  const state = getState();
+  const existing = state.devThemes?.[key];
+  if (existing) return existing;
+
+  if (state.devThemeId) {
+    const migrated: DevThemeRef = {
+      id: state.devThemeId,
+      name: state.devThemeName ?? `Development #${state.devThemeId}`,
+    };
+    updateConfig((config) => {
+      const current = (config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {};
+      const { devThemeId: _id, devThemeName: _name, ...rest } = current;
+      return {
+        ...config,
+        plugins: {
+          ...config.plugins,
+          [PLUGIN_KEY]: {
+            ...rest,
+            devThemes: withDevTheme(rest.devThemes, key, migrated),
+            lastDevThemeId: migrated.id,
+          },
+        },
+      };
+    });
+    return migrated;
+  }
+
+  return undefined;
+}
+
+/** Store (or refresh) the dev theme for a project key and mark it most-recent. */
+export function setDevTheme(key: string, theme: DevThemeRef): void {
+  updateConfig((config) => {
+    const current = (config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {};
+    return {
+      ...config,
+      plugins: {
+        ...config.plugins,
+        [PLUGIN_KEY]: {
+          ...current,
+          devThemes: withDevTheme(current.devThemes, key, theme),
+          lastDevThemeId: theme.id,
+        },
       },
-    },
-  }));
+    };
+  });
+}
+
+/** Forget a project's dev theme (it was deleted remotely or is no longer a dev theme). */
+export function clearDevTheme(key: string): void {
+  updateConfig((config) => {
+    const current = (config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {};
+    const removed = current.devThemes?.[key];
+    if (!removed) return config;
+    const { [key]: _removed, ...rest } = current.devThemes ?? {};
+    const next: ThemeDevState = { ...current, devThemes: rest };
+    // Don't leave `navigate` pointing at a theme we just forgot.
+    if (current.lastDevThemeId === removed.id) {
+      next.lastDevThemeId = undefined;
+    }
+    return {
+      ...config,
+      plugins: { ...config.plugins, [PLUGIN_KEY]: next },
+    };
+  });
+}
+
+/**
+ * Mark a theme as the most recently started dev server (`navigate`'s default)
+ * without recording it as a project's dev theme — used for the `--theme`
+ * escape hatch, which may target an arbitrary (non-dev) theme.
+ */
+export function setLastDevThemeId(id: number): void {
+  updateConfig((config) => {
+    const current = (config.plugins[PLUGIN_KEY] as ThemeDevState) ?? {};
+    return {
+      ...config,
+      plugins: {
+        ...config.plugins,
+        [PLUGIN_KEY]: { ...current, lastDevThemeId: id },
+      },
+    };
+  });
+}
+
+/**
+ * The dev theme to target by default in `navigate` — the most recently started
+ * dev server. Falls back to the legacy global id for users who haven't yet run
+ * the per-project `theme dev`.
+ */
+export function getLastDevThemeId(): number | undefined {
+  const state = getState();
+  return state.lastDevThemeId ?? state.devThemeId;
 }