@scalar/api-client 3.2.2 → 3.3.1

package/dist/v2/features/app/hooks/use-sidebar-context-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sidebar-context-menu.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/hooks/use-sidebar-context-menu.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAA;AAGhF;;;;;GAKG;AACH,KAAK,UAAU,GAAG;IAChB,+CAA+C;IAC/C,IAAI,EAAE,cAAc,CAAA;IACpB,mDAAmD;IACnD,EAAE,EAAE,WAAW,CAAA;IACf,8CAA8C;IAC9C,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,GAAI,6BAGnC;IACD,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,YAAY,EAAE,YAAY,CAAC,cAAc,CAAC,CAAA;CAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA7BK,WAAW;kBAEL,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAFb,WAAW;kBAEL,OAAO;;;;;;;;sBA+Cc,UAAU,GAAG,aAAa,QAAQ,cAAc;;;CAsFhF,CAAA"}

package/dist/v2/features/app/hooks/use-sidebar-context-menu.js

@@ -0,0 +1,107 @@
+import { computed, nextTick, ref } from "vue";
+import { useModal } from "@scalar/components";
+import { getParentEntry } from "@scalar/workspace-store/navigation";
+//#region src/v2/features/app/hooks/use-sidebar-context-menu.ts
+/**
+* Owns the "more options" dropdown + delete confirmation modal for the app
+* sidebar.
+*
+* The hook exposes:
+*  - `menuTarget`: anchor + open state for the `SidebarItemMenu` component,
+*    so the dropdown can re-position itself next to the triggering icon
+*    button without each row rendering its own menu
+*  - `openMenu` / `closeMenu`: helpers that match the dropdown animation
+*    lifecycle (keep the target element around on close so exit animations
+*    can play)
+*  - `deleteModalState` + `deleteMessage`: the shared confirmation modal
+*    that is triggered from the dropdown menu. The message is phrased more
+*    strongly for documents because deleting one also removes every tag and
+*    operation inside it.
+*  - `handleDelete`: routes the confirmation to the right `*:delete:*`
+*    event on the workspace event bus depending on the item's type.
+*/
+var useSidebarContextMenu = ({ eventBus, sidebarState }) => {
+	const menuTarget = ref(null);
+	const deleteModalState = useModal();
+	const deleteMessage = computed(() => {
+		const item = menuTarget.value?.item;
+		if (item?.type === "document") return "This cannot be undone. You're about to delete the document and all tags and operations inside it.";
+		return `Are you sure you want to delete this ${item?.type ?? "item"}? This action cannot be undone.`;
+	});
+	/**
+	* Open the dropdown for `item` and re-dispatch the originating event on
+	* the anchor element after the next tick. Re-dispatching is what lets the
+	* menu open on the correct anchor for both mouse and keyboard
+	* interactions, matching the behaviour of the old sidebar.
+	*/
+	const openMenu = async (event, item) => {
+		if (menuTarget.value?.showMenu) return;
+		menuTarget.value = {
+			item,
+			el: event.currentTarget,
+			showMenu: true
+		};
+		await nextTick();
+		const cloned = event instanceof MouseEvent ? new MouseEvent(event.type, event) : new KeyboardEvent(event.type, event);
+		menuTarget.value?.el.dispatchEvent(cloned);
+	};
+	/**
+	* Close the dropdown without resetting its target so exit animations can
+	* still play out. The target is cleared on the next `handleDelete` or
+	* `openMenu` call.
+	*/
+	const closeMenu = () => {
+		if (menuTarget.value) menuTarget.value.showMenu = false;
+	};
+	/**
+	* Fire the correct `*:delete:*` event on the workspace event bus for the
+	* active menu target, then hide the confirmation modal and clear the
+	* menu. Silent no-op if the target cannot be resolved to a parent
+	* document (or parent operation, for examples).
+	*/
+	const handleDelete = () => {
+		const item = menuTarget.value?.item;
+		if (!item) return;
+		const result = sidebarState.getEntryById(item.id);
+		const document = getParentEntry("document", result);
+		const operation = getParentEntry("operation", result);
+		if (!document) return;
+		if (item.type === "document") eventBus.emit("document:delete:document", { name: document.name });
+		else if (item.type === "tag") eventBus.emit("tag:delete:tag", {
+			documentName: document.name,
+			name: item.name
+		});
+		else if (item.type === "operation") eventBus.emit("operation:delete:operation", {
+			meta: {
+				method: item.method,
+				path: item.path
+			},
+			documentName: document.name
+		});
+		else if (item.type === "example") {
+			if (!operation) return;
+			eventBus.emit("operation:delete:example", {
+				meta: {
+					method: operation.method,
+					path: operation.path,
+					exampleKey: item.name
+				},
+				documentName: document.name
+			});
+		}
+		deleteModalState.hide();
+		menuTarget.value = null;
+	};
+	return {
+		menuTarget,
+		deleteModalState,
+		deleteMessage,
+		openMenu,
+		closeMenu,
+		handleDelete
+	};
+};
+//#endregion
+export { useSidebarContextMenu };
+
+//# sourceMappingURL=use-sidebar-context-menu.js.map

package/dist/v2/features/app/hooks/use-sidebar-context-menu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sidebar-context-menu.js","names":[],"sources":["../../../../../src/v2/features/app/hooks/use-sidebar-context-menu.ts"],"sourcesContent":["import { useModal } from '@scalar/components'\nimport type { SidebarState } from '@scalar/sidebar'\nimport type { WorkspaceEventBus } from '@scalar/workspace-store/events'\nimport { getParentEntry } from '@scalar/workspace-store/navigation'\nimport type { TraversedEntry } from '@scalar/workspace-store/schemas/navigation'\nimport { computed, nextTick, ref } from 'vue'\n\n/**\n * Anchor information for the currently open contextual dropdown. We hold on\n * to the DOM element that opened the menu so `SidebarItemMenu` can teleport\n * itself next to it, and track `showMenu` independently from `null`-ness so\n * closing the menu can play its exit animation before the target is cleared.\n */\ntype MenuTarget = {\n  /** The sidebar entry the menu is acting on. */\n  item: TraversedEntry\n  /** The DOM element the dropdown is anchored to. */\n  el: HTMLElement\n  /** Whether the menu is currently rendered. */\n  showMenu: boolean\n}\n\n/**\n * Owns the \"more options\" dropdown + delete confirmation modal for the app\n * sidebar.\n *\n * The hook exposes:\n *  - `menuTarget`: anchor + open state for the `SidebarItemMenu` component,\n *    so the dropdown can re-position itself next to the triggering icon\n *    button without each row rendering its own menu\n *  - `openMenu` / `closeMenu`: helpers that match the dropdown animation\n *    lifecycle (keep the target element around on close so exit animations\n *    can play)\n *  - `deleteModalState` + `deleteMessage`: the shared confirmation modal\n *    that is triggered from the dropdown menu. The message is phrased more\n *    strongly for documents because deleting one also removes every tag and\n *    operation inside it.\n *  - `handleDelete`: routes the confirmation to the right `*:delete:*`\n *    event on the workspace event bus depending on the item's type.\n */\nexport const useSidebarContextMenu = ({\n  eventBus,\n  sidebarState,\n}: {\n  eventBus: WorkspaceEventBus\n  sidebarState: SidebarState<TraversedEntry>\n}) => {\n  const menuTarget = ref<MenuTarget | null>(null)\n  const deleteModalState = useModal()\n\n  const deleteMessage = computed(() => {\n    const item = menuTarget.value?.item\n\n    if (item?.type === 'document') {\n      return \"This cannot be undone. You're about to delete the document and all tags and operations inside it.\"\n    }\n\n    return `Are you sure you want to delete this ${item?.type ?? 'item'}? This action cannot be undone.`\n  })\n\n  /**\n   * Open the dropdown for `item` and re-dispatch the originating event on\n   * the anchor element after the next tick. Re-dispatching is what lets the\n   * menu open on the correct anchor for both mouse and keyboard\n   * interactions, matching the behaviour of the old sidebar.\n   */\n  const openMenu = async (event: MouseEvent | KeyboardEvent, item: TraversedEntry) => {\n    if (menuTarget.value?.showMenu) {\n      return\n    }\n\n    const el = event.currentTarget as HTMLElement\n    menuTarget.value = { item, el, showMenu: true }\n\n    await nextTick()\n\n    const cloned =\n      event instanceof MouseEvent ? new MouseEvent(event.type, event) : new KeyboardEvent(event.type, event)\n\n    menuTarget.value?.el.dispatchEvent(cloned)\n  }\n\n  /**\n   * Close the dropdown without resetting its target so exit animations can\n   * still play out. The target is cleared on the next `handleDelete` or\n   * `openMenu` call.\n   */\n  const closeMenu = () => {\n    if (menuTarget.value) {\n      menuTarget.value.showMenu = false\n    }\n  }\n\n  /**\n   * Fire the correct `*:delete:*` event on the workspace event bus for the\n   * active menu target, then hide the confirmation modal and clear the\n   * menu. Silent no-op if the target cannot be resolved to a parent\n   * document (or parent operation, for examples).\n   */\n  const handleDelete = () => {\n    const item = menuTarget.value?.item\n\n    if (!item) {\n      return\n    }\n\n    const result = sidebarState.getEntryById(item.id)\n    const document = getParentEntry('document', result)\n    const operation = getParentEntry('operation', result)\n\n    if (!document) {\n      return\n    }\n\n    if (item.type === 'document') {\n      eventBus.emit('document:delete:document', { name: document.name })\n    } else if (item.type === 'tag') {\n      eventBus.emit('tag:delete:tag', {\n        documentName: document.name,\n        name: item.name,\n      })\n    } else if (item.type === 'operation') {\n      eventBus.emit('operation:delete:operation', {\n        meta: { method: item.method, path: item.path },\n        documentName: document.name,\n      })\n    } else if (item.type === 'example') {\n      if (!operation) {\n        return\n      }\n      eventBus.emit('operation:delete:example', {\n        meta: {\n          method: operation.method,\n          path: operation.path,\n          exampleKey: item.name,\n        },\n        documentName: document.name,\n      })\n    }\n\n    deleteModalState.hide()\n    menuTarget.value = null\n  }\n\n  return {\n    menuTarget,\n    deleteModalState,\n    deleteMessage,\n    openMenu,\n    closeMenu,\n    handleDelete,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,yBAAyB,EACpC,UACA,mBAII;CACJ,MAAM,aAAa,IAAuB,KAAK;CAC/C,MAAM,mBAAmB,UAAU;CAEnC,MAAM,gBAAgB,eAAe;EACnC,MAAM,OAAO,WAAW,OAAO;AAE/B,MAAI,MAAM,SAAS,WACjB,QAAO;AAGT,SAAO,wCAAwC,MAAM,QAAQ,OAAO;GACpE;;;;;;;CAQF,MAAM,WAAW,OAAO,OAAmC,SAAyB;AAClF,MAAI,WAAW,OAAO,SACpB;AAIF,aAAW,QAAQ;GAAE;GAAM,IADhB,MAAM;GACc,UAAU;GAAM;AAE/C,QAAM,UAAU;EAEhB,MAAM,SACJ,iBAAiB,aAAa,IAAI,WAAW,MAAM,MAAM,MAAM,GAAG,IAAI,cAAc,MAAM,MAAM,MAAM;AAExG,aAAW,OAAO,GAAG,cAAc,OAAO;;;;;;;CAQ5C,MAAM,kBAAkB;AACtB,MAAI,WAAW,MACb,YAAW,MAAM,WAAW;;;;;;;;CAUhC,MAAM,qBAAqB;EACzB,MAAM,OAAO,WAAW,OAAO;AAE/B,MAAI,CAAC,KACH;EAGF,MAAM,SAAS,aAAa,aAAa,KAAK,GAAG;EACjD,MAAM,WAAW,eAAe,YAAY,OAAO;EACnD,MAAM,YAAY,eAAe,aAAa,OAAO;AAErD,MAAI,CAAC,SACH;AAGF,MAAI,KAAK,SAAS,WAChB,UAAS,KAAK,4BAA4B,EAAE,MAAM,SAAS,MAAM,CAAC;WACzD,KAAK,SAAS,MACvB,UAAS,KAAK,kBAAkB;GAC9B,cAAc,SAAS;GACvB,MAAM,KAAK;GACZ,CAAC;WACO,KAAK,SAAS,YACvB,UAAS,KAAK,8BAA8B;GAC1C,MAAM;IAAE,QAAQ,KAAK;IAAQ,MAAM,KAAK;IAAM;GAC9C,cAAc,SAAS;GACxB,CAAC;WACO,KAAK,SAAS,WAAW;AAClC,OAAI,CAAC,UACH;AAEF,YAAS,KAAK,4BAA4B;IACxC,MAAM;KACJ,QAAQ,UAAU;KAClB,MAAM,UAAU;KAChB,YAAY,KAAK;KAClB;IACD,cAAc,SAAS;IACxB,CAAC;;AAGJ,mBAAiB,MAAM;AACvB,aAAW,QAAQ;;AAGrB,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACD"}

package/dist/v2/features/app/hooks/use-sidebar-documents.d.ts

@@ -0,0 +1,95 @@
+import type { AppState } from '@scalar/api-client/v2/features/app';
+import type { TraversedDocument } from '@scalar/workspace-store/schemas/navigation';
+import { type MaybeRefOrGetter } from 'vue';
+/**
+ * A single "version" of a document grouped under a registry namespace + slug.
+ * Only used on team workspaces, where multiple local documents may share the
+ * same registry coordinates.
+ */
+export type SidebarDocumentVersion = {
+    /** Stable key, matches the workspace document name */
+    key: string;
+    /** User facing label for the version */
+    title: string;
+    /** Name of the document inside the workspace store */
+    documentName: string;
+    /** Traversal tree for the document (if it has been loaded) */
+    navigation?: TraversedDocument;
+};
+/**
+ * A unified item for the top-level of our sidebar.
+ *
+ * It can represent one of three things:
+ *  - A workspace document that only exists locally (no registry link)
+ *  - A workspace document that was imported from the registry
+ *  - A registry document that has not yet been imported into the store
+ */
+export type SidebarDocumentItem = {
+    /** Stable key used for sidebar state keyed by `namespace/slug` or document name */
+    key: string;
+    /** User facing title of the document */
+    title: string;
+    /** Name of the document inside the workspace store (if loaded) */
+    documentName?: string;
+    /** Registry metadata if available */
+    registry?: {
+        namespace: string;
+        slug: string;
+    };
+    /**
+     * Traversal tree for the document if it has been loaded in the workspace store.
+     * When `undefined` the document still needs to be fetched from the registry
+     * before its nested content can be shown.
+     */
+    navigation?: TraversedDocument;
+    /** Whether the document is pinned (todo: derived from `x-scalar-pinned`) */
+    isPinned?: boolean;
+    /**
+     * TODO: implement versioning logic
+     * Other loaded documents that share this item's `namespace + slug`. Only
+     * populated on team workspaces where we collapse duplicates into a single
+     * entry with multiple versions.
+     */
+    versions?: SidebarDocumentVersion[];
+};
+export type RegistryDocument = {
+    namespace: string;
+    slug: string;
+    title: string;
+};
+/**
+ * Loading-aware wrapper for the registry documents prop.
+ *
+ * The sidebar uses the `status` to decide whether to render skeleton
+ * placeholders while the registry is being fetched. `documents` is optional
+ * during loading so callers can either render nothing or stream in cached
+ * results while a refresh is still in flight.
+ */
+export type RegistryDocumentsState = {
+    status: 'loading';
+    documents?: RegistryDocument[];
+} | {
+    status: 'success';
+    documents: RegistryDocument[];
+};
+/**
+ * Builds a unified list of sidebar documents.
+ *
+ * Behavior:
+ *  - Local workspaces (`teamUid === 'local'`) only show workspace documents.
+ *    Registry documents are not considered at all.
+ *  - Team workspaces group workspace documents by `namespace + slug` from
+ *    `x-scalar-registry-meta`. Each unique registry coordinate produces a
+ *    single sidebar entry whose additional matches are exposed as `versions`.
+ *    Registry documents that have no loaded match are appended as entries
+ *    waiting to be fetched.
+ */
+export declare function useSidebarDocuments({ app, managedDocs, }: {
+    app: AppState;
+    managedDocs: MaybeRefOrGetter<RegistryDocument[]>;
+}): {
+    documents: import("vue").ComputedRef<SidebarDocumentItem[]>;
+    pinned: import("vue").ComputedRef<SidebarDocumentItem[]>;
+    rest: import("vue").ComputedRef<SidebarDocumentItem[]>;
+};
+//# sourceMappingURL=use-sidebar-documents.d.ts.map

package/dist/v2/features/app/hooks/use-sidebar-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sidebar-documents.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/hooks/use-sidebar-documents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAA;AACnF,OAAO,EAAE,KAAK,gBAAgB,EAAqB,MAAM,KAAK,CAAA;AAE9D;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,sDAAsD;IACtD,GAAG,EAAE,MAAM,CAAA;IACX,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAA;IACpB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAA;IACX,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAA;IACb,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,qCAAqC;IACrC,QAAQ,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C;;;;OAIG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,sBAAsB,EAAE,CAAA;CACpC,CAAA;AAID,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAAA;AAIxD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,GAAG,EACH,WAAW,GACZ,EAAE;IACD,GAAG,EAAE,QAAQ,CAAA;IACb,WAAW,EAAE,gBAAgB,CAAC,gBAAgB,EAAE,CAAC,CAAA;CAClD;;;;EA+GA"}

package/dist/v2/features/app/hooks/use-sidebar-documents.js

@@ -0,0 +1,97 @@
+import { computed, toValue } from "vue";
+//#region src/v2/features/app/hooks/use-sidebar-documents.ts
+var registryKey = (namespace, slug) => `@${namespace}/${slug}`;
+/**
+* Builds a unified list of sidebar documents.
+*
+* Behavior:
+*  - Local workspaces (`teamUid === 'local'`) only show workspace documents.
+*    Registry documents are not considered at all.
+*  - Team workspaces group workspace documents by `namespace + slug` from
+*    `x-scalar-registry-meta`. Each unique registry coordinate produces a
+*    single sidebar entry whose additional matches are exposed as `versions`.
+*    Registry documents that have no loaded match are appended as entries
+*    waiting to be fetched.
+*/
+function useSidebarDocuments({ app, managedDocs }) {
+	const isTeamWorkspace = app.workspace.isTeamWorkspace;
+	/** Raw workspace documents mapped to sidebar entries (pre-grouping). */
+	const workspaceEntries = computed(() => {
+		const store = app.store.value;
+		if (!store) return [];
+		return Object.entries(store.workspace.documents).map(([name, doc]) => {
+			const registry = doc?.["x-scalar-registry-meta"];
+			const navigation = doc?.["x-scalar-navigation"];
+			const title = navigation?.title || doc?.info?.title || "Untitled";
+			const isTeam = isTeamWorkspace.value;
+			return {
+				key: isTeam && registry ? registryKey(registry.namespace, registry.slug) : name,
+				title,
+				documentName: name,
+				registry: isTeam && registry ? {
+					namespace: registry.namespace,
+					slug: registry.slug
+				} : void 0,
+				navigation,
+				isPinned: false
+			};
+		});
+	});
+	const documents = computed(() => {
+		if (!isTeamWorkspace.value) return workspaceEntries.value;
+		const activeDocumentSlug = app.activeEntities.documentSlug.value;
+		const groups = /* @__PURE__ */ new Map();
+		const standalone = [];
+		for (const entry of workspaceEntries.value) {
+			if (!entry.registry) {
+				standalone.push(entry);
+				continue;
+			}
+			const key = registryKey(entry.registry.namespace, entry.registry.slug);
+			const bucket = groups.get(key);
+			if (bucket) bucket.push(entry);
+			else groups.set(key, [entry]);
+		}
+		const grouped = [];
+		for (const [, entries] of groups) {
+			const activeIndex = entries.findIndex((e) => e.documentName === activeDocumentSlug);
+			const primaryIndex = activeIndex === -1 ? 0 : activeIndex;
+			const primary = entries[primaryIndex];
+			if (!primary) continue;
+			const versions = entries.filter((_, i) => i !== primaryIndex).map((e) => ({
+				key: e.documentName,
+				title: e.title,
+				documentName: e.documentName,
+				navigation: e.navigation
+			}));
+			grouped.push({
+				...primary,
+				isPinned: entries.some((e) => e.isPinned),
+				versions: versions.length ? versions : void 0
+			});
+		}
+		const loadedKeys = new Set(groups.keys());
+		const registryOnly = toValue(managedDocs).filter((doc) => !loadedKeys.has(registryKey(doc.namespace, doc.slug))).map((doc) => ({
+			key: registryKey(doc.namespace, doc.slug),
+			title: doc.title || doc.slug,
+			registry: {
+				namespace: doc.namespace,
+				slug: doc.slug
+			}
+		}));
+		return [
+			...grouped,
+			...registryOnly,
+			...standalone
+		];
+	});
+	return {
+		documents,
+		pinned: computed(() => documents.value.filter((d) => d.isPinned)),
+		rest: computed(() => documents.value.filter((d) => !d.isPinned))
+	};
+}
+//#endregion
+export { useSidebarDocuments };
+
+//# sourceMappingURL=use-sidebar-documents.js.map

package/dist/v2/features/app/hooks/use-sidebar-documents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sidebar-documents.js","names":[],"sources":["../../../../../src/v2/features/app/hooks/use-sidebar-documents.ts"],"sourcesContent":["import type { AppState } from '@scalar/api-client/v2/features/app'\nimport type { TraversedDocument } from '@scalar/workspace-store/schemas/navigation'\nimport { type MaybeRefOrGetter, computed, toValue } from 'vue'\n\n/**\n * A single \"version\" of a document grouped under a registry namespace + slug.\n * Only used on team workspaces, where multiple local documents may share the\n * same registry coordinates.\n */\nexport type SidebarDocumentVersion = {\n  /** Stable key, matches the workspace document name */\n  key: string\n  /** User facing label for the version */\n  title: string\n  /** Name of the document inside the workspace store */\n  documentName: string\n  /** Traversal tree for the document (if it has been loaded) */\n  navigation?: TraversedDocument\n}\n\n/**\n * A unified item for the top-level of our sidebar.\n *\n * It can represent one of three things:\n *  - A workspace document that only exists locally (no registry link)\n *  - A workspace document that was imported from the registry\n *  - A registry document that has not yet been imported into the store\n */\nexport type SidebarDocumentItem = {\n  /** Stable key used for sidebar state keyed by `namespace/slug` or document name */\n  key: string\n  /** User facing title of the document */\n  title: string\n  /** Name of the document inside the workspace store (if loaded) */\n  documentName?: string\n  /** Registry metadata if available */\n  registry?: { namespace: string; slug: string }\n  /**\n   * Traversal tree for the document if it has been loaded in the workspace store.\n   * When `undefined` the document still needs to be fetched from the registry\n   * before its nested content can be shown.\n   */\n  navigation?: TraversedDocument\n  /** Whether the document is pinned (todo: derived from `x-scalar-pinned`) */\n  isPinned?: boolean\n  /**\n   * TODO: implement versioning logic\n   * Other loaded documents that share this item's `namespace + slug`. Only\n   * populated on team workspaces where we collapse duplicates into a single\n   * entry with multiple versions.\n   */\n  versions?: SidebarDocumentVersion[]\n}\n\ntype WorkspaceDocumentEntry = SidebarDocumentItem & { documentName: string }\n\nexport type RegistryDocument = {\n  namespace: string\n  slug: string\n  title: string\n}\n\n/**\n * Loading-aware wrapper for the registry documents prop.\n *\n * The sidebar uses the `status` to decide whether to render skeleton\n * placeholders while the registry is being fetched. `documents` is optional\n * during loading so callers can either render nothing or stream in cached\n * results while a refresh is still in flight.\n */\nexport type RegistryDocumentsState =\n  | { status: 'loading'; documents?: RegistryDocument[] }\n  | { status: 'success'; documents: RegistryDocument[] }\n\nconst registryKey = (namespace: string, slug: string) => `@${namespace}/${slug}`\n\n/**\n * Builds a unified list of sidebar documents.\n *\n * Behavior:\n *  - Local workspaces (`teamUid === 'local'`) only show workspace documents.\n *    Registry documents are not considered at all.\n *  - Team workspaces group workspace documents by `namespace + slug` from\n *    `x-scalar-registry-meta`. Each unique registry coordinate produces a\n *    single sidebar entry whose additional matches are exposed as `versions`.\n *    Registry documents that have no loaded match are appended as entries\n *    waiting to be fetched.\n */\nexport function useSidebarDocuments({\n  app,\n  managedDocs,\n}: {\n  app: AppState\n  managedDocs: MaybeRefOrGetter<RegistryDocument[]>\n}) {\n  const isTeamWorkspace = app.workspace.isTeamWorkspace\n\n  /** Raw workspace documents mapped to sidebar entries (pre-grouping). */\n  const workspaceEntries = computed<WorkspaceDocumentEntry[]>(() => {\n    const store = app.store.value\n    if (!store) {\n      return []\n    }\n\n    return Object.entries(store.workspace.documents).map(([name, doc]) => {\n      const registry = doc?.['x-scalar-registry-meta']\n      const navigation = doc?.['x-scalar-navigation'] as TraversedDocument | undefined\n\n      const title = navigation?.title || doc?.info?.title || 'Untitled'\n\n      // On team workspaces we key by registry coordinates so entries with the\n      // same `namespace/slug` can later be grouped into a single row with\n      // versions. On local workspaces we always key by the workspace document\n      // name, which is guaranteed to be unique because it is the map key in\n      // `store.workspace.documents`. If we derived the key from registry meta\n      // on local workspaces too, two documents sharing the same\n      // `x-scalar-registry-meta` would produce duplicate Vue `:key`s in the\n      // sidebar `v-for` and silently collide on re-render.\n      const isTeam = isTeamWorkspace.value\n      return {\n        key: isTeam && registry ? registryKey(registry.namespace, registry.slug) : name,\n        title,\n        documentName: name,\n        registry: isTeam && registry ? { namespace: registry.namespace, slug: registry.slug } : undefined,\n        navigation,\n        // TODO: we can implement this later\n        isPinned: false,\n      }\n    })\n  })\n  const documents = computed<SidebarDocumentItem[]>(() => {\n    // Local workspaces: show the workspace document list as-is, no registry\n    // grouping and no registry document lookups.\n    if (!isTeamWorkspace.value) {\n      return workspaceEntries.value\n    }\n\n    const activeDocumentSlug = app.activeEntities.documentSlug.value\n\n    // 1. Bucket workspace documents by their registry `namespace + slug`.\n    //    Documents without registry meta remain standalone entries.\n    const groups = new Map<string, WorkspaceDocumentEntry[]>()\n    const standalone: WorkspaceDocumentEntry[] = []\n\n    for (const entry of workspaceEntries.value) {\n      if (!entry.registry) {\n        standalone.push(entry)\n        continue\n      }\n      const key = registryKey(entry.registry.namespace, entry.registry.slug)\n      const bucket = groups.get(key)\n      if (bucket) {\n        bucket.push(entry)\n      } else {\n        groups.set(key, [entry])\n      }\n    }\n\n    // 2. Collapse each group into a single sidebar entry. The active document\n    //    is promoted to primary when possible so the visible entry matches\n    //    what is currently being viewed. The remaining documents in the\n    //    group become selectable versions.\n    const grouped: SidebarDocumentItem[] = []\n    for (const [, entries] of groups) {\n      const activeIndex = entries.findIndex((e) => e.documentName === activeDocumentSlug)\n      const primaryIndex = activeIndex === -1 ? 0 : activeIndex\n      const primary = entries[primaryIndex]\n      if (!primary) {\n        continue\n      }\n\n      const versions = entries\n        .filter((_, i) => i !== primaryIndex)\n        .map<SidebarDocumentVersion>((e) => ({\n          key: e.documentName,\n          title: e.title,\n          documentName: e.documentName,\n          navigation: e.navigation,\n        }))\n\n      grouped.push({\n        ...primary,\n        isPinned: entries.some((e) => e.isPinned),\n        versions: versions.length ? versions : undefined,\n      })\n    }\n\n    // 3. Merge in registry documents that have no loaded counterpart yet.\n    //    They render as placeholders until the user clicks to fetch them.\n    const loadedKeys = new Set(groups.keys())\n    const registryOnly = toValue(managedDocs)\n      .filter((doc) => !loadedKeys.has(registryKey(doc.namespace, doc.slug)))\n      .map<SidebarDocumentItem>((doc) => ({\n        key: registryKey(doc.namespace, doc.slug),\n        title: doc.title || doc.slug,\n        registry: { namespace: doc.namespace, slug: doc.slug },\n      }))\n\n    return [...grouped, ...registryOnly, ...standalone]\n  })\n\n  const pinned = computed(() => documents.value.filter((d) => d.isPinned))\n  const rest = computed(() => documents.value.filter((d) => !d.isPinned))\n\n  return { documents, pinned, rest }\n}\n"],"mappings":";;AA0EA,IAAM,eAAe,WAAmB,SAAiB,IAAI,UAAU,GAAG;;;;;;;;;;;;;AAc1E,SAAgB,oBAAoB,EAClC,KACA,eAIC;CACD,MAAM,kBAAkB,IAAI,UAAU;;CAGtC,MAAM,mBAAmB,eAAyC;EAChE,MAAM,QAAQ,IAAI,MAAM;AACxB,MAAI,CAAC,MACH,QAAO,EAAE;AAGX,SAAO,OAAO,QAAQ,MAAM,UAAU,UAAU,CAAC,KAAK,CAAC,MAAM,SAAS;GACpE,MAAM,WAAW,MAAM;GACvB,MAAM,aAAa,MAAM;GAEzB,MAAM,QAAQ,YAAY,SAAS,KAAK,MAAM,SAAS;GAUvD,MAAM,SAAS,gBAAgB;AAC/B,UAAO;IACL,KAAK,UAAU,WAAW,YAAY,SAAS,WAAW,SAAS,KAAK,GAAG;IAC3E;IACA,cAAc;IACd,UAAU,UAAU,WAAW;KAAE,WAAW,SAAS;KAAW,MAAM,SAAS;KAAM,GAAG,KAAA;IACxF;IAEA,UAAU;IACX;IACD;GACF;CACF,MAAM,YAAY,eAAsC;AAGtD,MAAI,CAAC,gBAAgB,MACnB,QAAO,iBAAiB;EAG1B,MAAM,qBAAqB,IAAI,eAAe,aAAa;EAI3D,MAAM,yBAAS,IAAI,KAAuC;EAC1D,MAAM,aAAuC,EAAE;AAE/C,OAAK,MAAM,SAAS,iBAAiB,OAAO;AAC1C,OAAI,CAAC,MAAM,UAAU;AACnB,eAAW,KAAK,MAAM;AACtB;;GAEF,MAAM,MAAM,YAAY,MAAM,SAAS,WAAW,MAAM,SAAS,KAAK;GACtE,MAAM,SAAS,OAAO,IAAI,IAAI;AAC9B,OAAI,OACF,QAAO,KAAK,MAAM;OAElB,QAAO,IAAI,KAAK,CAAC,MAAM,CAAC;;EAQ5B,MAAM,UAAiC,EAAE;AACzC,OAAK,MAAM,GAAG,YAAY,QAAQ;GAChC,MAAM,cAAc,QAAQ,WAAW,MAAM,EAAE,iBAAiB,mBAAmB;GACnF,MAAM,eAAe,gBAAgB,KAAK,IAAI;GAC9C,MAAM,UAAU,QAAQ;AACxB,OAAI,CAAC,QACH;GAGF,MAAM,WAAW,QACd,QAAQ,GAAG,MAAM,MAAM,aAAa,CACpC,KAA6B,OAAO;IACnC,KAAK,EAAE;IACP,OAAO,EAAE;IACT,cAAc,EAAE;IAChB,YAAY,EAAE;IACf,EAAE;AAEL,WAAQ,KAAK;IACX,GAAG;IACH,UAAU,QAAQ,MAAM,MAAM,EAAE,SAAS;IACzC,UAAU,SAAS,SAAS,WAAW,KAAA;IACxC,CAAC;;EAKJ,MAAM,aAAa,IAAI,IAAI,OAAO,MAAM,CAAC;EACzC,MAAM,eAAe,QAAQ,YAAY,CACtC,QAAQ,QAAQ,CAAC,WAAW,IAAI,YAAY,IAAI,WAAW,IAAI,KAAK,CAAC,CAAC,CACtE,KAA0B,SAAS;GAClC,KAAK,YAAY,IAAI,WAAW,IAAI,KAAK;GACzC,OAAO,IAAI,SAAS,IAAI;GACxB,UAAU;IAAE,WAAW,IAAI;IAAW,MAAM,IAAI;IAAM;GACvD,EAAE;AAEL,SAAO;GAAC,GAAG;GAAS,GAAG;GAAc,GAAG;GAAW;GACnD;AAKF,QAAO;EAAE;EAAW,QAHL,eAAe,UAAU,MAAM,QAAQ,MAAM,EAAE,SAAS,CAAC;EAG5C,MAFf,eAAe,UAAU,MAAM,QAAQ,MAAM,CAAC,EAAE,SAAS,CAAC;EAErC"}

package/dist/v2/features/app/index.d.ts

@@ -6,4 +6,5 @@ export type { ClientLayout } from '../../../v2/types/layout';
 export { type CommandPaletteAction, type CommandPaletteRoute, baseClientActions, baseRoutes, useCommandPaletteState, } from '../command-palette/hooks/use-command-palette-state.js';
 export { default as ClientApp } from './App.vue.js';
 export { createApiClientApp, createAppRouter } from './helpers/create-api-client-app.js';
+export type { RegistryDocumentsState } from './hooks/use-sidebar-documents.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/v2/features/app/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2/features/app/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC3E,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,uDAAuD,CAAA;AACvG,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,gEAAgE,CAAA;AAC7G,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,iEAAiE,CAAA;AAC/G,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,iBAAiB,EACjB,UAAU,EACV,sBAAsB,GACvB,MAAM,oDAAoD,CAAA;AAC3D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2/features/app/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC3E,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,uDAAuD,CAAA;AACvG,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,gEAAgE,CAAA;AAC7G,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,iEAAiE,CAAA;AAC/G,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,iBAAiB,EACjB,UAAU,EACV,sBAAsB,GACvB,MAAM,oDAAoD,CAAA;AAC3D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACrF,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA"}

package/dist/v2/features/collection/components/GetStarted.vue.d.ts

@@ -0,0 +1,13 @@
+import type { RouteProps } from '../../../../v2/features/app/helpers/routes.js';
+/**
+ * Workspace get started page.
+ *
+ * Shown as the landing view for a workspace with no request selected. Displays
+ * an ASCII art mark and a short list of keyboard shortcuts to help the user
+ * bootstrap their workspace (open the command palette, jump to settings, or
+ * focus the sidebar filter).
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<RouteProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<RouteProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+//# sourceMappingURL=GetStarted.vue.d.ts.map

package/dist/v2/features/collection/components/GetStarted.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetStarted.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/collection/components/GetStarted.vue"],"names":[],"mappings":"AA8GA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAGlE;;;;;;;GAOG;wBACkB,OAAO,YAAY;AAAxC,wBAAyC;AAGzC,QAAA,MAAM,YAAY,gSAwMd,CAAC"}

package/dist/v2/features/collection/components/GetStarted.vue.js

@@ -0,0 +1,7 @@
+import GetStarted_vue_vue_type_script_setup_true_lang_default from "./GetStarted.vue.script.js";
+//#region src/v2/features/collection/components/GetStarted.vue
+var GetStarted_default = GetStarted_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { GetStarted_default as default };
+
+//# sourceMappingURL=GetStarted.vue.js.map

package/dist/v2/features/collection/components/GetStarted.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetStarted.vue.js","names":[],"sources":["../../../../../src/v2/features/collection/components/GetStarted.vue"],"sourcesContent":["<script lang=\"ts\">\n/**\n * Workspace get started page.\n *\n * Shown as the landing view for a workspace with no request selected. Displays\n * an ASCII art mark and a short list of keyboard shortcuts to help the user\n * bootstrap their workspace (open the command palette, jump to settings, or\n * focus the sidebar filter).\n */\nexport default {}\n</script>\n\n<script setup lang=\"ts\">\nimport { ScalarHotkey } from '@scalar/components'\nimport { ScalarIconDownloadSimple } from '@scalar/icons'\n\nimport Computer from '@/assets/computer.ascii?raw'\nimport ScalarAsciiArt from '@/components/ScalarAsciiArt.vue'\nimport type { RouteProps } from '@/v2/features/app/helpers/routes'\n\nconst { eventBus, layout } = defineProps<RouteProps>()\n\nconst openCommandPalette = () => {\n  eventBus.emit('ui:open:command-palette')\n}\n\n/**\n * Open the contextual settings page. Emits the same event as the Cmd/Ctrl+I\n * hotkey so the workspace sidebar handles it uniformly: workspace-level\n * settings from this \"Get started\" screen, document-level settings when the\n * user is viewing a specific document. No `KeyboardEvent` is attached here\n * because the trigger is a click.\n */\nconst openSettings = () => {\n  eventBus.emit('ui:open:settings')\n}\n\n/**\n * Open the contextual search affordance. Emits the same event as the Cmd/Ctrl+J\n * hotkey so the workspace sidebar handles it uniformly: the document filter\n * toggles on the workspace page and the search modal opens inside a document.\n * No `KeyboardEvent` is attached here because the trigger is a click.\n */\nconst focusSearch = () => {\n  eventBus.emit('ui:focus:search')\n}\n</script>\n\n<template>\n  <div class=\"flex h-full w-full flex-col items-center justify-center p-6\">\n    <div class=\"flex flex-col items-stretch gap-10\">\n      <ScalarAsciiArt\n        :art=\"Computer\"\n        class=\"text-c-3 self-center\" />\n\n      <div class=\"text-c-2 flex flex-col gap-3 text-sm\">\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"openCommandPalette\">\n          <span>Get Started</span>\n          <ScalarHotkey\n            hotkey=\"K\"\n            :modifier=\"['default']\" />\n        </button>\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"openSettings\">\n          <span>Settings</span>\n          <ScalarHotkey\n            hotkey=\"I\"\n            :modifier=\"['default']\" />\n        </button>\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"focusSearch\">\n          <span>Filter</span>\n          <ScalarHotkey\n            hotkey=\"J\"\n            :modifier=\"['default']\" />\n        </button>\n        <!--\n          Browser-only nudge to install the desktop app. Hidden in the desktop\n          and modal layouts because the user is already running the native app\n          (or embedded in a host page).\n        -->\n        <a\n          v-if=\"layout === 'web'\"\n          class=\"text-c-2 hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          href=\"https://scalar.com/download?utm_source=web_client&utm_medium=download_button&utm_campaign=topnav\"\n          target=\"_blank\">\n          <span>Download App</span>\n          <ScalarIconDownloadSimple\n            class=\"size-3.5\"\n            weight=\"bold\" />\n        </a>\n      </div>\n    </div>\n  </div>\n</template>\n"],"mappings":""}

package/dist/v2/features/collection/components/GetStarted.vue.script.js

@@ -0,0 +1,101 @@
+import computer_default from "../../../../assets/computer.ascii.virtual.js";
+import ScalarAsciiArt_default from "../../../../components/ScalarAsciiArt.vue.js";
+import { createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, openBlock, unref } from "vue";
+import { ScalarHotkey } from "@scalar/components";
+import { ScalarIconDownloadSimple } from "@scalar/icons";
+//#region src/v2/features/collection/components/GetStarted.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "flex h-full w-full flex-col items-center justify-center p-6" };
+var _hoisted_2 = { class: "flex flex-col items-stretch gap-10" };
+var _hoisted_3 = { class: "text-c-2 flex flex-col gap-3 text-sm" };
+var _hoisted_4 = {
+	key: 0,
+	class: "text-c-2 hover:text-c-1 flex w-full items-center justify-between gap-8",
+	href: "https://scalar.com/download?utm_source=web_client&utm_medium=download_button&utm_campaign=topnav",
+	target: "_blank"
+};
+var GetStarted_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "GetStarted",
+	props: {
+		documentSlug: {},
+		document: {},
+		eventBus: {},
+		layout: {},
+		path: {},
+		method: {},
+		exampleName: {},
+		environment: {},
+		workspaceStore: {},
+		activeWorkspace: {},
+		plugins: {},
+		customThemes: {},
+		currentTheme: {},
+		isDarkMode: { type: Boolean },
+		fetchRegistryDocument: { type: Function },
+		telemetry: { type: Boolean },
+		onUpdateTelemetry: { type: Function },
+		options: {}
+	},
+	setup(__props) {
+		const openCommandPalette = () => {
+			__props.eventBus.emit("ui:open:command-palette");
+		};
+		/**
+		* Open the contextual settings page. Emits the same event as the Cmd/Ctrl+I
+		* hotkey so the workspace sidebar handles it uniformly: workspace-level
+		* settings from this "Get started" screen, document-level settings when the
+		* user is viewing a specific document. No `KeyboardEvent` is attached here
+		* because the trigger is a click.
+		*/
+		const openSettings = () => {
+			__props.eventBus.emit("ui:open:settings");
+		};
+		/**
+		* Open the contextual search affordance. Emits the same event as the Cmd/Ctrl+J
+		* hotkey so the workspace sidebar handles it uniformly: the document filter
+		* toggles on the workspace page and the search modal opens inside a document.
+		* No `KeyboardEvent` is attached here because the trigger is a click.
+		*/
+		const focusSearch = () => {
+			__props.eventBus.emit("ui:focus:search");
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [createElementVNode("div", _hoisted_2, [createVNode(ScalarAsciiArt_default, {
+				art: unref(computer_default),
+				class: "text-c-3 self-center"
+			}, null, 8, ["art"]), createElementVNode("div", _hoisted_3, [
+				createElementVNode("button", {
+					class: "hover:text-c-1 flex w-full items-center justify-between gap-8",
+					type: "button",
+					onClick: openCommandPalette
+				}, [_cache[0] || (_cache[0] = createElementVNode("span", null, "Get Started", -1)), createVNode(unref(ScalarHotkey), {
+					hotkey: "K",
+					modifier: ["default"]
+				})]),
+				createElementVNode("button", {
+					class: "hover:text-c-1 flex w-full items-center justify-between gap-8",
+					type: "button",
+					onClick: openSettings
+				}, [_cache[1] || (_cache[1] = createElementVNode("span", null, "Settings", -1)), createVNode(unref(ScalarHotkey), {
+					hotkey: "I",
+					modifier: ["default"]
+				})]),
+				createElementVNode("button", {
+					class: "hover:text-c-1 flex w-full items-center justify-between gap-8",
+					type: "button",
+					onClick: focusSearch
+				}, [_cache[2] || (_cache[2] = createElementVNode("span", null, "Filter", -1)), createVNode(unref(ScalarHotkey), {
+					hotkey: "J",
+					modifier: ["default"]
+				})]),
+				__props.layout === "web" ? (openBlock(), createElementBlock("a", _hoisted_4, [_cache[3] || (_cache[3] = createElementVNode("span", null, "Download App", -1)), createVNode(unref(ScalarIconDownloadSimple), {
+					class: "size-3.5",
+					weight: "bold"
+				})])) : createCommentVNode("", true)
+			])])]);
+		};
+	}
+});
+//#endregion
+export { GetStarted_vue_vue_type_script_setup_true_lang_default as default };
+
+//# sourceMappingURL=GetStarted.vue.script.js.map

package/dist/v2/features/collection/components/GetStarted.vue.script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetStarted.vue.script.js","names":[],"sources":["../../../../../src/v2/features/collection/components/GetStarted.vue"],"sourcesContent":["<script lang=\"ts\">\n/**\n * Workspace get started page.\n *\n * Shown as the landing view for a workspace with no request selected. Displays\n * an ASCII art mark and a short list of keyboard shortcuts to help the user\n * bootstrap their workspace (open the command palette, jump to settings, or\n * focus the sidebar filter).\n */\nexport default {}\n</script>\n\n<script setup lang=\"ts\">\nimport { ScalarHotkey } from '@scalar/components'\nimport { ScalarIconDownloadSimple } from '@scalar/icons'\n\nimport Computer from '@/assets/computer.ascii?raw'\nimport ScalarAsciiArt from '@/components/ScalarAsciiArt.vue'\nimport type { RouteProps } from '@/v2/features/app/helpers/routes'\n\nconst { eventBus, layout } = defineProps<RouteProps>()\n\nconst openCommandPalette = () => {\n  eventBus.emit('ui:open:command-palette')\n}\n\n/**\n * Open the contextual settings page. Emits the same event as the Cmd/Ctrl+I\n * hotkey so the workspace sidebar handles it uniformly: workspace-level\n * settings from this \"Get started\" screen, document-level settings when the\n * user is viewing a specific document. No `KeyboardEvent` is attached here\n * because the trigger is a click.\n */\nconst openSettings = () => {\n  eventBus.emit('ui:open:settings')\n}\n\n/**\n * Open the contextual search affordance. Emits the same event as the Cmd/Ctrl+J\n * hotkey so the workspace sidebar handles it uniformly: the document filter\n * toggles on the workspace page and the search modal opens inside a document.\n * No `KeyboardEvent` is attached here because the trigger is a click.\n */\nconst focusSearch = () => {\n  eventBus.emit('ui:focus:search')\n}\n</script>\n\n<template>\n  <div class=\"flex h-full w-full flex-col items-center justify-center p-6\">\n    <div class=\"flex flex-col items-stretch gap-10\">\n      <ScalarAsciiArt\n        :art=\"Computer\"\n        class=\"text-c-3 self-center\" />\n\n      <div class=\"text-c-2 flex flex-col gap-3 text-sm\">\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"openCommandPalette\">\n          <span>Get Started</span>\n          <ScalarHotkey\n            hotkey=\"K\"\n            :modifier=\"['default']\" />\n        </button>\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"openSettings\">\n          <span>Settings</span>\n          <ScalarHotkey\n            hotkey=\"I\"\n            :modifier=\"['default']\" />\n        </button>\n        <button\n          class=\"hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          type=\"button\"\n          @click=\"focusSearch\">\n          <span>Filter</span>\n          <ScalarHotkey\n            hotkey=\"J\"\n            :modifier=\"['default']\" />\n        </button>\n        <!--\n          Browser-only nudge to install the desktop app. Hidden in the desktop\n          and modal layouts because the user is already running the native app\n          (or embedded in a host page).\n        -->\n        <a\n          v-if=\"layout === 'web'\"\n          class=\"text-c-2 hover:text-c-1 flex w-full items-center justify-between gap-8\"\n          href=\"https://scalar.com/download?utm_source=web_client&utm_medium=download_button&utm_campaign=topnav\"\n          target=\"_blank\">\n          <span>Download App</span>\n          <ScalarIconDownloadSimple\n            class=\"size-3.5\"\n            weight=\"bold\" />\n        </a>\n      </div>\n    </div>\n  </div>\n</template>\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBA,MAAM,2BAA2B;AAC/B,WAAA,SAAS,KAAK,0BAAyB;;;;;;;;;EAUzC,MAAM,qBAAqB;AACzB,WAAA,SAAS,KAAK,mBAAkB;;;;;;;;EASlC,MAAM,oBAAoB;AACxB,WAAA,SAAS,KAAK,kBAAiB;;;uBAK/B,mBAmDM,OAnDN,YAmDM,CAlDJ,mBAiDM,OAjDN,YAiDM,CAhDJ,YAEiC,wBAAA;IAD9B,KAAK,MAAA,iBAAQ;IACd,OAAM;yBAER,mBA2CM,OA3CN,YA2CM;IA1CJ,mBAQS,UAAA;KAPP,OAAM;KACN,MAAK;KACJ,SAAO;kCACR,mBAAwB,QAAA,MAAlB,eAAW,GAAA,GACjB,YAE4B,MAAA,aAAA,EAAA;KAD1B,QAAO;KACN,UAAU,CAAA,UAAW;;IAE1B,mBAQS,UAAA;KAPP,OAAM;KACN,MAAK;KACJ,SAAO;kCACR,mBAAqB,QAAA,MAAf,YAAQ,GAAA,GACd,YAE4B,MAAA,aAAA,EAAA;KAD1B,QAAO;KACN,UAAU,CAAA,UAAW;;IAE1B,mBAQS,UAAA;KAPP,OAAM;KACN,MAAK;KACJ,SAAO;kCACR,mBAAmB,QAAA,MAAb,UAAM,GAAA,GACZ,YAE4B,MAAA,aAAA,EAAA;KAD1B,QAAO;KACN,UAAU,CAAA,UAAW;;IAQlB,QAAA,WAAM,SAAA,WAAA,EADd,mBASI,KATJ,YASI,CAAA,OAAA,OAAA,OAAA,KAJF,mBAAyB,QAAA,MAAnB,gBAAY,GAAA,GAClB,YAEkB,MAAA,yBAAA,EAAA;KADhB,OAAM;KACN,QAAO"}

package/dist/v2/features/command-palette/helpers/generate-unique-slug.d.ts

@@ -7,6 +7,10 @@
  * The function will retry up to 100 times to find a unique slug. If all attempts fail,
  * it returns null, which should be handled as an import error.
  *
+ * When the input is missing or contains only whitespace, it falls back to
+ * `'default'` so the workspace store never ends up with a document keyed by an
+ * empty string (for example, when a registry document has no `info.title`).
+ *
  * @param defaultValue - The original document title to base the slug on
  * @param currentDocuments - Set of existing document slugs to check against
  *

package/dist/v2/features/command-palette/helpers/generate-unique-slug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-unique-slug.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/generate-unique-slug.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAAU,cAAc,MAAM,GAAG,SAAS,EAAE,kBAAkB,GAAG,CAAC,MAAM,CAAC,gCAOvG,CAAA"}
+{"version":3,"file":"generate-unique-slug.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/generate-unique-slug.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAAU,cAAc,MAAM,GAAG,SAAS,EAAE,kBAAkB,GAAG,CAAC,MAAM,CAAC,gCASvG,CAAA"}

package/dist/v2/features/command-palette/helpers/generate-unique-slug.js

@@ -10,6 +10,10 @@ import { generateUniqueValue } from "@scalar/workspace-store/helpers/generate-un
 * The function will retry up to 100 times to find a unique slug. If all attempts fail,
 * it returns null, which should be handled as an import error.
 *
+* When the input is missing or contains only whitespace, it falls back to
+* `'default'` so the workspace store never ends up with a document keyed by an
+* empty string (for example, when a registry document has no `info.title`).
+*
 * @param defaultValue - The original document title to base the slug on
 * @param currentDocuments - Set of existing document slugs to check against
 *
@@ -17,7 +21,7 @@ import { generateUniqueValue } from "@scalar/workspace-store/helpers/generate-un
 */
 var generateUniqueSlug = async (defaultValue, currentDocuments) => {
 	return await generateUniqueValue({
-		defaultValue: defaultValue ?? "default",
+		defaultValue: defaultValue?.trim() || "default",
 		validation: (value) => !currentDocuments.has(value),
 		maxRetries: 100,
 		transformation: slugify

package/dist/v2/features/command-palette/helpers/generate-unique-slug.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate-unique-slug.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/generate-unique-slug.ts"],"sourcesContent":["import { generateUniqueValue } from '@scalar/workspace-store/helpers/generate-unique-value'\n\nimport { slugify } from '@/v2/helpers/slugify'\n\n/**\n * Generates a unique slug for an imported document based on its title.\n *\n * This ensures the imported document does not conflict with existing documents\n * by appending a number suffix if necessary (e.g., \"my-api\", \"my-api-1\", \"my-api-2\").\n *\n * The function will retry up to 100 times to find a unique slug. If all attempts fail,\n * it returns null, which should be handled as an import error.\n *\n * @param defaultValue - The original document title to base the slug on\n * @param currentDocuments - Set of existing document slugs to check against\n *\n * @returns Promise resolving to a unique slug, or null if unable to generate one\n */\nexport const generateUniqueSlug = async (defaultValue: string | undefined, currentDocuments: Set<string>) => {\n  return await generateUniqueValue({\n    defaultValue: defaultValue ?? 'default',\n    validation: (value) => !currentDocuments.has(value),\n    maxRetries: 100,\n    transformation: slugify,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,IAAa,qBAAqB,OAAO,cAAkC,qBAAkC;AAC3G,QAAO,MAAM,oBAAoB;EAC/B,cAAc,gBAAgB;EAC9B,aAAa,UAAU,CAAC,iBAAiB,IAAI,MAAM;EACnD,YAAY;EACZ,gBAAgB;EACjB,CAAC"}
+{"version":3,"file":"generate-unique-slug.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/generate-unique-slug.ts"],"sourcesContent":["import { generateUniqueValue } from '@scalar/workspace-store/helpers/generate-unique-value'\n\nimport { slugify } from '@/v2/helpers/slugify'\n\n/**\n * Generates a unique slug for an imported document based on its title.\n *\n * This ensures the imported document does not conflict with existing documents\n * by appending a number suffix if necessary (e.g., \"my-api\", \"my-api-1\", \"my-api-2\").\n *\n * The function will retry up to 100 times to find a unique slug. If all attempts fail,\n * it returns null, which should be handled as an import error.\n *\n * When the input is missing or contains only whitespace, it falls back to\n * `'default'` so the workspace store never ends up with a document keyed by an\n * empty string (for example, when a registry document has no `info.title`).\n *\n * @param defaultValue - The original document title to base the slug on\n * @param currentDocuments - Set of existing document slugs to check against\n *\n * @returns Promise resolving to a unique slug, or null if unable to generate one\n */\nexport const generateUniqueSlug = async (defaultValue: string | undefined, currentDocuments: Set<string>) => {\n  const base = defaultValue?.trim() || 'default'\n\n  return await generateUniqueValue({\n    defaultValue: base,\n    validation: (value) => !currentDocuments.has(value),\n    maxRetries: 100,\n    transformation: slugify,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,qBAAqB,OAAO,cAAkC,qBAAkC;AAG3G,QAAO,MAAM,oBAAoB;EAC/B,cAHW,cAAc,MAAM,IAAI;EAInC,aAAa,UAAU,CAAC,iBAAiB,IAAI,MAAM;EACnD,YAAY;EACZ,gBAAgB;EACjB,CAAC"}

package/dist/v2/features/search/components/DocumentSearchModal.vue.d.ts

@@ -0,0 +1,16 @@
+import { type ModalState } from '@scalar/components';
+import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+type __VLS_Props = {
+    /** Controls the visibility of the search modal. */
+    modalState: ModalState;
+    /** The document whose entries should be searched. */
+    document: OpenApiDocument | undefined;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    select: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;
+//# sourceMappingURL=DocumentSearchModal.vue.d.ts.map

package/dist/v2/features/search/components/DocumentSearchModal.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentSearchModal.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/search/components/DocumentSearchModal.vue"],"names":[],"mappings":"AA4JA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAQnG,KAAK,WAAW,GAAG;IACjB,mDAAmD;IACnD,UAAU,EAAE,UAAU,CAAA;IACtB,qDAAqD;IACrD,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAA;CACtC,CAAC;AAgQF,QAAA,MAAM,YAAY;;;;kFAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}