@scalar/api-client 3.6.1 → 3.8.0

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

@@ -1 +0,0 @@
-{"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

@@ -1,107 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,119 +0,0 @@
-import type { AppState } from '@scalar/api-client/v2/features/app';
-import type { TraversedDocument } from '@scalar/workspace-store/schemas/navigation';
-import { type MaybeRefOrGetter } from 'vue';
-import { type VersionStatus } from '../../../../v2/features/app/helpers/compute-version-status.js';
-import type { RegistryDocument } from '../../../../v2/types/configuration';
-export type { VersionStatus };
-/**
- * A single version of a registry-backed document.
- *
- * On team workspaces, a registry document can advertise multiple versions and
- * each one may or may not have been imported into the local workspace store.
- * Loaded versions surface their `documentName` and traversal `navigation`,
- * unloaded versions are placeholders the sidebar can fetch on demand.
- */
-export type SidebarDocumentVersion = {
-    /** Stable key: workspace `documentName` when loaded, otherwise `${namespace}/${slug}@${version}`. */
-    key: string;
-    /** Version identifier as advertised by the registry. */
-    version: string;
-    /** User-facing label for the version row. */
-    title: string;
-    /** Workspace store document name when this version is loaded locally. */
-    documentName?: string;
-    /**
-     * Commit hash recorded on the locally loaded workspace document, if any.
-     * Undefined when the version has not been imported into the workspace
-     * store or when the loaded document does not carry a hash.
-     */
-    commitHash?: string;
-    /**
-     * Commit hash advertised by the registry for this version, if any.
-     * Compared against `commitHash` to derive `status`.
-     */
-    registryCommitHash?: string;
-    /**
-     * Sync status surfaced for the version row. Derived from the local /
-     * registry commit hashes, the document's dirty flag and the cached
-     * conflict-check result on `x-scalar-registry-meta`. `unknown` is used
-     * for versions that are not loaded into the workspace store yet.
-     */
-    status: VersionStatus;
-    /**
-     * True when this row is the canonical "latest" version of the group: the
-     * first version the registry advertises. Drafts (locally-created versions
-     * the registry has not seen yet) never get this flag, even when they are
-     * surfaced ahead of the registry-advertised rows in the picker.
-     */
-    isLatest: boolean;
-    /** Traversal tree for this version. Populated only when the version is loaded into the workspace store. */
-    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
- *
- * For registry-backed entries, the parent fields (`navigation`, `documentName`)
- * mirror the active version so the sidebar template can render a single tree
- * without having to look up the active version itself. The full version list
- * lives in `versions`.
- */
-export type SidebarDocumentItem = {
-    /** Stable key used for sidebar state: `@namespace/slug` for registry-backed entries, document name otherwise. */
-    key: string;
-    /**
-     * User-facing title of the document. Registry-backed entries always surface
-     * the registry's title so the sidebar matches what the registry advertises,
-     * even when a locally loaded copy has been renamed. Standalone entries use
-     * the workspace document title.
-     */
-    title: string;
-    /** Name of the document inside the workspace store (mirrors the active version on registry-backed entries). */
-    documentName?: string;
-    /** Registry coordinates for the document group (without the version, which lives on `versions[]`). */
-    registry?: {
-        namespace: string;
-        slug: string;
-    };
-    /** Traversal tree of the active version (or the lone document for standalone entries). */
-    navigation?: TraversedDocument;
-    /** Whether the document is pinned (todo: derived from `x-scalar-pinned`) */
-    isPinned?: boolean;
-    /**
-     * All known versions of the document, ordered with the registry's ordering
-     * preserved (latest first by convention). Loaded versions surface their
-     * workspace `documentName` and `navigation`, unloaded ones act as
-     * placeholders the sidebar can fetch on demand. Undefined for standalone
-     * entries that have no registry coordinates.
-     */
-    versions?: SidebarDocumentVersion[];
-    /** Key of the version currently surfaced at the parent level (matches a `versions[].key`). */
-    activeVersionKey?: string;
-};
-/**
- * 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 versions are exposed as `versions`. The
- *    `versions` array merges the registry-advertised versions with any
- *    loaded workspace counterparts (matched by `version`). Registry
- *    documents that have no loaded match are still surfaced 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

@@ -1 +0,0 @@
-{"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,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kDAAkD,CAAA;AAC3G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,YAAY,EAAE,aAAa,EAAE,CAAA;AAE7B;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,qGAAqG;IACrG,GAAG,EAAE,MAAM,CAAA;IACX,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAA;IACf,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;;OAKG;IACH,MAAM,EAAE,aAAa,CAAA;IACrB;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB,2GAA2G;IAC3G,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,iHAAiH;IACjH,GAAG,EAAE,MAAM,CAAA;IACX;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,+GAA+G;IAC/G,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,sGAAsG;IACtG,QAAQ,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C,0FAA0F;IAC1F,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,sBAAsB,EAAE,CAAA;IACnC,8FAA8F;IAC9F,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AA0BD;;;;;;;;;;;;;GAaG;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+HA"}

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

@@ -1,219 +0,0 @@
-import { computeVersionStatus } from "../helpers/compute-version-status.js";
-import { computed, toValue } from "vue";
-//#region src/v2/features/app/hooks/use-sidebar-documents.ts
-var registryKey = (namespace, slug) => `@${namespace}/${slug}`;
-var versionKey = (namespace, slug, version) => `${registryKey(namespace, slug)}@${version}`;
-/**
-* 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 versions are exposed as `versions`. The
-*    `versions` array merges the registry-advertised versions with any
-*    loaded workspace counterparts (matched by `version`). Registry
-*    documents that have no loaded match are still surfaced as entries
-*    waiting to be fetched.
-*/
-function useSidebarDocuments({ app, managedDocs }) {
-	const isTeamWorkspace = app.workspace.isTeamWorkspace;
-	/** Raw workspace documents projected into the shape the grouping logic needs. */
-	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"];
-			return {
-				documentName: name,
-				title: navigation?.title || doc?.info?.title || "Untitled",
-				navigation,
-				isPinned: false,
-				isDirty: doc?.["x-scalar-is-dirty"] === true,
-				registry: registry ? {
-					namespace: registry.namespace,
-					slug: registry.slug,
-					version: registry.version,
-					commitHash: registry.commitHash,
-					conflictCheckedAgainstHash: registry.conflictCheckedAgainstHash,
-					hasConflict: registry.hasConflict
-				} : void 0
-			};
-		});
-	});
-	const documents = computed(() => {
-		if (!isTeamWorkspace.value) return workspaceEntries.value.map((entry) => ({
-			key: entry.documentName,
-			title: entry.title,
-			documentName: entry.documentName,
-			registry: void 0,
-			navigation: entry.navigation,
-			isPinned: entry.isPinned ?? false
-		}));
-		const activeDocumentSlug = app.activeEntities.documentSlug.value;
-		const workspaceByRegistry = /* @__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 = workspaceByRegistry.get(key);
-			if (bucket) bucket.push(entry);
-			else workspaceByRegistry.set(key, [entry]);
-		}
-		const grouped = [];
-		const consumedRegistryKeys = /* @__PURE__ */ new Set();
-		for (const doc of toValue(managedDocs)) {
-			const key = registryKey(doc.namespace, doc.slug);
-			consumedRegistryKeys.add(key);
-			const item = buildRegistryItem({
-				key,
-				registry: doc,
-				loaded: workspaceByRegistry.get(key) ?? [],
-				activeDocumentSlug
-			});
-			if (item) grouped.push(item);
-		}
-		for (const [key, loaded] of workspaceByRegistry) {
-			if (consumedRegistryKeys.has(key)) continue;
-			const first = loaded[0]?.registry;
-			if (!first) continue;
-			const item = buildRegistryItem({
-				key,
-				registry: {
-					namespace: first.namespace,
-					slug: first.slug,
-					title: loaded[0]?.title ?? first.slug,
-					versions: []
-				},
-				loaded,
-				activeDocumentSlug
-			});
-			if (item) grouped.push(item);
-		}
-		return [...grouped, ...standalone.map(toStandaloneItem)];
-	});
-	return {
-		documents,
-		pinned: computed(() => documents.value.filter((d) => d.isPinned)),
-		rest: computed(() => documents.value.filter((d) => !d.isPinned))
-	};
-}
-/** Project a standalone (non-registry) workspace entry into a sidebar item. */
-var toStandaloneItem = (entry) => ({
-	key: entry.documentName,
-	title: entry.title,
-	documentName: entry.documentName,
-	registry: void 0,
-	navigation: entry.navigation,
-	isPinned: entry.isPinned ?? false
-});
-/**
-* Build a single registry-backed sidebar item. The version list is assembled
-* by walking the registry's advertised versions in order and pairing them
-* with any loaded workspace document that claims the same `version` string.
-* Loaded versions that the registry has not advertised are appended at the
-* end so they stay visible until the registry catches up.
-*/
-var buildRegistryItem = ({ key, registry, loaded, activeDocumentSlug }) => {
-	const loadedByVersion = /* @__PURE__ */ new Map();
-	const orphans = [];
-	for (const entry of loaded) {
-		const version = entry.registry?.version;
-		if (!version) {
-			orphans.push(entry);
-			continue;
-		}
-		if (loadedByVersion.has(version)) {
-			orphans.push(entry);
-			continue;
-		}
-		loadedByVersion.set(version, entry);
-	}
-	const versions = [];
-	const groupTitle = registry.title || registry.slug;
-	const draftEntries = [];
-	for (const [version, match] of loadedByVersion) {
-		if (registry.versions.some((v) => v.version === version)) continue;
-		draftEntries.push([version, match]);
-	}
-	draftEntries.reverse();
-	for (const [version, match] of draftEntries) versions.push({
-		key: match.documentName,
-		version,
-		title: groupTitle,
-		documentName: match.documentName,
-		commitHash: match.registry?.commitHash,
-		registryCommitHash: void 0,
-		status: computeVersionStatus({
-			isLoaded: true,
-			localHash: match.registry?.commitHash,
-			registryHash: void 0,
-			isDirty: match.isDirty
-		}),
-		isLatest: false,
-		navigation: match.navigation
-	});
-	registry.versions.forEach((v, registryIndex) => {
-		const match = loadedByVersion.get(v.version);
-		const localHash = match?.registry?.commitHash;
-		const registryHash = v.commitHash;
-		versions.push({
-			key: match ? match.documentName : versionKey(registry.namespace, registry.slug, v.version),
-			version: v.version,
-			title: groupTitle,
-			documentName: match?.documentName,
-			commitHash: localHash,
-			registryCommitHash: registryHash,
-			status: computeVersionStatus({
-				isLoaded: Boolean(match),
-				localHash,
-				registryHash,
-				isDirty: match?.isDirty,
-				conflictCheckedAgainstHash: match?.registry?.conflictCheckedAgainstHash,
-				hasConflict: match?.registry?.hasConflict
-			}),
-			isLatest: registryIndex === 0,
-			navigation: match?.navigation
-		});
-	});
-	for (const orphan of orphans) versions.push({
-		key: orphan.documentName,
-		version: orphan.registry?.version ?? "",
-		title: groupTitle,
-		documentName: orphan.documentName,
-		commitHash: orphan.registry?.commitHash,
-		registryCommitHash: void 0,
-		status: computeVersionStatus({
-			isLoaded: true,
-			localHash: orphan.registry?.commitHash,
-			registryHash: void 0,
-			isDirty: orphan.isDirty
-		}),
-		isLatest: false,
-		navigation: orphan.navigation
-	});
-	if (versions.length === 0) return;
-	const activeVersion = versions.find((v) => v.documentName !== void 0 && v.documentName === activeDocumentSlug) ?? versions.find((v) => v.documentName !== void 0) ?? versions[0];
-	return {
-		key,
-		title: groupTitle,
-		documentName: activeVersion.documentName,
-		registry: {
-			namespace: registry.namespace,
-			slug: registry.slug
-		},
-		navigation: activeVersion.navigation,
-		isPinned: loaded.some((e) => e.isPinned),
-		versions,
-		activeVersionKey: activeVersion.key
-	};
-};
-//#endregion
-export { useSidebarDocuments };
-
-//# sourceMappingURL=use-sidebar-documents.js.map

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

@@ -1 +0,0 @@
-{"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\nimport { type VersionStatus, computeVersionStatus } from '@/v2/features/app/helpers/compute-version-status'\nimport type { RegistryDocument } from '@/v2/types/configuration'\n\nexport type { VersionStatus }\n\n/**\n * A single version of a registry-backed document.\n *\n * On team workspaces, a registry document can advertise multiple versions and\n * each one may or may not have been imported into the local workspace store.\n * Loaded versions surface their `documentName` and traversal `navigation`,\n * unloaded versions are placeholders the sidebar can fetch on demand.\n */\nexport type SidebarDocumentVersion = {\n  /** Stable key: workspace `documentName` when loaded, otherwise `${namespace}/${slug}@${version}`. */\n  key: string\n  /** Version identifier as advertised by the registry. */\n  version: string\n  /** User-facing label for the version row. */\n  title: string\n  /** Workspace store document name when this version is loaded locally. */\n  documentName?: string\n  /**\n   * Commit hash recorded on the locally loaded workspace document, if any.\n   * Undefined when the version has not been imported into the workspace\n   * store or when the loaded document does not carry a hash.\n   */\n  commitHash?: string\n  /**\n   * Commit hash advertised by the registry for this version, if any.\n   * Compared against `commitHash` to derive `status`.\n   */\n  registryCommitHash?: string\n  /**\n   * Sync status surfaced for the version row. Derived from the local /\n   * registry commit hashes, the document's dirty flag and the cached\n   * conflict-check result on `x-scalar-registry-meta`. `unknown` is used\n   * for versions that are not loaded into the workspace store yet.\n   */\n  status: VersionStatus\n  /**\n   * True when this row is the canonical \"latest\" version of the group: the\n   * first version the registry advertises. Drafts (locally-created versions\n   * the registry has not seen yet) never get this flag, even when they are\n   * surfaced ahead of the registry-advertised rows in the picker.\n   */\n  isLatest: boolean\n  /** Traversal tree for this version. Populated only when the version is loaded into the workspace store. */\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 *\n * For registry-backed entries, the parent fields (`navigation`, `documentName`)\n * mirror the active version so the sidebar template can render a single tree\n * without having to look up the active version itself. The full version list\n * lives in `versions`.\n */\nexport type SidebarDocumentItem = {\n  /** Stable key used for sidebar state: `@namespace/slug` for registry-backed entries, document name otherwise. */\n  key: string\n  /**\n   * User-facing title of the document. Registry-backed entries always surface\n   * the registry's title so the sidebar matches what the registry advertises,\n   * even when a locally loaded copy has been renamed. Standalone entries use\n   * the workspace document title.\n   */\n  title: string\n  /** Name of the document inside the workspace store (mirrors the active version on registry-backed entries). */\n  documentName?: string\n  /** Registry coordinates for the document group (without the version, which lives on `versions[]`). */\n  registry?: { namespace: string; slug: string }\n  /** Traversal tree of the active version (or the lone document for standalone entries). */\n  navigation?: TraversedDocument\n  /** Whether the document is pinned (todo: derived from `x-scalar-pinned`) */\n  isPinned?: boolean\n  /**\n   * All known versions of the document, ordered with the registry's ordering\n   * preserved (latest first by convention). Loaded versions surface their\n   * workspace `documentName` and `navigation`, unloaded ones act as\n   * placeholders the sidebar can fetch on demand. Undefined for standalone\n   * entries that have no registry coordinates.\n   */\n  versions?: SidebarDocumentVersion[]\n  /** Key of the version currently surfaced at the parent level (matches a `versions[].key`). */\n  activeVersionKey?: string\n}\n\n/** Internal projection of a workspace document used during grouping. */\ntype WorkspaceDocumentEntry = {\n  documentName: string\n  title: string\n  navigation?: TraversedDocument\n  isPinned?: boolean\n  /** Whether the workspace document has uncommitted local edits. */\n  isDirty?: boolean\n  registry?: {\n    namespace: string\n    slug: string\n    version?: string\n    commitHash?: string\n    /** Last registry hash the conflict cache was computed against. */\n    conflictCheckedAgainstHash?: string\n    /** Cached conflict-check outcome for `conflictCheckedAgainstHash`. */\n    hasConflict?: boolean\n  }\n}\n\nconst registryKey = (namespace: string, slug: string) => `@${namespace}/${slug}`\n\nconst versionKey = (namespace: string, slug: string, version: string) => `${registryKey(namespace, slug)}@${version}`\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 versions are exposed as `versions`. The\n *    `versions` array merges the registry-advertised versions with any\n *    loaded workspace counterparts (matched by `version`). Registry\n *    documents that have no loaded match are still surfaced 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 projected into the shape the grouping logic needs. */\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      return {\n        documentName: name,\n        title,\n        navigation,\n        // TODO: we can implement this later\n        isPinned: false,\n        isDirty: doc?.['x-scalar-is-dirty'] === true,\n        registry: registry\n          ? {\n              namespace: registry.namespace,\n              slug: registry.slug,\n              version: registry.version,\n              commitHash: registry.commitHash,\n              conflictCheckedAgainstHash: registry.conflictCheckedAgainstHash,\n              hasConflict: registry.hasConflict,\n            }\n          : undefined,\n      }\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. The sidebar key is derived\n    // from the workspace document name (which is guaranteed unique because\n    // it is the map key in `store.workspace.documents`). If we keyed by\n    // registry coordinates instead, two local 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    if (!isTeamWorkspace.value) {\n      return workspaceEntries.value.map<SidebarDocumentItem>((entry) => ({\n        key: entry.documentName,\n        title: entry.title,\n        documentName: entry.documentName,\n        registry: undefined,\n        navigation: entry.navigation,\n        isPinned: entry.isPinned ?? false,\n      }))\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 workspaceByRegistry = 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 = workspaceByRegistry.get(key)\n      if (bucket) {\n        bucket.push(entry)\n      } else {\n        workspaceByRegistry.set(key, [entry])\n      }\n    }\n\n    // 2. Build entries from the registry, merging in any loaded workspace\n    //    counterparts. The registry's version order is preserved so the\n    //    \"first\" version on each entry is the latest one advertised.\n    const grouped: SidebarDocumentItem[] = []\n    const consumedRegistryKeys = new Set<string>()\n\n    for (const doc of toValue(managedDocs)) {\n      const key = registryKey(doc.namespace, doc.slug)\n      consumedRegistryKeys.add(key)\n      const loaded = workspaceByRegistry.get(key) ?? []\n      const item = buildRegistryItem({ key, registry: doc, loaded, activeDocumentSlug })\n      if (item) {\n        grouped.push(item)\n      }\n    }\n\n    // 3. Workspace docs that point at a registry coordinate the registry has\n    //    not advertised (yet) still need to appear in the sidebar so the user\n    //    is not stranded without an entry to click.\n    for (const [key, loaded] of workspaceByRegistry) {\n      if (consumedRegistryKeys.has(key)) {\n        continue\n      }\n      const first = loaded[0]?.registry\n      if (!first) {\n        continue\n      }\n      const item = buildRegistryItem({\n        key,\n        registry: {\n          namespace: first.namespace,\n          slug: first.slug,\n          title: loaded[0]?.title ?? first.slug,\n          versions: [],\n        },\n        loaded,\n        activeDocumentSlug,\n      })\n      if (item) {\n        grouped.push(item)\n      }\n    }\n\n    return [...grouped, ...standalone.map(toStandaloneItem)]\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\n/** Project a standalone (non-registry) workspace entry into a sidebar item. */\nconst toStandaloneItem = (entry: WorkspaceDocumentEntry): SidebarDocumentItem => ({\n  key: entry.documentName,\n  title: entry.title,\n  documentName: entry.documentName,\n  registry: undefined,\n  navigation: entry.navigation,\n  isPinned: entry.isPinned ?? false,\n})\n\n/**\n * Build a single registry-backed sidebar item. The version list is assembled\n * by walking the registry's advertised versions in order and pairing them\n * with any loaded workspace document that claims the same `version` string.\n * Loaded versions that the registry has not advertised are appended at the\n * end so they stay visible until the registry catches up.\n */\nconst buildRegistryItem = ({\n  key,\n  registry,\n  loaded,\n  activeDocumentSlug,\n}: {\n  key: string\n  registry: RegistryDocument\n  loaded: WorkspaceDocumentEntry[]\n  activeDocumentSlug: string | undefined\n}): SidebarDocumentItem | undefined => {\n  // Index loaded workspace docs by the version they claim. A workspace doc\n  // that does not declare a `version` is treated as an orphan and pushed to\n  // the bottom of the version list — it still belongs to the group but we\n  // cannot reconcile it with the registry.\n  const loadedByVersion = new Map<string, WorkspaceDocumentEntry>()\n  const orphans: WorkspaceDocumentEntry[] = []\n\n  for (const entry of loaded) {\n    const version = entry.registry?.version\n    if (!version) {\n      orphans.push(entry)\n      continue\n    }\n    if (loadedByVersion.has(version)) {\n      // Multiple workspace docs claim the same version; keep the first one\n      // (registry order wins) and surface the rest as orphans so they remain\n      // visible instead of silently disappearing.\n      orphans.push(entry)\n      continue\n    }\n    loadedByVersion.set(version, entry)\n  }\n\n  const versions: SidebarDocumentVersion[] = []\n\n  // Registry-backed rows always surface the registry title so the sidebar\n  // matches what the registry advertises. Local renames are intentionally\n  // ignored here; the slug is the last-resort fallback so the row always has\n  // something to render.\n  const groupTitle = registry.title || registry.slug\n\n  // Build the drafts list first: entries left in `loadedByVersion` after we\n  // remove every version the registry advertises. The workspace store\n  // preserves insertion order, so the newest draft is naturally last —\n  // reverse it here to surface the most recently created draft first.\n  const draftEntries: [string, WorkspaceDocumentEntry][] = []\n  for (const [version, match] of loadedByVersion) {\n    if (registry.versions.some((v) => v.version === version)) {\n      continue\n    }\n    draftEntries.push([version, match])\n  }\n  draftEntries.reverse()\n\n  // Drafts go on top: the user just created them and the registry has not\n  // seen them yet, so they are the most relevant rows in the picker.\n  // Drafts never carry the \"Latest\" badge — that label always belongs to\n  // the latest registry-advertised version, regardless of row position.\n  for (const [version, match] of draftEntries) {\n    versions.push({\n      key: match.documentName,\n      version,\n      title: groupTitle,\n      documentName: match.documentName,\n      commitHash: match.registry?.commitHash,\n      registryCommitHash: undefined,\n      status: computeVersionStatus({\n        isLoaded: true,\n        localHash: match.registry?.commitHash,\n        registryHash: undefined,\n        isDirty: match.isDirty,\n      }),\n      isLatest: false,\n      navigation: match.navigation,\n    })\n  }\n\n  // Then the registry-advertised versions, in the order the registry\n  // returned them (latest first by convention). The first one is the\n  // canonical \"latest\" — flagged here so the picker can render the badge\n  // independent of row order in the array.\n  registry.versions.forEach((v, registryIndex) => {\n    const match = loadedByVersion.get(v.version)\n    const localHash = match?.registry?.commitHash\n    const registryHash = v.commitHash\n    versions.push({\n      key: match ? match.documentName : versionKey(registry.namespace, registry.slug, v.version),\n      version: v.version,\n      title: groupTitle,\n      documentName: match?.documentName,\n      commitHash: localHash,\n      registryCommitHash: registryHash,\n      status: computeVersionStatus({\n        isLoaded: Boolean(match),\n        localHash,\n        registryHash,\n        isDirty: match?.isDirty,\n        conflictCheckedAgainstHash: match?.registry?.conflictCheckedAgainstHash,\n        hasConflict: match?.registry?.hasConflict,\n      }),\n      isLatest: registryIndex === 0,\n      navigation: match?.navigation,\n    })\n  })\n\n  // Loaded docs that did not declare a version at all.\n  for (const orphan of orphans) {\n    versions.push({\n      key: orphan.documentName,\n      version: orphan.registry?.version ?? '',\n      title: groupTitle,\n      documentName: orphan.documentName,\n      commitHash: orphan.registry?.commitHash,\n      registryCommitHash: undefined,\n      status: computeVersionStatus({\n        isLoaded: true,\n        localHash: orphan.registry?.commitHash,\n        registryHash: undefined,\n        isDirty: orphan.isDirty,\n      }),\n      isLatest: false,\n      navigation: orphan.navigation,\n    })\n  }\n\n  if (versions.length === 0) {\n    return undefined\n  }\n\n  // Pick the active version: prefer a loaded match against the active\n  // document slug, then any loaded version, then fall back to the first\n  // version (the latest advertised by the registry).\n  const activeVersion =\n    versions.find((v) => v.documentName !== undefined && v.documentName === activeDocumentSlug) ??\n    versions.find((v) => v.documentName !== undefined) ??\n    versions[0]!\n\n  return {\n    key,\n    title: groupTitle,\n    documentName: activeVersion.documentName,\n    registry: { namespace: registry.namespace, slug: registry.slug },\n    navigation: activeVersion.navigation,\n    isPinned: loaded.some((e) => e.isPinned),\n    versions,\n    activeVersionKey: activeVersion.key,\n  }\n}\n"],"mappings":"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"}

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

@@ -1,56 +0,0 @@
-import { type Theme } from '@scalar/themes';
-import type { WorkspaceStore } from '@scalar/workspace-store/client';
-import { type MaybeRefOrGetter } from 'vue';
-/**
- * useTheme
- *
- * Reactive Vue.js hook to resolve and generate a <style> tag string based on the current theme.
- * Automatically selects the appropriate theme styles in the following priority order:
- *    1. Workspace theme (from the provided store, e.g. store.workspace['x-scalar-theme'])
- *    2. Fallback theme (from the fallbackThemeSlug prop)
- *    3. Default built-in theme (with slug "default")
- *
- * The returned `themeStyleTag` can be injected into your page to dynamically apply theming.
- *
- * @example
- * ```ts
- * // In a Vue component setup() function
- * import { ref } from 'vue'
- * import { useTheme } from './use-theme.js'
- *
- * const myThemes = ref([...])
- * const workspaceStore = ref(...)
- * const fallbackThemeSlug = ref('dark')
- *
- * const { themeStyleTag } = useTheme({
- *   customThemes: myThemes,
- *   fallbackThemeSlug,
- *   store: workspaceStore
- * })
- *
- * // To inject in template:
- * // <div v-html="themeStyleTag"></div>
- * ```
- */
-export declare const useTheme: ({ fallbackThemeSlug, store, customThemes, }: {
-    customThemes: MaybeRefOrGetter<Theme[]>;
-    fallbackThemeSlug: MaybeRefOrGetter<string>;
-    store: MaybeRefOrGetter<WorkspaceStore | null>;
-}) => {
-    /**
-     * Computed ref containing the resolved theme styles object
-     * for the currently active theme. Always returns a style object,
-     * never null, with proper fallback logic if custom or workspace themes are missing.
-     */
-    themeStyles: import("vue").ComputedRef<{
-        themeStyles: string;
-        themeSlug: string;
-    }>;
-    /**
-     * Computed ref containing a <style> tag as a string,
-     * ready to be injected into the DOM.
-     * This wraps the currently active theme CSS variables/styles.
-     */
-    themeStyleTag: import("vue").ComputedRef<string>;
-};
-//# sourceMappingURL=use-theme.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"use-theme.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/app/hooks/use-theme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAA8B,MAAM,gBAAgB,CAAA;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAqB,MAAM,KAAK,CAAA;AAkC9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,QAAQ,GAAI,6CAItB;IACD,YAAY,EAAE,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAA;IACvC,iBAAiB,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;CAC/C;IA6CG;;;;OAIG;;qBAhDuC,MAAM;mBAAa,MAAM;;IAmDnE;;;;OAIG;;CAGN,CAAA"}