@pstdio/workbench 0.4.0 → 0.5.0

package/dist/storage.d.ts

@@ -1,5 +1,7 @@
 declare type ContributionSource = "module" | "extension";
 
+declare type ContributionSource_2 = "module" | "extension";
+
 export declare const createLocalStorageHistoryPersistence: (input: CreateWorkbenchStoragePersistenceInput) => WorkbenchHistoryPersistence;
 
 export declare const createLocalStorageLastResourcePersistence: (input: CreateLocalStorageLastResourcePersistenceInput) => LastResourcePersistenceAdapter;
@@ -25,10 +27,11 @@ export declare interface CreateLocalStorageTreePersistenceInput extends CreateWo
 export declare const createLocalStorageWorkbenchPersistence: (input: CreateLocalStorageWorkbenchPersistenceInput) => {
     snapshotPersistence: WorkbenchPersistenceAdapter;
     historyPersistence: WorkbenchHistoryPersistence;
-    layoutPersistence: LayoutPersistenceAdapter;
+    layoutPersistence: LayoutPersistenceAdapter_2;
     panelsPersistence: WorkbenchPanelsPersistenceAdapter;
     treePersistence: TreeRendererPersistenceAdapter;
     lastResourcePersistence: LastResourcePersistenceAdapter;
+    sidePanelPersistence: WorkbenchSidePanelPersistenceAdapter;
 };
 
 export declare interface CreateLocalStorageWorkbenchPersistenceInput extends CreateWorkbenchStoragePersistenceInput {
@@ -60,12 +63,31 @@ declare interface LastResourcePersistenceAdapter {
 declare interface LayoutPersistenceAdapter {
     getLayout(scope?: LayoutScope): WorkbenchLayout | undefined;
     setLayout(layout: WorkbenchLayout, scope?: LayoutScope): void;
+    listScopes?(projectId: string): LayoutScope[];
+    transformLayouts?(projectId: string, transform: (layout: WorkbenchLayout, scope: LayoutScope) => WorkbenchLayout | undefined): void;
+    getCompatibilityMarker?(key: string): string | undefined;
+    setCompatibilityMarker?(key: string, value: string): void;
+    advanceWriteGeneration?(): number;
+    flush?(): void;
+    dispose?(): void;
+}
+
+declare interface LayoutPersistenceAdapter_2 {
+    getLayout(scope?: LayoutScope_2): WorkbenchLayout_2 | undefined;
+    setLayout(layout: WorkbenchLayout_2, scope?: LayoutScope_2): void;
+    listScopes?(projectId: string): LayoutScope_2[];
+    transformLayouts?(projectId: string, transform: (layout: WorkbenchLayout_2, scope: LayoutScope_2) => WorkbenchLayout_2 | undefined): void;
+    getCompatibilityMarker?(key: string): string | undefined;
+    setCompatibilityMarker?(key: string, value: string): void;
+    advanceWriteGeneration?(): number;
     flush?(): void;
     dispose?(): void;
 }
 
 declare type LayoutScope = string;
 
+declare type LayoutScope_2 = string;
+
 declare interface PersistedTreeRendererStates {
     statesByTreeId: Record<string, TreeRendererState>;
 }
@@ -87,6 +109,15 @@ declare interface ResourceRef {
     metadata?: Record<string, unknown>;
 }
 
+declare interface ResourceRef_2 {
+    kind: string;
+    uri: string;
+    id?: string;
+    label?: string;
+    icon?: string;
+    metadata?: Record<string, unknown>;
+}
+
 declare interface TreeRendererPersistenceAdapter {
     getTreeStates(): PersistedTreeRendererStates | undefined;
     setTreeStates(states: PersistedTreeRendererStates): void;
@@ -101,6 +132,8 @@ declare interface TreeRendererState {
 
 declare type WidgetMountStrategy = "active" | "keep-mounted";
 
+declare type WidgetMountStrategy_2 = "active" | "keep-mounted";
+
 declare interface WorkbenchClosedSubPanel {
     region: WorkbenchPanelRegion;
     reference: WorkbenchSubPanelRef;
@@ -121,6 +154,14 @@ declare interface WorkbenchLayout {
     activeResourceUri?: string;
 }
 
+declare interface WorkbenchLayout_2 {
+    regions: Record<WorkbenchRegion_2, WorkbenchRegionState_2>;
+    locationSubPanelSelections?: Record<string, Partial<Record<WorkbenchPanelRegion_2, string>>>;
+    activeWidgetId?: string;
+    activeLocationWidgetId?: string;
+    activeResourceUri?: string;
+}
+
 declare interface WorkbenchLocationRef {
     key: string;
     modeId?: string;
@@ -146,8 +187,12 @@ declare interface WorkbenchNavigationEntry {
 
 declare type WorkbenchPanelRegion = (typeof workbenchPanelRegions)[number];
 
+declare type WorkbenchPanelRegion_2 = (typeof workbenchPanelRegions_2)[number];
+
 declare const workbenchPanelRegions: readonly ["main", "secondary", "side"];
 
+declare const workbenchPanelRegions_2: readonly ["main", "secondary", "side"];
+
 declare interface WorkbenchPanelsPersistenceAdapter {
     getPanelStates(scope?: string): PersistedWorkbenchPanels | undefined;
     setPanelStates(state: PersistedWorkbenchPanels, scope?: string): void;
@@ -162,8 +207,12 @@ declare interface WorkbenchPersistenceAdapter {
 
 declare type WorkbenchRegion = (typeof workbenchRegions)[number];
 
+declare type WorkbenchRegion_2 = (typeof workbenchRegions_2)[number];
+
 declare const workbenchRegions: readonly ["nav", "activity", "sidenav-header", "sidenav", "main-header", "main-left-menu", "main", "main-right-menu", "secondary-header", "secondary-left-menu", "secondary", "secondary-right-menu", "side-header", "side-left-menu", "side", "side-right-menu", "status", "overlay"];
 
+declare const workbenchRegions_2: readonly ["nav", "activity", "sidenav-header", "sidenav", "main-header", "main-left-menu", "main", "main-right-menu", "secondary-header", "secondary-left-menu", "secondary", "secondary-right-menu", "side-header", "side-left-menu", "side", "side-right-menu", "status", "overlay"];
+
 declare interface WorkbenchRegionState {
     id: WorkbenchRegion;
     visible: boolean;
@@ -172,19 +221,36 @@ declare interface WorkbenchRegionState {
     activeWidgetId?: string;
 }
 
+declare interface WorkbenchRegionState_2 {
+    id: WorkbenchRegion_2;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement_2[];
+    activeWidgetId?: string;
+}
+
+declare type WorkbenchSidePanelMode = "floating" | "closed" | "attached";
+
+declare interface WorkbenchSidePanelPersistenceAdapter {
+    getMode(): WorkbenchSidePanelMode | undefined;
+    setMode(mode: WorkbenchSidePanelMode): void;
+}
+
 declare interface WorkbenchSnapshot {
     layout: WorkbenchLayout;
 }
 
 export declare interface WorkbenchStorageLike {
+    readonly length?: number;
     getItem(key: string): string | null;
+    key?(index: number): string | null;
     setItem(key: string, value: string): void;
     removeItem?(key: string): void;
 }
 
 export declare const workbenchStoragePersistenceKey: (namespace: string, kind: WorkbenchStoragePersistenceKind, scope: string | undefined) => string;
 
-export declare type WorkbenchStoragePersistenceKind = "history" | "layout" | "layout-resource-index" | "panels" | "tree" | "last-resource";
+export declare type WorkbenchStoragePersistenceKind = "history" | "layout" | "layout-compatibility" | "layout-generation" | "layout-resource-index" | "layout-scope-index" | "panels" | "side-panel" | "tree" | "last-resource";
 
 declare interface WorkbenchSubPanelRef {
     contributionId: string;
@@ -194,6 +260,8 @@ declare interface WorkbenchSubPanelRef {
 
 declare type WorkbenchTabRetention = "preview" | "persistent";
 
+declare type WorkbenchTabRetention_2 = "preview" | "persistent";
+
 declare interface WorkbenchWidgetPlacement {
     widgetId: string;
     contributionId: string;
@@ -212,12 +280,38 @@ declare interface WorkbenchWidgetPlacement {
     role?: WorkbenchWidgetRole;
 }
 
+declare interface WorkbenchWidgetPlacement_2 {
+    widgetId: string;
+    contributionId: string;
+    ownerId?: string;
+    source?: ContributionSource_2;
+    resource?: ResourceRef_2;
+    resourceUri?: string;
+    ownerResourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy_2;
+    hiddenByDefault?: boolean;
+    tabRetention?: WorkbenchTabRetention_2;
+    tab?: WorkbenchWidgetTab_2;
+    role?: WorkbenchWidgetRole_2;
+}
+
 declare type WorkbenchWidgetRole = "content" | "location" | "sub-panel" | "panel-menu";
 
+declare type WorkbenchWidgetRole_2 = "content" | "location" | "sub-panel" | "panel-menu";
+
 declare interface WorkbenchWidgetTab {
     contentRendererId?: string;
     /** Custom actions shown when the user activates an already-active tab. */
     customMenuRendererId?: string;
 }
 
+declare interface WorkbenchWidgetTab_2 {
+    contentRendererId?: string;
+    /** Custom actions shown when the user activates an already-active tab. */
+    customMenuRendererId?: string;
+}
+
 export { }

package/dist/storage.js

@@ -1,182 +1,263 @@
-import { b as E } from "./layout-types-DMoZz38-.js";
-const S = 2, P = 1, b = 50, r = (e, s, t) => `${e}:${s}:${t ?? "global"}`, N = () => {
+import { b as j } from "./layout-types-DMoZz38-.js";
+const c = (e, t, o) => `${e}:${t}:${o ?? "global"}`, B = () => {
   const e = /* @__PURE__ */ new Map();
   return {
-    getItem: (s) => e.get(s) ?? null,
-    setItem: (s, t) => {
-      e.set(s, t);
+    get length() {
+      return e.size;
     },
-    removeItem: (s) => {
-      e.delete(s);
+    getItem: (t) => e.get(t) ?? null,
+    key: (t) => [...e.keys()][t] ?? null,
+    setItem: (t, o) => {
+      e.set(t, o);
+    },
+    removeItem: (t) => {
+      e.delete(t);
     }
   };
-}, d = (e) => e || (typeof localStorage < "u" ? localStorage : N()), p = (e, s) => {
-  const t = e.getItem(s);
-  if (t)
+}, p = (e) => e || (typeof localStorage < "u" ? localStorage : B()), m = (e, t) => {
+  const o = e.getItem(t);
+  if (o)
     try {
-      return JSON.parse(t);
+      return JSON.parse(o);
     } catch {
       return;
     }
-}, T = (e) => {
-  const s = d(e.storage), t = /* @__PURE__ */ new Map(), a = e.debounceMs ?? 250, m = e.eventTarget ?? (typeof window < "u" ? {
-    addEventListener: (n, o) => window.addEventListener(n, o),
-    removeEventListener: (n, o) => window.removeEventListener(n, o)
+}, v = 2, k = 1, W = 50, C = (e) => {
+  const t = p(e.storage), o = /* @__PURE__ */ new Map(), i = e.debounceMs ?? 250, d = e.eventTarget ?? (typeof window < "u" ? {
+    addEventListener: (s, r) => window.addEventListener(s, r),
+    removeEventListener: (s, r) => window.removeEventListener(s, r)
   } : void 0);
-  let l;
-  const R = (n) => n?.match(/^project\/([^/]+)\/mode\/[^/]+\/resource\//)?.[1], O = (n) => {
-    const o = R(n);
-    if (!o || !n) return;
-    const y = r(e.namespace, "layout-resource-index", o), c = p(s, y), i = typeof c == "object" && c !== null && "version" in c && c.version === P && "scopes" in c && Array.isArray(c.scopes) ? c.scopes.filter((g) => typeof g == "string" && g !== n && s.getItem(r(e.namespace, "layout", g)) !== null) : [];
-    i.push(n);
-    for (const g of i.splice(0, Math.max(0, i.length - b)))
-      s.removeItem?.(r(e.namespace, "layout", g)), s.removeItem?.(r(e.namespace, "panels", g));
-    const v = {
-      version: P,
-      scopes: i
+  let y;
+  const L = c(e.namespace, "layout-generation", void 0), f = () => {
+    const s = m(t, L);
+    return typeof s == "object" && s !== null && "version" in s && s.version === 1 && "generation" in s && typeof s.generation == "number" ? s.generation : 0;
+  }, P = () => {
+    const s = f() + 1, r = {
+      version: 1,
+      generation: s
+    };
+    return t.setItem(L, JSON.stringify(r)), s;
+  }, J = (s) => s?.match(/^project\/([^/]+)\/mode\/[^/]+\/resource\//)?.[1], O = (s) => s?.match(/^project\/([^/]+)/)?.[1], M = (s) => {
+    if (!t.key) return [];
+    const r = `${e.namespace}:layout:`, n = [];
+    for (let a = 0; a < (t.length ?? 0); a += 1) {
+      const l = t.key(a);
+      if (!l?.startsWith(r)) continue;
+      const g = l.slice(r.length);
+      O(g) === s && n.push(g);
+    }
+    return n;
+  }, S = (s, r) => {
+    const n = m(t, c(e.namespace, s, r));
+    return typeof n == "object" && n !== null && "version" in n && n.version === k && "scopes" in n && Array.isArray(n.scopes) ? n.scopes.filter((a) => typeof a == "string" && t.getItem(c(e.namespace, "layout", a)) !== null) : [];
+  }, N = (s, r, n) => {
+    const a = {
+      version: k,
+      scopes: n
     };
-    s.setItem(y, JSON.stringify(v));
-  }, f = () => {
-    l && clearTimeout(l), l = void 0;
-    const n = [...t.values()];
-    t.clear();
-    for (const o of n)
-      s.setItem(r(e.namespace, "layout", o.scope), o.raw), O(o.scope), o.legacyPanelsKey && s.removeItem?.(o.legacyPanelsKey);
-  }, I = () => {
-    l && clearTimeout(l), l = setTimeout(f, a);
+    t.setItem(c(e.namespace, s, r), JSON.stringify(a));
+  }, T = (s) => {
+    const r = O(s);
+    if (!r || !s) return;
+    const n = S("layout-scope-index", r).filter((a) => a !== s);
+    n.push(s), N("layout-scope-index", r, n);
+  }, K = (s) => {
+    const r = J(s);
+    if (!r || !s) return;
+    const n = S("layout-resource-index", r).filter((a) => a !== s);
+    n.push(s);
+    for (const a of n.splice(0, Math.max(0, n.length - W)))
+      t.removeItem?.(c(e.namespace, "layout", a)), t.removeItem?.(c(e.namespace, "panels", a));
+    N("layout-resource-index", r, n);
+  }, u = () => {
+    y && clearTimeout(y), y = void 0;
+    const s = [...o.values()];
+    o.clear();
+    const r = f();
+    for (const n of s)
+      n.generation === r && (t.setItem(c(e.namespace, "layout", n.scope), n.raw), T(n.scope), K(n.scope), n.legacyPanelsKey && t.removeItem?.(n.legacyPanelsKey));
+  }, R = () => {
+    y && clearTimeout(y), y = setTimeout(u, i);
   };
-  return m?.addEventListener("pagehide", f), {
-    getLayout: (n) => {
-      const o = r(e.namespace, "layout", n), y = t.has(o) ? JSON.parse(t.get(o).raw) : p(s, o);
-      if (y?.version === S) return y.layout;
-      if (y?.version !== 1) return;
-      const c = r(e.namespace, "panels", n), i = p(s, c), v = typeof i == "object" && i !== null && "openByRegionId" in i && typeof i.openByRegionId == "object" && i.openByRegionId !== null ? i.openByRegionId : {}, g = {
-        ...y.layout.regions
+  return d?.addEventListener("pagehide", u), {
+    getLayout: (s) => {
+      const r = c(e.namespace, "layout", s), n = o.get(r), a = n && n.generation === f() ? JSON.parse(n.raw) : m(t, r);
+      if (a?.version === v) return a.layout;
+      if (a?.version !== 1) return;
+      const l = c(e.namespace, "panels", s), g = m(t, l), x = typeof g == "object" && g !== null && "openByRegionId" in g && typeof g.openByRegionId == "object" && g.openByRegionId !== null ? g.openByRegionId : {}, I = {
+        ...a.layout.regions
       };
-      for (const u of E) {
-        const L = v[u];
-        typeof L == "boolean" && g[u] && (g[u] = {
-          ...g[u],
-          visible: L
+      for (const h of j) {
+        const w = x[h];
+        typeof w == "boolean" && I[h] && (I[h] = {
+          ...I[h],
+          visible: w
         });
       }
-      const h = {
-        ...y.layout,
-        regions: g
-      }, w = {
-        version: S,
-        layout: h
+      const b = {
+        ...a.layout,
+        regions: I
+      }, _ = {
+        version: v,
+        layout: b
       };
-      return t.set(o, {
-        legacyPanelsKey: s.getItem(c) === null ? void 0 : c,
-        raw: JSON.stringify(w),
-        scope: n
-      }), I(), h;
+      return o.set(r, {
+        generation: f(),
+        legacyPanelsKey: t.getItem(l) === null ? void 0 : l,
+        raw: JSON.stringify(_),
+        scope: s
+      }), R(), b;
+    },
+    setLayout: (s, r) => {
+      const n = {
+        version: v,
+        layout: s
+      }, a = c(e.namespace, "layout", r), l = c(e.namespace, "panels", r);
+      o.delete(a), o.set(a, {
+        generation: f(),
+        legacyPanelsKey: t.getItem(l) === null ? void 0 : l,
+        raw: JSON.stringify(n),
+        scope: r
+      }), R();
     },
-    setLayout: (n, o) => {
-      const y = {
-        version: S,
-        layout: n
-      }, c = r(e.namespace, "layout", o), i = r(e.namespace, "panels", o);
-      t.delete(c), t.set(c, {
-        legacyPanelsKey: s.getItem(i) === null ? void 0 : i,
-        raw: JSON.stringify(y),
-        scope: o
-      }), I();
+    flush: u,
+    listScopes(s) {
+      return [.../* @__PURE__ */ new Set([...S("layout-scope-index", s), ...S("layout-resource-index", s), ...M(s)])];
     },
-    flush: f,
+    transformLayouts(s, r) {
+      u(), P();
+      for (const n of this.listScopes?.(s) ?? []) {
+        const a = c(e.namespace, "layout", n), l = m(t, a);
+        if (l?.version !== v) continue;
+        const g = r(l.layout, n);
+        if (!g) {
+          t.removeItem?.(a);
+          continue;
+        }
+        t.setItem(a, JSON.stringify({
+          version: v,
+          layout: g
+        }));
+      }
+    },
+    getCompatibilityMarker: (s) => m(t, c(e.namespace, "layout-compatibility", s)),
+    setCompatibilityMarker: (s, r) => {
+      P(), t.setItem(c(e.namespace, "layout-compatibility", s), JSON.stringify(r));
+    },
+    advanceWriteGeneration: P,
     dispose() {
-      f(), m?.removeEventListener("pagehide", f);
+      u(), d?.removeEventListener("pagehide", u);
     }
   };
-}, K = (e) => {
-  const s = d(e.storage);
+}, H = (e) => {
+  const t = p(e.storage);
   return {
-    getHistory: (t) => p(s, r(e.namespace, "history", t)),
-    setHistory: (t, a) => {
-      s.setItem(r(e.namespace, "history", a), JSON.stringify(t));
+    getHistory: (o) => m(t, c(e.namespace, "history", o)),
+    setHistory: (o, i) => {
+      t.setItem(c(e.namespace, "history", i), JSON.stringify(o));
     }
   };
-}, J = (e) => {
-  const s = d(e.storage);
+}, A = (e) => {
+  const t = p(e.storage);
   return {
-    getPanelStates: (t) => p(s, r(e.namespace, "panels", t ?? e.scope)),
-    setPanelStates: (t, a) => {
-      const m = r(e.namespace, "panels", a ?? e.scope);
-      s.setItem(m, JSON.stringify(t));
+    getPanelStates: (o) => m(t, c(e.namespace, "panels", o ?? e.scope)),
+    setPanelStates: (o, i) => {
+      const d = c(e.namespace, "panels", i ?? e.scope);
+      t.setItem(d, JSON.stringify(o));
     }
   };
-}, k = (e) => {
-  const s = d(e.storage), t = r(e.namespace, "tree", e.scope);
+}, U = (e) => {
+  const t = p(e.storage), o = c(e.namespace, "tree", e.scope);
   return {
-    getTreeStates: () => p(s, t),
-    setTreeStates: (a) => {
-      s.setItem(t, JSON.stringify(a));
+    getTreeStates: () => m(t, o),
+    setTreeStates: (i) => {
+      t.setItem(o, JSON.stringify(i));
     }
   };
-}, B = (e) => !!e && typeof e.kind == "string" && typeof e.uri == "string", M = (e) => {
-  const s = d(e.storage), t = r(e.namespace, "last-resource", e.scope);
+}, $ = (e) => !!e && typeof e.kind == "string" && typeof e.uri == "string", G = (e) => {
+  const t = p(e.storage), o = c(e.namespace, "last-resource", e.scope);
   return {
     getLastResource: () => {
-      const a = p(s, t);
-      return B(a) ? a : void 0;
+      const i = m(t, o);
+      return $(i) ? i : void 0;
     },
-    setLastResource: (a) => {
-      if (!a) {
-        s.removeItem?.(t);
+    setLastResource: (i) => {
+      if (!i) {
+        t.removeItem?.(o);
         return;
       }
-      s.setItem(t, JSON.stringify(a));
+      t.setItem(o, JSON.stringify(i));
     }
   };
-}, j = (e) => {
-  const s = d(e.storage), t = T({
+}, E = 1, V = ["attached", "closed", "floating"], Y = (e) => {
+  const t = p(e.storage), o = c(e.namespace, "side-panel", e.scope);
+  return {
+    getMode: () => {
+      const i = m(t, o);
+      if (i?.version === E)
+        return V.includes(i.mode) ? i.mode : void 0;
+    },
+    setMode: (i) => {
+      const d = {
+        version: E,
+        mode: i
+      };
+      t.setItem(o, JSON.stringify(d));
+    }
+  };
+}, z = (e) => {
+  const t = p(e.storage), o = C({
     debounceMs: e.debounceMs,
     eventTarget: e.eventTarget,
     namespace: e.namespace,
-    storage: s
+    storage: t
   });
   return {
     snapshotPersistence: {
-      getSnapshot: (m) => {
-        const l = t.getLayout(m);
-        return l ? {
-          layout: l
+      getSnapshot: (d) => {
+        const y = o.getLayout(d);
+        return y ? {
+          layout: y
         } : void 0;
       },
-      setSnapshot: (m, l) => t.setLayout(m.layout, l),
-      flush: t.flush,
-      dispose: t.dispose
+      setSnapshot: (d, y) => o.setLayout(d.layout, y),
+      flush: o.flush,
+      dispose: o.dispose
     },
-    historyPersistence: K({
+    historyPersistence: H({
       namespace: e.namespace,
-      storage: s
+      storage: t
     }),
-    layoutPersistence: t,
-    panelsPersistence: J({
+    layoutPersistence: o,
+    panelsPersistence: A({
       namespace: e.namespace,
       scope: e.scope ?? "global",
-      storage: s
+      storage: t
+    }),
+    treePersistence: U({
+      namespace: e.namespace,
+      scope: e.scope,
+      storage: t
     }),
-    treePersistence: k({
+    lastResourcePersistence: G({
       namespace: e.namespace,
       scope: e.scope,
-      storage: s
+      storage: t
     }),
-    lastResourcePersistence: M({
+    sidePanelPersistence: Y({
       namespace: e.namespace,
       scope: e.scope,
-      storage: s
+      storage: t
     })
   };
 };
 export {
-  K as createLocalStorageHistoryPersistence,
-  M as createLocalStorageLastResourcePersistence,
-  T as createLocalStorageLayoutPersistence,
-  J as createLocalStoragePanelsPersistence,
-  k as createLocalStorageTreePersistence,
-  j as createLocalStorageWorkbenchPersistence,
-  r as workbenchStoragePersistenceKey
+  H as createLocalStorageHistoryPersistence,
+  G as createLocalStorageLastResourcePersistence,
+  C as createLocalStorageLayoutPersistence,
+  A as createLocalStoragePanelsPersistence,
+  U as createLocalStorageTreePersistence,
+  z as createLocalStorageWorkbenchPersistence,
+  c as workbenchStoragePersistenceKey
 };
 //# sourceMappingURL=storage.js.map