@bendyline/docblocks 2.0.0 → 2.1.1

package/dist/chunk-SJBB5OD7.js

@@ -0,0 +1,227 @@
+import {
+  RawIndexedDBFileSystemStore
+} from "./chunk-OQCPBOQA.js";
+import {
+  getFileSystemProviderV2
+} from "./chunk-XAMILHQP.js";
+
+// src/workspace/workspace-schema.ts
+var MAX_IDENTIFIER_CHARACTERS = 256;
+var MAX_LABEL_CHARACTERS = 1024;
+var MAX_PATH_CHARACTERS = 4096;
+var MAX_WORKSPACES = 1e4;
+function parsePersistedWorkspaceList(value) {
+  if (!Array.isArray(value)) throw new Error("Persisted workspaces must be an array.");
+  if (value.length > MAX_WORKSPACES) throw new Error("Persisted workspace list is too large.");
+  const parsed = value.map(parsePersistedWorkspace);
+  if (new Set(parsed.map((workspace) => workspace.id)).size !== parsed.length) {
+    throw new Error("Persisted workspace IDs must be unique.");
+  }
+  return parsed;
+}
+function parsePersistedWorkspace(value, index) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`Persisted workspace ${index} must be an object.`);
+  }
+  const record = value;
+  const allowed = ["id", "name", "type", "lastOpened", "rootPath", "versioningOverride"];
+  const unknownKey = Object.keys(record).find((key) => !allowed.includes(key));
+  if (unknownKey) throw new Error(`Persisted workspace ${index} has unknown field ${unknownKey}.`);
+  const id = boundedString(record.id, MAX_IDENTIFIER_CHARACTERS, `workspace ${index} id`);
+  const name = boundedString(record.name, MAX_LABEL_CHARACTERS, `workspace ${index} name`);
+  if (record.type !== "indexeddb" && record.type !== "native" && record.type !== "electron-native") {
+    throw new Error(`Persisted workspace ${index} has an invalid provider type.`);
+  }
+  const lastOpened = boundedString(
+    record.lastOpened,
+    MAX_IDENTIFIER_CHARACTERS,
+    `workspace ${index} lastOpened`
+  );
+  if (!Number.isFinite(Date.parse(lastOpened)) || new Date(lastOpened).toISOString() !== lastOpened) {
+    throw new Error(`Persisted workspace ${index} has an invalid lastOpened timestamp.`);
+  }
+  const descriptor = { id, name, type: record.type, lastOpened };
+  if (record.rootPath !== void 0) {
+    descriptor.rootPath = boundedString(
+      record.rootPath,
+      MAX_PATH_CHARACTERS,
+      `workspace ${index} rootPath`
+    );
+  }
+  if (record.type === "electron-native" && descriptor.rootPath === void 0) {
+    throw new Error(`Persisted Electron workspace ${index} is missing rootPath.`);
+  }
+  if (record.type !== "electron-native" && descriptor.rootPath !== void 0) {
+    throw new Error(`Persisted workspace ${index} must not contain rootPath.`);
+  }
+  if (record.versioningOverride !== void 0) {
+    if (record.versioningOverride !== "inherit" && record.versioningOverride !== "on" && record.versioningOverride !== "off") {
+      throw new Error(`Persisted workspace ${index} has an invalid versioning override.`);
+    }
+    descriptor.versioningOverride = record.versioningOverride;
+  }
+  return descriptor;
+}
+function boundedString(value, maximum, label) {
+  if (typeof value !== "string" || value.length < 1 || value.length > maximum || value.includes("\0")) {
+    throw new Error(`Persisted ${label} must be a bounded non-empty string.`);
+  }
+  return value;
+}
+
+// src/workspace/workspace-manager.ts
+var DB_NAME = "docblocks-workspaces";
+var STORE_NAME = "workspaces";
+var LIST_KEY = "workspace-list";
+var DEFAULT_WORKSPACE_ID = "default";
+var registryStore = null;
+function store() {
+  registryStore ?? (registryStore = new RawIndexedDBFileSystemStore(DB_NAME, STORE_NAME));
+  return registryStore;
+}
+var transientWorkspaces = /* @__PURE__ */ new Map();
+var persistedMutationTail = Promise.resolve();
+function registerTransientWorkspace(descriptor, provider) {
+  const previous = transientWorkspaces.get(descriptor.id);
+  if (previous && previous.provider !== provider) {
+    void getFileSystemProviderV2(previous.provider)?.dispose();
+  }
+  transientWorkspaces.set(descriptor.id, { descriptor, provider });
+}
+function getTransientWorkspace(id) {
+  return transientWorkspaces.get(id) ?? null;
+}
+async function unregisterTransientWorkspace(id) {
+  const entry = transientWorkspaces.get(id);
+  if (!entry) return;
+  transientWorkspaces.delete(id);
+  await getFileSystemProviderV2(entry.provider)?.dispose();
+}
+async function readPersistedIn(transaction) {
+  const list = await transaction.get(LIST_KEY);
+  return list == null ? [] : parsePersistedWorkspaceList(list);
+}
+async function readPersisted() {
+  return store().transaction("readonly", readPersistedIn);
+}
+async function listPersisted() {
+  await persistedMutationTail;
+  return readPersisted();
+}
+function mutatePersisted(mutation) {
+  const operation = persistedMutationTail.then(async () => {
+    await store().transaction("readwrite", async (transaction) => {
+      const current = await readPersistedIn(transaction);
+      const next = parsePersistedWorkspaceList(mutation([...current]));
+      await transaction.put(LIST_KEY, next);
+    });
+  });
+  persistedMutationTail = operation.then(
+    () => void 0,
+    () => void 0
+  );
+  return operation;
+}
+async function listWorkspaces() {
+  const persisted = await listPersisted();
+  const transient = [...transientWorkspaces.values()].map((t) => t.descriptor);
+  return [...persisted, ...transient];
+}
+async function getWorkspace(id) {
+  const transient = transientWorkspaces.get(id);
+  if (transient) return transient.descriptor;
+  const list = await listPersisted();
+  return list.find((w) => w.id === id) ?? null;
+}
+async function saveWorkspace(workspace) {
+  if (workspace.type === "transient") return;
+  const persisted = parsePersistedWorkspaceList([workspace])[0];
+  await mutatePersisted((list) => {
+    const idx = list.findIndex((candidate) => candidate.id === persisted.id);
+    if (idx >= 0) list[idx] = persisted;
+    else list.push(persisted);
+    return list;
+  });
+}
+async function removeWorkspace(id) {
+  if (transientWorkspaces.has(id)) {
+    await unregisterTransientWorkspace(id);
+    return;
+  }
+  await mutatePersisted((list) => list.filter((workspace) => workspace.id !== id));
+}
+async function touchWorkspace(id) {
+  const transient = transientWorkspaces.get(id);
+  if (transient) {
+    transient.descriptor.lastOpened = (/* @__PURE__ */ new Date()).toISOString();
+    return;
+  }
+  await mutatePersisted((list) => {
+    const workspace = list.find((candidate) => candidate.id === id);
+    if (workspace) workspace.lastOpened = (/* @__PURE__ */ new Date()).toISOString();
+    return list;
+  });
+}
+async function ensureDefaultWorkspace() {
+  const existing = await getWorkspace(DEFAULT_WORKSPACE_ID);
+  if (existing) return existing;
+  const descriptor = {
+    id: DEFAULT_WORKSPACE_ID,
+    name: "My Documents",
+    type: "indexeddb",
+    lastOpened: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveWorkspace(descriptor);
+  return descriptor;
+}
+
+// src/workspace/reconcile-electron.ts
+function comparableRoot(rootPath, platform) {
+  const normalized = rootPath.replace(/\\/gu, "/").replace(/\/+$/gu, "");
+  return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function reconcileElectronWorkspaceDescriptors(local, hostWorkspaces, platform, now) {
+  const electron = local.filter((workspace) => workspace.type === "electron-native");
+  const matchedLocalIds = /* @__PURE__ */ new Set();
+  const idRemap = {};
+  const upsert = hostWorkspaces.map((hostWorkspace) => {
+    const root = comparableRoot(hostWorkspace.rootPath, platform);
+    const candidates = electron.filter(
+      (workspace) => workspace.rootPath && comparableRoot(workspace.rootPath, platform) === root
+    );
+    const matching = candidates.sort(
+      (left, right) => right.lastOpened.localeCompare(left.lastOpened)
+    )[0];
+    if (matching) {
+      matchedLocalIds.add(matching.id);
+      if (matching.id !== hostWorkspace.id) idRemap[matching.id] = hostWorkspace.id;
+    }
+    return {
+      id: hostWorkspace.id,
+      name: matching?.name ?? hostWorkspace.name,
+      type: "electron-native",
+      rootPath: hostWorkspace.rootPath,
+      lastOpened: matching?.lastOpened ?? now,
+      ...matching?.versioningOverride ? { versioningOverride: matching.versioningOverride } : {}
+    };
+  });
+  const canonicalIds = new Set(hostWorkspaces.map((workspace) => workspace.id));
+  const removeIds = electron.filter(
+    (workspace) => !canonicalIds.has(workspace.id) || matchedLocalIds.has(workspace.id) && !upsert.some((candidate) => candidate.id === workspace.id)
+  ).map((workspace) => workspace.id);
+  return { removeIds, upsert, idRemap };
+}
+
+export {
+  parsePersistedWorkspaceList,
+  registerTransientWorkspace,
+  getTransientWorkspace,
+  unregisterTransientWorkspace,
+  listWorkspaces,
+  getWorkspace,
+  saveWorkspace,
+  removeWorkspace,
+  touchWorkspace,
+  ensureDefaultWorkspace,
+  reconcileElectronWorkspaceDescriptors
+};

package/dist/{chunk-EZKJZUNJ.js → chunk-XAMILHQP.js}

@@ -10,4 +10,3 @@ export {
   hasFileSystemProviderV2,
   getFileSystemProviderV2
 };
-//# sourceMappingURL=chunk-EZKJZUNJ.js.map