@scalar/workspace-store 0.40.2 → 0.40.4

package/dist/mutators/tabs.js

@@ -1,146 +1,189 @@
-import { unpackProxyObject } from "../helpers/unpack-proxy.js";
+import { unpackProxyObject } from '../helpers/unpack-proxy.js';
+/**
+ * Depth level for unpacking tab proxy objects.
+ * We only need shallow unpacking since tabs are a flat array.
+ */
 const TAB_UNPACK_DEPTH = 1;
+/**
+ * Helper to validate that workspace has tabs configured.
+ * Returns false if workspace or tabs are not available.
+ */
 const hasValidTabs = (workspace) => {
-  return workspace !== null && workspace["x-scalar-tabs"] !== void 0;
+    return workspace !== null && workspace['x-scalar-tabs'] !== undefined;
 };
+/**
+ * Helper to get the unpacked tabs array from workspace.
+ * Returns the tabs as a plain array, not a proxy.
+ */
 const getUnpackedTabs = (workspace) => {
-  return unpackProxyObject(workspace["x-scalar-tabs"], { depth: TAB_UNPACK_DEPTH });
+    return unpackProxyObject(workspace['x-scalar-tabs'], { depth: TAB_UNPACK_DEPTH });
 };
+/**
+ * Helper to get the current active tab index.
+ * Defaults to 0 if not set.
+ */
 const getActiveIndex = (workspace) => {
-  return workspace["x-scalar-active-tab"] ?? 0;
+    return workspace['x-scalar-active-tab'] ?? 0;
 };
-const updateTabs = (workspace, payload) => {
-  if (!workspace) {
-    return;
-  }
-  if (payload["x-scalar-tabs"]) {
-    workspace["x-scalar-tabs"] = payload["x-scalar-tabs"];
-  }
-  if (payload["x-scalar-active-tab"] !== void 0) {
-    workspace["x-scalar-active-tab"] = payload["x-scalar-active-tab"];
-  }
-};
-const addTab = (workspace, _payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const tabs = getUnpackedTabs(workspace);
-  const activeIndex = getActiveIndex(workspace);
-  const currentTab = tabs[activeIndex];
-  if (!currentTab) {
-    return false;
-  }
-  const newTabs = [...tabs, { ...currentTab }];
-  workspace["x-scalar-tabs"] = newTabs;
-  workspace["x-scalar-active-tab"] = newTabs.length - 1;
-  return true;
+/**
+ * Updates the tabs and active tab index in the workspace.
+ * This is used for bulk updates when synchronizing state.
+ */
+export const updateTabs = (workspace, payload) => {
+    if (!workspace) {
+        return;
+    }
+    if (payload['x-scalar-tabs']) {
+        workspace['x-scalar-tabs'] = payload['x-scalar-tabs'];
+    }
+    if (payload['x-scalar-active-tab'] !== undefined) {
+        workspace['x-scalar-active-tab'] = payload['x-scalar-active-tab'];
+    }
 };
-const closeTab = (workspace, payload) => {
-  const getInputIndex = () => {
-    if ("event" in payload) {
-      return payload.event.code.startsWith("Digit") ? Number.parseInt(payload.event.key, 10) - 1 : Number.NaN;
-    }
-    return payload.index;
-  };
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const index = getInputIndex();
-  const activeIndex = getActiveIndex(workspace);
-  const filteredTabs = getUnpackedTabs(workspace).filter((_, i) => i !== index);
-  if (filteredTabs.length <= 0) {
-    return false;
-  }
-  workspace["x-scalar-tabs"] = filteredTabs;
-  const newActiveIndex = index < activeIndex ? activeIndex - 1 : Math.min(activeIndex, filteredTabs.length - 1);
-  workspace["x-scalar-active-tab"] = newActiveIndex;
-  return true;
+/**
+ * Adds a new tab by duplicating the currently active tab.
+ * This preserves the user's context when opening a new tab.
+ */
+export const addTab = (workspace, _payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const tabs = getUnpackedTabs(workspace);
+    const activeIndex = getActiveIndex(workspace);
+    const currentTab = tabs[activeIndex];
+    if (!currentTab) {
+        return false;
+    }
+    const newTabs = [...tabs, { ...currentTab }];
+    workspace['x-scalar-tabs'] = newTabs;
+    workspace['x-scalar-active-tab'] = newTabs.length - 1;
+    return true;
 };
-const closeOtherTabs = (workspace, payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const tabs = getUnpackedTabs(workspace);
-  if (tabs.length <= 1) {
-    return false;
-  }
-  workspace["x-scalar-tabs"] = tabs.filter((_, index) => index === payload.index);
-  workspace["x-scalar-active-tab"] = 0;
-  return true;
+/**
+ * Closes the currently active tab.
+ * Prevents closing if only one tab remains, to ensure the user always has a tab open.
+ * Adjusts the active index if needed to keep it in bounds.
+ */
+export const closeTab = (workspace, payload) => {
+    const getInputIndex = () => {
+        if ('event' in payload) {
+            return payload.event.code.startsWith('Digit') ? Number.parseInt(payload.event.key, 10) - 1 : Number.NaN;
+        }
+        return payload.index;
+    };
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const index = getInputIndex();
+    const activeIndex = getActiveIndex(workspace);
+    const filteredTabs = getUnpackedTabs(workspace).filter((_, i) => i !== index);
+    if (filteredTabs.length <= 0) {
+        return false;
+    }
+    workspace['x-scalar-tabs'] = filteredTabs;
+    /**
+     * Adjust active index so it stays in bounds and points to the same logical tab when possible.
+     * - Closing a tab before the active: decrement so we stay on the same tab (now at index - 1).
+     * - Closing the active tab or one after: clamp to the new length so we never go out of bounds.
+     */
+    const newActiveIndex = index < activeIndex ? activeIndex - 1 : Math.min(activeIndex, filteredTabs.length - 1);
+    workspace['x-scalar-active-tab'] = newActiveIndex;
+    return true;
 };
-const navigatePreviousTab = (workspace, _payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const activeIndex = getActiveIndex(workspace);
-  if (activeIndex <= 0) {
-    return false;
-  }
-  workspace["x-scalar-active-tab"] = activeIndex - 1;
-  return true;
+/**
+ * Closes all other tabs except the one at the given index
+ */
+export const closeOtherTabs = (workspace, payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const tabs = getUnpackedTabs(workspace);
+    if (tabs.length <= 1) {
+        return false;
+    }
+    workspace['x-scalar-tabs'] = tabs.filter((_, index) => index === payload.index);
+    // set the active tab to the first tab since we closed all other tabs
+    workspace['x-scalar-active-tab'] = 0;
+    return true;
 };
-const navigateNextTab = (workspace, _payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const tabs = getUnpackedTabs(workspace);
-  const activeIndex = getActiveIndex(workspace);
-  if (activeIndex >= tabs.length - 1) {
-    return false;
-  }
-  workspace["x-scalar-active-tab"] = activeIndex + 1;
-  return true;
+/**
+ * Navigates to the previous tab in the list.
+ * Does nothing if already at the first tab.
+ */
+export const navigatePreviousTab = (workspace, _payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const activeIndex = getActiveIndex(workspace);
+    if (activeIndex <= 0) {
+        return false;
+    }
+    workspace['x-scalar-active-tab'] = activeIndex - 1;
+    return true;
 };
-const focusTab = (workspace, payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const getInputIndex = () => {
-    if ("event" in payload) {
-      return payload.event.code.startsWith("Digit") ? Number.parseInt(payload.event.key, 10) - 1 : Number.NaN;
-    }
-    return payload.index;
-  };
-  const tabs = getUnpackedTabs(workspace);
-  const newActiveIndex = getInputIndex();
-  if (Number.isNaN(newActiveIndex) || newActiveIndex < 0 || newActiveIndex >= tabs.length) {
-    return false;
-  }
-  workspace["x-scalar-active-tab"] = newActiveIndex;
-  return true;
+/**
+ * Navigates to the next tab in the list.
+ * Does nothing if already at the last tab.
+ */
+export const navigateNextTab = (workspace, _payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const tabs = getUnpackedTabs(workspace);
+    const activeIndex = getActiveIndex(workspace);
+    if (activeIndex >= tabs.length - 1) {
+        return false;
+    }
+    workspace['x-scalar-active-tab'] = activeIndex + 1;
+    return true;
 };
-const focusLastTab = (workspace, _payload) => {
-  if (!hasValidTabs(workspace)) {
-    return false;
-  }
-  const tabs = getUnpackedTabs(workspace);
-  if (tabs.length <= 1) {
-    return false;
-  }
-  workspace["x-scalar-active-tab"] = tabs.length - 1;
-  return true;
+/**
+ * Focuses a specific tab based on keyboard number input (1-9).
+ * Extracts the digit from the keyboard event and focuses that tab.
+ * Tab numbering starts at 1 for user convenience but uses 0-based indexing internally.
+ */
+export const focusTab = (workspace, payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const getInputIndex = () => {
+        if ('event' in payload) {
+            return payload.event.code.startsWith('Digit') ? Number.parseInt(payload.event.key, 10) - 1 : Number.NaN;
+        }
+        return payload.index;
+    };
+    const tabs = getUnpackedTabs(workspace);
+    const newActiveIndex = getInputIndex();
+    if (Number.isNaN(newActiveIndex) || newActiveIndex < 0 || newActiveIndex >= tabs.length) {
+        return false;
+    }
+    workspace['x-scalar-active-tab'] = newActiveIndex;
+    return true;
 };
-const tabsMutatorsFactory = ({ workspace }) => {
-  return {
-    updateTabs: (payload) => updateTabs(workspace, payload),
-    addTab: (payload) => addTab(workspace, payload),
-    closeTab: (payload) => closeTab(workspace, payload),
-    closeOtherTabs: (payload) => closeOtherTabs(workspace, payload),
-    navigatePreviousTab: (payload) => navigatePreviousTab(workspace, payload),
-    navigateNextTab: (payload) => navigateNextTab(workspace, payload),
-    focusTab: (payload) => focusTab(workspace, payload),
-    focusLastTab: (payload) => focusLastTab(workspace, payload)
-  };
+/**
+ * Focuses the last tab in the list.
+ * This provides a quick way to jump to the end, regardless of how many tabs exist.
+ */
+export const focusLastTab = (workspace, _payload) => {
+    if (!hasValidTabs(workspace)) {
+        return false;
+    }
+    const tabs = getUnpackedTabs(workspace);
+    if (tabs.length <= 1) {
+        return false;
+    }
+    workspace['x-scalar-active-tab'] = tabs.length - 1;
+    return true;
 };
-export {
-  addTab,
-  closeOtherTabs,
-  closeTab,
-  focusLastTab,
-  focusTab,
-  navigateNextTab,
-  navigatePreviousTab,
-  tabsMutatorsFactory,
-  updateTabs
+export const tabsMutatorsFactory = ({ workspace }) => {
+    return {
+        updateTabs: (payload) => updateTabs(workspace, payload),
+        addTab: (payload) => addTab(workspace, payload),
+        closeTab: (payload) => closeTab(workspace, payload),
+        closeOtherTabs: (payload) => closeOtherTabs(workspace, payload),
+        navigatePreviousTab: (payload) => navigatePreviousTab(workspace, payload),
+        navigateNextTab: (payload) => navigateNextTab(workspace, payload),
+        focusTab: (payload) => focusTab(workspace, payload),
+        focusLastTab: (payload) => focusLastTab(workspace, payload),
+    };
 };
-//# sourceMappingURL=tabs.js.map

package/dist/mutators/tag.js

@@ -1,106 +1,140 @@
-import { getResolvedRef } from "../helpers/get-resolved-ref.js";
-import { unpackProxyObject } from "../helpers/unpack-proxy.js";
-import { getNavigationOptions } from "../navigation/get-navigation-options.js";
-import { getTagEntries } from "../navigation/helpers/get-tag-entries.js";
-import { updateOrderIds } from "../navigation/helpers/update-order-ids.js";
-const createTag = (store, payload) => {
-  const document = store?.workspace.documents[payload.documentName];
-  if (!document) {
-    console.error("Document not found", { payload, store });
-    return;
-  }
-  if (!document.tags) {
-    document.tags = [];
-  }
-  document.tags.push({
-    name: payload.name
-  });
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+import { unpackProxyObject } from '../helpers/unpack-proxy.js';
+import { getNavigationOptions } from '../navigation/get-navigation-options.js';
+import { getTagEntries } from '../navigation/helpers/get-tag-entries.js';
+import { updateOrderIds } from '../navigation/helpers/update-order-ids.js';
+/**
+ * Adds a new tag to the WorkspaceDocument's `tags` array.
+ *
+ * If the document or its tags property does not exist, the function safely no-ops or initializes `tags` as needed.
+ *
+ * @param document - The target WorkspaceDocument
+ * @param payload - The name of the tag to add
+ */
+export const createTag = (store, payload) => {
+    const document = store?.workspace.documents[payload.documentName];
+    if (!document) {
+        console.error('Document not found', { payload, store });
+        return;
+    }
+    if (!document.tags) {
+        document.tags = [];
+    }
+    document.tags.push({
+        name: payload.name,
+    });
 };
-const editTag = (store, payload) => {
-  const document = store?.workspace.documents[payload.documentName];
-  const documentNavigation = document?.["x-scalar-navigation"];
-  if (!document || !documentNavigation) {
-    console.error("Document not found", { payload, store });
-    return;
-  }
-  const oldName = payload.tag.name;
-  const newName = payload.newName;
-  if (document.tags?.length) {
-    document.tags = document.tags.map((_tag) => {
-      const tag = unpackProxyObject(_tag);
-      return tag.name === oldName ? { ...tag, name: newName } : tag;
+/**
+ * Edits a tag in the WorkspaceDocument's
+ *
+ * @param document - The target WorkspaceDocument
+ * @param payload - holds the old tag and the new name
+ */
+export const editTag = (store, payload) => {
+    const document = store?.workspace.documents[payload.documentName];
+    const documentNavigation = document?.['x-scalar-navigation'];
+    if (!document || !documentNavigation) {
+        console.error('Document not found', { payload, store });
+        return;
+    }
+    const oldName = payload.tag.name;
+    const newName = payload.newName;
+    if (document.tags?.length) {
+        // const plainTags = unpackProxyObject(document.tags, { depth: null })
+        document.tags = document.tags.map((_tag) => {
+            const tag = unpackProxyObject(_tag);
+            return tag.name === oldName ? { ...tag, name: newName } : tag;
+        });
+    }
+    // Update the tag name in all child operations and webhooks
+    payload.tag.children?.forEach((child) => {
+        // Operation
+        if (child.type === 'operation') {
+            const operation = getResolvedRef(document.paths?.[child.path]?.[child.method]);
+            if (operation && 'tags' in operation) {
+                const plainTags = unpackProxyObject(operation.tags, { depth: null });
+                operation.tags = plainTags?.map((tag) => (tag === oldName ? newName : tag));
+            }
+        }
+        // Webhook
+        else if (child.type === 'webhook') {
+            const webhook = getResolvedRef(document.webhooks?.[child.name]?.[child.method]);
+            if (webhook && 'tags' in webhook) {
+                const plainTags = unpackProxyObject(webhook.tags, { depth: null });
+                webhook.tags = plainTags?.map((tag) => (tag === oldName ? newName : tag));
+            }
+        }
     });
-  }
-  payload.tag.children?.forEach((child) => {
-    if (child.type === "operation") {
-      const operation = getResolvedRef(document.paths?.[child.path]?.[child.method]);
-      if (operation && "tags" in operation) {
-        const plainTags = unpackProxyObject(operation.tags, { depth: null });
-        operation.tags = plainTags?.map((tag) => tag === oldName ? newName : tag);
-      }
-    } else if (child.type === "webhook") {
-      const webhook = getResolvedRef(document.webhooks?.[child.name]?.[child.method]);
-      if (webhook && "tags" in webhook) {
-        const plainTags = unpackProxyObject(webhook.tags, { depth: null });
-        webhook.tags = plainTags?.map((tag) => tag === oldName ? newName : tag);
-      }
+    // Update x-tagGroups references to the renamed tag
+    if (document['x-tagGroups']) {
+        const plainGroups = unpackProxyObject(document['x-tagGroups'], { depth: null });
+        document['x-tagGroups'] = plainGroups.map((group) => ({
+            ...group,
+            tags: group.tags.map((tag) => (tag === oldName ? newName : tag)),
+        }));
+    }
+    /**
+     * We don't pass navigation options as we don't have config on the client,
+     * and we don't change path or method on the references
+     */
+    const { generateId } = getNavigationOptions(documentNavigation.name);
+    /** Grabs all sidebar entries for the tag that is being renamed */
+    const tagEntriesMap = getTagEntries(documentNavigation);
+    const entries = tagEntriesMap.get(oldName);
+    // Updates the order ID so we don't lose the sidebar ordering when it rebuilds.
+    if (entries) {
+        updateOrderIds({ store, tag: { name: newName }, generateId, entries });
     }
-  });
-  if (document["x-tagGroups"]) {
-    const plainGroups = unpackProxyObject(document["x-tagGroups"], { depth: null });
-    document["x-tagGroups"] = plainGroups.map((group) => ({
-      ...group,
-      tags: group.tags.map((tag) => tag === oldName ? newName : tag)
-    }));
-  }
-  const { generateId } = getNavigationOptions(documentNavigation.name);
-  const tagEntriesMap = getTagEntries(documentNavigation);
-  const entries = tagEntriesMap.get(oldName);
-  if (entries) {
-    updateOrderIds({ store, tag: { name: newName }, generateId, entries });
-  }
 };
-const deleteTag = (workspace, payload) => {
-  const document = workspace?.workspace.documents[payload.documentName];
-  if (!document) {
-    return;
-  }
-  Object.values(document.paths ?? {}).forEach((path) => {
-    Object.values(path).forEach((operation) => {
-      if (typeof operation !== "object" || Array.isArray(operation)) {
+/**
+ * Deletes a tag from the workspace
+ *
+ * Example:
+ * ```ts
+ * deleteTag({
+ *   document,
+ *   name: 'tag',
+ * })
+ * ```
+ */
+export const deleteTag = (workspace, payload) => {
+    const document = workspace?.workspace.documents[payload.documentName];
+    if (!document) {
         return;
-      }
-      const resolvedOperation = getResolvedRef(operation);
-      if ("tags" in resolvedOperation) {
-        const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
-        resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
-      }
+    }
+    // Clear tags from all operations that have this tag
+    Object.values(document.paths ?? {}).forEach((path) => {
+        Object.values(path).forEach((operation) => {
+            // Only process operations that are objects
+            if (typeof operation !== 'object' || Array.isArray(operation)) {
+                return;
+            }
+            const resolvedOperation = getResolvedRef(operation);
+            if ('tags' in resolvedOperation) {
+                const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
+                resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
+            }
+        });
     });
-  });
-  Object.values(document.webhooks ?? {}).forEach((webhook) => {
-    Object.values(webhook).forEach((operation) => {
-      if (typeof operation !== "object" || Array.isArray(operation)) {
-        return;
-      }
-      const resolvedOperation = getResolvedRef(operation);
-      const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
-      resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
+    // Remove the tag from all webhooks that have this tag
+    Object.values(document.webhooks ?? {}).forEach((webhook) => {
+        Object.values(webhook).forEach((operation) => {
+            if (typeof operation !== 'object' || Array.isArray(operation)) {
+                return;
+            }
+            const resolvedOperation = getResolvedRef(operation);
+            const plainTags = unpackProxyObject(resolvedOperation.tags, { depth: 1 });
+            resolvedOperation.tags = plainTags?.filter((tag) => tag !== payload.name);
+        });
     });
-  });
-  const plainDocTags = unpackProxyObject(document.tags, { depth: null });
-  document.tags = plainDocTags?.filter((tag) => tag.name !== payload.name);
-};
-const tagMutatorsFactory = ({ store }) => {
-  return {
-    createTag: (payload) => createTag(store, payload),
-    editTag: (payload) => editTag(store, payload),
-    deleteTag: (payload) => deleteTag(store, payload)
-  };
+    // Remove the tag from the document tags array
+    const plainDocTags = unpackProxyObject(document.tags, { depth: null });
+    document.tags = plainDocTags?.filter((tag) => tag.name !== payload.name);
 };
-export {
-  createTag,
-  deleteTag,
-  editTag,
-  tagMutatorsFactory
+export const tagMutatorsFactory = ({ store }) => {
+    return {
+        createTag: (payload) => createTag(store, payload),
+        editTag: (payload) => editTag(store, payload),
+        deleteTag: (payload) => deleteTag(store, payload),
+    };
 };
-//# sourceMappingURL=tag.js.map