@scalar/api-client 2.38.4 → 2.39.0

package/dist/v2/features/command-palette/helpers/postman-request-tree.js

@@ -0,0 +1,139 @@
+//#region src/v2/features/command-palette/helpers/postman-request-tree.ts
+var pathKey = (path) => JSON.stringify([...path]);
+/**
+* Inverse of {@link pathKey}: parses stable request index path JSON from the UI.
+* Returns undefined for malformed input.
+*/
+var parsePostmanPathKey = (key) => {
+	try {
+		const parsed = JSON.parse(key);
+		if (!Array.isArray(parsed) || parsed.length === 0) return;
+		for (const n of parsed) if (typeof n !== "number" || !Number.isInteger(n) || n < 0) return;
+		return parsed;
+	} catch {
+		return;
+	}
+};
+/** Maps UI path keys to `ConvertOptions.requestIndexPaths`; invalid keys are skipped. */
+var pathKeysToRequestIndexPaths = (keys) => {
+	const out = [];
+	for (const key of keys) {
+		const path = parsePostmanPathKey(key);
+		if (path !== void 0) out.push([...path]);
+	}
+	return out;
+};
+var isPostmanFolderNode = (node) => {
+	if (node === null || node === void 0 || typeof node !== "object") return false;
+	return "item" in node && Array.isArray(node.item);
+};
+/**
+* Resolves the Postman JSON node at `path` (indices into root `item`, then each folder’s `item`).
+* Matches {@link buildPostmanRequestTree} paths and postman-to-openapi `getNodeAtPath`.
+*/
+var getPostmanItemAtIndexPath = (itemRoot, path) => {
+	if (!Array.isArray(itemRoot) || path.length === 0) return;
+	let list = itemRoot;
+	let node;
+	for (let i = 0; i < path.length; i++) {
+		const idx = path[i];
+		if (typeof idx !== "number" || idx < 0 || idx >= list.length) return;
+		node = list[idx];
+		if (node === void 0) return;
+		if (i < path.length - 1) {
+			if (!isPostmanFolderNode(node)) return;
+			list = node.item;
+		}
+	}
+	return node;
+};
+var extractRequestMethod = (request) => {
+	if (typeof request === "string") return "get".toLowerCase();
+	if (request && typeof request === "object" && "method" in request) {
+		const method = request.method;
+		if (typeof method === "string" && method.length > 0) return method.toLowerCase();
+	}
+	return "get".toLowerCase();
+};
+/**
+* Builds a shallow tree of folders and requests from a Postman `item` array.
+* Paths are indices from the collection root through nested `item` arrays.
+*/
+var buildPostmanRequestTree = (items) => {
+	if (!Array.isArray(items)) return [];
+	const walk = (list, prefix) => list.map((raw, index) => {
+		const path = [...prefix, index];
+		const name = typeof raw?.name === "string" && raw.name.length > 0 ? raw.name : "Untitled";
+		if (raw?.item !== void 0 && Array.isArray(raw.item)) return {
+			path,
+			name,
+			isFolder: true,
+			children: walk(raw.item, path)
+		};
+		if (raw?.request !== void 0) return {
+			path,
+			name,
+			isFolder: false,
+			method: extractRequestMethod(raw.request)
+		};
+		return {
+			path,
+			name,
+			isFolder: true,
+			children: []
+		};
+	});
+	return walk(items, []);
+};
+/** Counts Postman request leaves in an `item` array (same rules as {@link buildPostmanRequestTree}). */
+var countPostmanRequestLeaves = (items) => {
+	if (!Array.isArray(items)) return 0;
+	const walk = (list) => list.reduce((sum, raw) => {
+		if (raw?.item !== void 0 && Array.isArray(raw.item)) return sum + walk(raw.item);
+		if (raw?.request !== void 0) return sum + 1;
+		return sum;
+	}, 0);
+	return walk(items);
+};
+/** Path keys for every request leaf in the tree (depth-first). */
+var collectAllRequestPathKeys = (nodes) => {
+	const keys = [];
+	for (const node of nodes) if (node.isFolder) keys.push(...collectAllRequestPathKeys(node.children ?? []));
+	else keys.push(pathKey(node.path));
+	return keys;
+};
+var collectRequestPathKeysUnderFolder = (node) => {
+	if (!node.isFolder) return [pathKey(node.path)];
+	return collectAllRequestPathKeys(node.children ?? []);
+};
+/** Returns a new selection list after toggling one request path key. */
+var applyPostmanRequestSelectionChange = (selectedKeys, key, selected) => {
+	const next = new Set(selectedKeys);
+	if (selected) next.add(key);
+	else next.delete(key);
+	return [...next];
+};
+/** Returns a new selection list after selecting or clearing every request under a folder. */
+var applyPostmanFolderSelectionChange = (selectedKeys, node, selected) => {
+	const keys = collectRequestPathKeysUnderFolder(node);
+	const next = new Set(selectedKeys);
+	for (const key of keys) if (selected) next.add(key);
+	else next.delete(key);
+	return [...next];
+};
+var folderFullySelected = (node, selected) => {
+	const keys = collectRequestPathKeysUnderFolder(node);
+	return keys.length > 0 && keys.every((key) => selected.has(key));
+};
+/** True when at least one descendant request is selected but not all. */
+var folderHasPartialSelection = (node, selected) => {
+	const keys = collectRequestPathKeysUnderFolder(node);
+	if (keys.length === 0) return false;
+	let selectedCount = 0;
+	for (const key of keys) if (selected.has(key)) selectedCount++;
+	return selectedCount > 0 && selectedCount < keys.length;
+};
+//#endregion
+export { applyPostmanFolderSelectionChange, applyPostmanRequestSelectionChange, buildPostmanRequestTree, collectRequestPathKeysUnderFolder, countPostmanRequestLeaves, extractRequestMethod, folderFullySelected, folderHasPartialSelection, getPostmanItemAtIndexPath, pathKey, pathKeysToRequestIndexPaths };
+
+//# sourceMappingURL=postman-request-tree.js.map

package/dist/v2/features/command-palette/helpers/postman-request-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postman-request-tree.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/postman-request-tree.ts"],"sourcesContent":["export type PostmanTreeNode = {\n  path: readonly number[]\n  name: string\n  isFolder: boolean\n  method?: string\n  children?: PostmanTreeNode[]\n}\n\ntype LooseItem = {\n  name?: string\n  item?: LooseItem[]\n  request?: unknown\n}\n\nexport const pathKey = (path: readonly number[]): string => JSON.stringify([...path])\n\n/**\n * Inverse of {@link pathKey}: parses stable request index path JSON from the UI.\n * Returns undefined for malformed input.\n */\nexport const parsePostmanPathKey = (key: string): readonly number[] | undefined => {\n  try {\n    const parsed = JSON.parse(key) as unknown\n    if (!Array.isArray(parsed) || parsed.length === 0) {\n      return undefined\n    }\n    for (const n of parsed) {\n      if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {\n        return undefined\n      }\n    }\n    return parsed as readonly number[]\n  } catch {\n    return undefined\n  }\n}\n\n/** Maps UI path keys to `ConvertOptions.requestIndexPaths`; invalid keys are skipped. */\nexport const pathKeysToRequestIndexPaths = (keys: readonly string[]): number[][] => {\n  const out: number[][] = []\n  for (const key of keys) {\n    const path = parsePostmanPathKey(key)\n    if (path !== undefined) {\n      out.push([...path])\n    }\n  }\n  return out\n}\n\nconst isPostmanFolderNode = (node: unknown): node is { item: LooseItem[] } => {\n  if (node === null || node === undefined || typeof node !== 'object') {\n    return false\n  }\n  return 'item' in node && Array.isArray((node as { item: unknown }).item)\n}\n\n/**\n * Resolves the Postman JSON node at `path` (indices into root `item`, then each folder’s `item`).\n * Matches {@link buildPostmanRequestTree} paths and postman-to-openapi `getNodeAtPath`.\n */\nexport const getPostmanItemAtIndexPath = (itemRoot: unknown, path: readonly number[]): unknown => {\n  if (!Array.isArray(itemRoot) || path.length === 0) {\n    return undefined\n  }\n  let list: unknown[] = itemRoot\n  let node: unknown\n  for (let i = 0; i < path.length; i++) {\n    const idx = path[i]\n    if (typeof idx !== 'number' || idx < 0 || idx >= list.length) {\n      return undefined\n    }\n    node = list[idx]\n    if (node === undefined) {\n      return undefined\n    }\n    if (i < path.length - 1) {\n      if (!isPostmanFolderNode(node)) {\n        return undefined\n      }\n      list = node.item\n    }\n  }\n  return node\n}\n\nexport const extractRequestMethod = (request: unknown): string => {\n  if (typeof request === 'string') {\n    return 'get'.toLowerCase()\n  }\n  if (request && typeof request === 'object' && 'method' in request) {\n    const method = (request as { method?: string }).method\n    if (typeof method === 'string' && method.length > 0) {\n      return method.toLowerCase()\n    }\n  }\n  return 'get'.toLowerCase()\n}\n\n/**\n * Builds a shallow tree of folders and requests from a Postman `item` array.\n * Paths are indices from the collection root through nested `item` arrays.\n */\nexport const buildPostmanRequestTree = (items: unknown): PostmanTreeNode[] => {\n  if (!Array.isArray(items)) {\n    return []\n  }\n\n  const walk = (list: LooseItem[], prefix: number[]): PostmanTreeNode[] =>\n    list.map((raw, index) => {\n      const path = [...prefix, index]\n      const name = typeof raw?.name === 'string' && raw.name.length > 0 ? raw.name : 'Untitled'\n\n      if (raw?.item !== undefined && Array.isArray(raw.item)) {\n        return {\n          path,\n          name,\n          isFolder: true,\n          children: walk(raw.item as LooseItem[], path),\n        }\n      }\n\n      if (raw?.request !== undefined) {\n        return {\n          path,\n          name,\n          isFolder: false,\n          method: extractRequestMethod(raw.request),\n        }\n      }\n\n      return {\n        path,\n        name,\n        isFolder: true,\n        children: [],\n      }\n    })\n\n  return walk(items as LooseItem[], [])\n}\n\n/** Counts Postman request leaves in an `item` array (same rules as {@link buildPostmanRequestTree}). */\nexport const countPostmanRequestLeaves = (items: unknown): number => {\n  if (!Array.isArray(items)) {\n    return 0\n  }\n  const walk = (list: LooseItem[]): number =>\n    list.reduce((sum, raw) => {\n      if (raw?.item !== undefined && Array.isArray(raw.item)) {\n        return sum + walk(raw.item as LooseItem[])\n      }\n      if (raw?.request !== undefined) {\n        return sum + 1\n      }\n      return sum\n    }, 0)\n  return walk(items as LooseItem[])\n}\n\n/** Path keys for every request leaf in the tree (depth-first). */\nexport const collectAllRequestPathKeys = (nodes: PostmanTreeNode[]): string[] => {\n  const keys: string[] = []\n  for (const node of nodes) {\n    if (node.isFolder) {\n      keys.push(...collectAllRequestPathKeys(node.children ?? []))\n    } else {\n      keys.push(pathKey(node.path))\n    }\n  }\n  return keys\n}\n\nexport const collectRequestPathKeysUnderFolder = (node: PostmanTreeNode): string[] => {\n  if (!node.isFolder) {\n    return [pathKey(node.path)]\n  }\n  return collectAllRequestPathKeys(node.children ?? [])\n}\n\n/** Returns a new selection list after toggling one request path key. */\nexport const applyPostmanRequestSelectionChange = (\n  selectedKeys: readonly string[],\n  key: string,\n  selected: boolean,\n): string[] => {\n  const next = new Set(selectedKeys)\n  if (selected) {\n    next.add(key)\n  } else {\n    next.delete(key)\n  }\n  return [...next]\n}\n\n/** Returns a new selection list after selecting or clearing every request under a folder. */\nexport const applyPostmanFolderSelectionChange = (\n  selectedKeys: readonly string[],\n  node: PostmanTreeNode,\n  selected: boolean,\n): string[] => {\n  const keys = collectRequestPathKeysUnderFolder(node)\n  const next = new Set(selectedKeys)\n  for (const key of keys) {\n    if (selected) {\n      next.add(key)\n    } else {\n      next.delete(key)\n    }\n  }\n  return [...next]\n}\n\n/** Number of request leaves under this node (0 for empty folders). */\nexport const countRequestLeaves = (node: PostmanTreeNode): number => {\n  if (!node.isFolder) {\n    return 1\n  }\n  return (node.children ?? []).reduce((sum, child) => sum + countRequestLeaves(child), 0)\n}\n\nexport const folderFullySelected = (node: PostmanTreeNode, selected: ReadonlySet<string>): boolean => {\n  const keys = collectRequestPathKeysUnderFolder(node)\n  return keys.length > 0 && keys.every((key) => selected.has(key))\n}\n\n/** True when at least one descendant request is selected but not all. */\nexport const folderHasPartialSelection = (node: PostmanTreeNode, selected: ReadonlySet<string>): boolean => {\n  const keys = collectRequestPathKeysUnderFolder(node)\n  if (keys.length === 0) {\n    return false\n  }\n  let selectedCount = 0\n  for (const key of keys) {\n    if (selected.has(key)) {\n      selectedCount++\n    }\n  }\n  return selectedCount > 0 && selectedCount < keys.length\n}\n"],"mappings":"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"}

package/dist/v2/features/command-palette/hooks/use-command-palette-state.d.ts

@@ -89,7 +89,7 @@ export type CommandPaletteState = {
  * palette.open('create-openapi-document')
  *
  * // Open with command props
- * palette.open('import-curl-command', { curl: 'curl https://api.example.com' })
+ * palette.open('import-curl-command', { inputValue: 'curl https://api.example.com' })
  *
  * // Update filter query (automatically filters commands)
  * palette.setFilterQuery('import')
@@ -112,7 +112,7 @@ export declare const baseRoutes: CommandPaletteRoute[];
  */
 export declare const baseClientActions: [{
     readonly id: "import-from-openapi-swagger-postman-curl";
-    readonly name: "Import from OpenAPI/Swagger/Postman/cURL";
+    readonly name: "Import from OpenAPI/Swagger/cURL";
     readonly component: {
         new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
             workspaceStore: import("@scalar/workspace-store/client").WorkspaceStore;
@@ -176,6 +176,42 @@ export declare const baseClientActions: [{
             default?: (props: {}) => any;
         };
     });
+}, {
+    readonly id: "import-postman-collection";
+    readonly name: "Import Postman Collection";
+    readonly component: import("vue").DefineComponent<{
+        workspaceStore: import("@scalar/workspace-store/client").WorkspaceStore;
+        eventBus: import("@scalar/workspace-store/events").WorkspaceEventBus;
+        inputValue: string;
+    }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+        close: () => any;
+        back: (keyboardEvent: KeyboardEvent) => any;
+    }, string, import("vue").PublicProps, Readonly<{
+        workspaceStore: import("@scalar/workspace-store/client").WorkspaceStore;
+        eventBus: import("@scalar/workspace-store/events").WorkspaceEventBus;
+        inputValue: string;
+    }> & Readonly<{
+        onClose?: (() => any) | undefined;
+        onBack?: ((keyboardEvent: KeyboardEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    readonly icon: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("@scalar/icons/types").ScalarIconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("@scalar/icons/types").ScalarIconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("@scalar/icons/types").ScalarIconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    });
+    readonly hidden: true;
 }, {
     readonly id: "create-openapi-document";
     readonly name: "Create OpenAPI Document";

package/dist/v2/features/command-palette/hooks/use-command-palette-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-command-palette-state.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/hooks/use-command-palette-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-command-palette-state.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/hooks/use-command-palette-state.ts"],"names":[],"mappings":"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"}

package/dist/v2/features/command-palette/hooks/use-command-palette-state.js

@@ -0,0 +1,207 @@
+import CommandPaletteExample_default from "../components/CommandPaletteExample.vue.js";
+import CommandPaletteImport_default from "../components/CommandPaletteImport.vue.js";
+import CommandPaletteImportCurl_default from "../components/CommandPaletteImportCurl.vue.js";
+import CommandPaletteImportPostman_default from "../components/CommandPaletteImportPostman.vue.js";
+import CommandPaletteOpenApiDocument_default from "../components/CommandPaletteOpenApiDocument.vue.js";
+import CommandPaletteRequest_default from "../components/CommandPaletteRequest.vue.js";
+import CommandPaletteTag_default from "../components/CommandPaletteTag.vue.js";
+import { computed, ref, shallowRef, toValue } from "vue";
+import { useModal } from "@scalar/components";
+import { ScalarIconArrowSquareIn, ScalarIconArrowUpRight, ScalarIconBracketsCurly, ScalarIconCookie, ScalarIconFolder, ScalarIconPackage, ScalarIconPuzzlePiece, ScalarIconSlidersHorizontal } from "@scalar/icons";
+import Fuse from "fuse.js";
+//#region src/v2/features/command-palette/hooks/use-command-palette-state.ts
+/**
+* Composable for managing command palette state.
+*
+* Centralizes all state management for the command palette including:
+* - Open/closed state
+* - Filter/search query
+* - Command filtering logic
+*
+* @example
+* const palette = useCommandPaletteState()
+*
+* // Open the palette
+* palette.open()
+*
+* // Open with a specific command
+* palette.open('create-openapi-document')
+*
+* // Open with command props
+* palette.open('import-curl-command', { inputValue: 'curl https://api.example.com' })
+*
+* // Update filter query (automatically filters commands)
+* palette.setFilterQuery('import')
+*
+* // Access filtered results
+* console.log(palette.filteredCommands.value)
+*
+* // Close and reset
+* palette.close()
+*/
+var useCommandPaletteState = (actions = baseClientActions, routes = baseRoutes) => {
+	const modalState = useModal();
+	const filterQuery = ref("");
+	const activeCommand = shallowRef(null);
+	const activeCommandProps = ref(null);
+	/** Whether the command palette is currently open */
+	const isOpen = computed(() => modalState.open);
+	const fuseActions = computed(() => new Fuse(toValue(actions), {
+		keys: ["name"],
+		threshold: .2
+	}));
+	const fuseRoutes = computed(() => new Fuse(toValue(routes), {
+		keys: ["name"],
+		threshold: .2
+	}));
+	/**
+	* Filtered commands based on the current search query.
+	* When no query is present, returns all visible commands (excluding hidden-folder).
+	* When a query exists, filters commands by name (case-insensitive) and excludes hidden-folder.
+	* Empty groups are excluded from the results.
+	*/
+	const filteredActions = computed(() => {
+		const query = filterQuery.value.toLowerCase().trim();
+		return (query ? fuseActions.value.search(query).map((a) => a.item) : toValue(actions)).filter((a) => !a.hidden);
+	});
+	const filteredRoutes = computed(() => {
+		const query = filterQuery.value.toLowerCase().trim();
+		return query ? fuseRoutes.value.search(query).map((a) => a.item) : toValue(routes);
+	});
+	/**
+	* Opens the command palette, optionally with a specific command active.
+	* If a commandId is provided, that command will be opened immediately.
+	* Props are type-safe and checked against the command's expected props.
+	*/
+	const open = (commandId, ...args) => {
+		if (commandId) {
+			activeCommand.value = toValue(actions).find((a) => a.id === commandId) ?? null;
+			activeCommandProps.value = args[0] ?? null;
+		}
+		modalState.show();
+	};
+	/** Closes the command palette and resets all state */
+	const close = () => {
+		modalState.hide();
+		reset();
+	};
+	/** Updates the filter query for searching commands */
+	const setFilterQuery = (query) => {
+		filterQuery.value = query;
+	};
+	/** Resets all internal state to initial values */
+	const reset = () => {
+		filterQuery.value = "";
+		activeCommand.value = null;
+		activeCommandProps.value = null;
+	};
+	return {
+		isOpen,
+		activeCommand,
+		activeCommandProps,
+		filterQuery,
+		filteredCommands: computed(() => [{
+			label: "",
+			commands: filteredActions.value
+		}, {
+			label: "Pages",
+			commands: filteredRoutes.value
+		}]),
+		open,
+		close,
+		setFilterQuery,
+		reset
+	};
+};
+/**
+* The base naviation routes used in the command palette.
+* This object can be extended and passed to the useCommandPaletteState hook to add custom routes
+*/
+var baseRoutes = [
+	{
+		type: "route",
+		id: "environment",
+		name: "Environment",
+		icon: ScalarIconBracketsCurly,
+		to: { name: "workspace.environment" }
+	},
+	{
+		type: "route",
+		id: "cookies",
+		name: "Cookies",
+		icon: ScalarIconCookie,
+		to: { name: "workspace.cookies" }
+	},
+	{
+		type: "route",
+		id: "settings",
+		name: "Settings",
+		icon: ScalarIconSlidersHorizontal,
+		to: { name: "workspace.settings" }
+	}
+];
+/**
+* The internal client command palette actions
+* This object can be extended and passed to the useCommandPaletteState hook to add custom actions
+*/
+var baseClientActions = [
+	{
+		id: "import-from-openapi-swagger-postman-curl",
+		name: "Import from OpenAPI/Swagger/cURL",
+		component: CommandPaletteImport_default,
+		icon: ScalarIconArrowSquareIn
+	},
+	{
+		id: "import-postman-collection",
+		name: "Import Postman Collection",
+		component: CommandPaletteImportPostman_default,
+		icon: ScalarIconArrowSquareIn,
+		hidden: true
+	},
+	{
+		id: "create-openapi-document",
+		name: "Create OpenAPI Document",
+		component: CommandPaletteOpenApiDocument_default,
+		icon: ScalarIconPackage
+	},
+	{
+		id: "add-tag",
+		name: "Add Tag",
+		component: CommandPaletteTag_default,
+		icon: ScalarIconFolder
+	},
+	{
+		id: "create-request",
+		name: "Create Request",
+		component: CommandPaletteRequest_default,
+		icon: ScalarIconArrowUpRight
+	},
+	{
+		id: "add-example",
+		name: "Add Example",
+		component: CommandPaletteExample_default,
+		icon: ScalarIconPuzzlePiece
+	},
+	{
+		id: "import-curl-command",
+		name: "Import cURL Command",
+		hidden: true,
+		component: CommandPaletteImportCurl_default
+	},
+	{
+		id: "edit-tag",
+		name: "Edit Tag",
+		hidden: true,
+		component: CommandPaletteTag_default
+	},
+	{
+		id: "edit-example",
+		name: "Edit Example",
+		hidden: true,
+		component: CommandPaletteExample_default
+	}
+];
+//#endregion
+export { baseClientActions, baseRoutes, useCommandPaletteState };
+
+//# sourceMappingURL=use-command-palette-state.js.map

package/dist/v2/features/command-palette/hooks/use-command-palette-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-command-palette-state.js","names":[],"sources":["../../../../../src/v2/features/command-palette/hooks/use-command-palette-state.ts"],"sourcesContent":["import { useModal } from '@scalar/components'\nimport {\n  ScalarIconArrowSquareIn,\n  ScalarIconArrowUpRight,\n  ScalarIconBracketsCurly,\n  ScalarIconCookie,\n  ScalarIconFolder,\n  ScalarIconPackage,\n  ScalarIconPuzzlePiece,\n  ScalarIconSlidersHorizontal,\n} from '@scalar/icons'\nimport type { ScalarIconComponent } from '@scalar/icons/types'\nimport type { CommandPalettePayload } from '@scalar/workspace-store/events'\nimport Fuse from 'fuse.js'\nimport {\n  type Component,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n  type Ref,\n  type ShallowRef,\n  computed,\n  ref,\n  shallowRef,\n  toValue,\n} from 'vue'\nimport type { RouteLocationRaw } from 'vue-router'\n\nimport CommandPaletteExample from '../components/CommandPaletteExample.vue'\nimport CommandPaletteImport from '../components/CommandPaletteImport.vue'\nimport CommandPaletteImportCurl from '../components/CommandPaletteImportCurl.vue'\nimport CommandPaletteImportPostman from '../components/CommandPaletteImportPostman.vue'\nimport CommandPaletteOpenApiDocument from '../components/CommandPaletteOpenApiDocument.vue'\nimport CommandPaletteRequest from '../components/CommandPaletteRequest.vue'\nimport CommandPaletteTag from '../components/CommandPaletteTag.vue'\n\n/**\n * Command IDs that map to UI components (folder and hidden-folder types)\n *\n * For base app commands they are defined by their action payload\n */\ntype UiCommandIds = keyof CommandPalettePayload\n\n/** Map the the prop definitons to the prop value */\ntype CommandPaletteActionProps<K extends UiCommandIds> = CommandPalettePayload[K]\n\n/**\n * Type for the open function in the command palette.\n * Supports two usage patterns:\n * - open() - Opens the palette without a specific command\n * - open(commandId) - Opens a command that does not require props\n * - open(commandId, props) - Opens a command with required props\n */\ntype OpenCommand = {\n  (): void\n  <T extends UiCommandIds>(commandId: T, props: CommandPaletteActionProps<T>): void\n}\n\n/** Route enntry for the palette list */\nexport type CommandPaletteRoute = {\n  id: string\n  type: 'route'\n  icon: ScalarIconComponent\n  name: string\n  to: RouteLocationRaw\n}\n\n/** Command entry for the palette list */\ntype BaseCommandPaletteAction = {\n  id: keyof CommandPalettePayload\n  name: string\n  icon?: ScalarIconComponent\n  component: Component\n  hidden?: boolean\n}\n\nexport type CommandPaletteAction = Omit<BaseCommandPaletteAction, 'id'> & {\n  id: string\n}\n\nexport type CommandPaletteEntry = CommandPaletteAction | CommandPaletteRoute\n\n// ---------------------------------------------------------------------------\n\n/**\n * Return type for the useCommandPaletteState composable.\n * Provides reactive state and methods to control the command palette.\n */\nexport type CommandPaletteState = {\n  /** Whether the command palette is currently open */\n  isOpen: Ref<boolean>\n  /** The currently active command, or null if showing the main list */\n  activeCommand: ShallowRef<CommandPaletteAction | null>\n  /** Properties passed to the active command component */\n  activeCommandProps: Ref<Record<string, unknown> | null>\n  /** Current filter/search query for filtering commands */\n  filterQuery: Ref<string>\n  /** Grouped actions and routes to be rendered */\n  filteredCommands: ComputedRef<\n    {\n      label?: string\n      commands: (CommandPaletteAction | CommandPaletteRoute)[]\n    }[]\n  >\n  /**\n   * Opens the command palette, optionally with a specific command active.\n   * When opening a command, props are required only if the command defines them.\n   */\n  open: OpenCommand\n  /** Closes the command palette and resets state */\n  close: () => void\n  /** Updates the filter query for searching commands */\n  setFilterQuery: (query: string) => void\n  /** Resets all state to initial values */\n  reset: () => void\n}\n\n/**\n * Composable for managing command palette state.\n *\n * Centralizes all state management for the command palette including:\n * - Open/closed state\n * - Filter/search query\n * - Command filtering logic\n *\n * @example\n * const palette = useCommandPaletteState()\n *\n * // Open the palette\n * palette.open()\n *\n * // Open with a specific command\n * palette.open('create-openapi-document')\n *\n * // Open with command props\n * palette.open('import-curl-command', { inputValue: 'curl https://api.example.com' })\n *\n * // Update filter query (automatically filters commands)\n * palette.setFilterQuery('import')\n *\n * // Access filtered results\n * console.log(palette.filteredCommands.value)\n *\n * // Close and reset\n * palette.close()\n */\nexport const useCommandPaletteState = (\n  actions: MaybeRefOrGetter<CommandPaletteAction[]> = baseClientActions,\n  routes: MaybeRefOrGetter<CommandPaletteRoute[]> = baseRoutes,\n): CommandPaletteState => {\n  const modalState = useModal()\n\n  const filterQuery = ref('')\n  const activeCommand = shallowRef<CommandPaletteAction | null>(null)\n  const activeCommandProps = ref<Record<string, unknown> | null>(null)\n\n  /** Whether the command palette is currently open */\n  const isOpen = computed<boolean>(() => modalState.open)\n\n  const fuseActions = computed(\n    () =>\n      new Fuse(toValue(actions), {\n        keys: ['name'],\n        threshold: 0.2,\n      }),\n  )\n\n  const fuseRoutes = computed(\n    () =>\n      new Fuse(toValue(routes), {\n        keys: ['name'],\n        threshold: 0.2,\n      }),\n  )\n\n  /**\n   * Filtered commands based on the current search query.\n   * When no query is present, returns all visible commands (excluding hidden-folder).\n   * When a query exists, filters commands by name (case-insensitive) and excludes hidden-folder.\n   * Empty groups are excluded from the results.\n   */\n  const filteredActions = computed<CommandPaletteAction[]>(() => {\n    const query = filterQuery.value.toLowerCase().trim()\n\n    // Filter commands by name when query exists\n    const base = query ? fuseActions.value.search(query).map((a) => a.item) : toValue(actions)\n\n    // Always exclude hidden folders\n    return base.filter((a) => !a.hidden)\n  })\n\n  const filteredRoutes = computed<CommandPaletteRoute[]>(() => {\n    const query = filterQuery.value.toLowerCase().trim()\n\n    return query ? fuseRoutes.value.search(query).map((a) => a.item) : toValue(routes)\n  })\n\n  /**\n   * Opens the command palette, optionally with a specific command active.\n   * If a commandId is provided, that command will be opened immediately.\n   * Props are type-safe and checked against the command's expected props.\n   */\n  const open: OpenCommand = (commandId?: UiCommandIds, ...args: unknown[]): void => {\n    if (commandId) {\n      activeCommand.value = toValue(actions).find((a) => a.id === commandId) ?? null\n      activeCommandProps.value = (args[0] as Record<string, unknown>) ?? null\n    }\n    modalState.show()\n  }\n\n  /** Closes the command palette and resets all state */\n  const close = (): void => {\n    modalState.hide()\n    reset()\n  }\n\n  /** Updates the filter query for searching commands */\n  const setFilterQuery = (query: string): void => {\n    filterQuery.value = query\n  }\n\n  /** Resets all internal state to initial values */\n  const reset = (): void => {\n    filterQuery.value = ''\n    activeCommand.value = null\n    activeCommandProps.value = null\n  }\n\n  return {\n    isOpen,\n    activeCommand,\n    activeCommandProps,\n    filterQuery,\n    filteredCommands: computed(() => [\n      {\n        label: '',\n        commands: filteredActions.value,\n      },\n      {\n        label: 'Pages',\n        commands: filteredRoutes.value,\n      },\n    ]),\n    open,\n    close,\n    setFilterQuery,\n    reset,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Base commands\n\n/**\n * The base naviation routes used in the command palette.\n * This object can be extended and passed to the useCommandPaletteState hook to add custom routes\n */\nexport const baseRoutes: CommandPaletteRoute[] = [\n  {\n    type: 'route',\n    id: 'environment',\n    name: 'Environment',\n    icon: ScalarIconBracketsCurly,\n    to: {\n      name: 'workspace.environment',\n    },\n  },\n  {\n    type: 'route',\n    id: 'cookies',\n    name: 'Cookies',\n    icon: ScalarIconCookie,\n    to: {\n      name: 'workspace.cookies',\n    },\n  },\n  {\n    type: 'route',\n    id: 'settings',\n    name: 'Settings',\n    icon: ScalarIconSlidersHorizontal,\n    to: {\n      name: 'workspace.settings',\n    },\n  },\n]\n\n/**\n * The internal client command palette actions\n * This object can be extended and passed to the useCommandPaletteState hook to add custom actions\n */\nexport const baseClientActions = [\n  {\n    id: 'import-from-openapi-swagger-postman-curl',\n    name: 'Import from OpenAPI/Swagger/cURL',\n    component: CommandPaletteImport,\n    icon: ScalarIconArrowSquareIn,\n  },\n  {\n    id: 'import-postman-collection',\n    name: 'Import Postman Collection',\n    component: CommandPaletteImportPostman,\n    icon: ScalarIconArrowSquareIn,\n    hidden: true,\n  },\n  {\n    id: 'create-openapi-document',\n    name: 'Create OpenAPI Document',\n    component: CommandPaletteOpenApiDocument,\n    icon: ScalarIconPackage,\n  },\n  {\n    id: 'add-tag',\n    name: 'Add Tag',\n    component: CommandPaletteTag,\n    icon: ScalarIconFolder,\n  },\n  {\n    id: 'create-request',\n    name: 'Create Request',\n    component: CommandPaletteRequest,\n    icon: ScalarIconArrowUpRight,\n  },\n  {\n    id: 'add-example',\n    name: 'Add Example',\n    component: CommandPaletteExample,\n    icon: ScalarIconPuzzlePiece,\n  },\n  {\n    id: 'import-curl-command',\n    name: 'Import cURL Command',\n    hidden: true,\n    component: CommandPaletteImportCurl,\n  },\n  {\n    id: 'edit-tag',\n    name: 'Edit Tag',\n    hidden: true,\n    component: CommandPaletteTag,\n  },\n  {\n    id: 'edit-example',\n    name: 'Edit Example',\n    hidden: true,\n    component: CommandPaletteExample,\n  },\n] as const satisfies BaseCommandPaletteAction[]\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiJA,IAAa,0BACX,UAAoD,mBACpD,SAAkD,eAC1B;CACxB,MAAM,aAAa,UAAU;CAE7B,MAAM,cAAc,IAAI,GAAG;CAC3B,MAAM,gBAAgB,WAAwC,KAAK;CACnE,MAAM,qBAAqB,IAAoC,KAAK;;CAGpE,MAAM,SAAS,eAAwB,WAAW,KAAK;CAEvD,MAAM,cAAc,eAEhB,IAAI,KAAK,QAAQ,QAAQ,EAAE;EACzB,MAAM,CAAC,OAAO;EACd,WAAW;EACZ,CAAC,CACL;CAED,MAAM,aAAa,eAEf,IAAI,KAAK,QAAQ,OAAO,EAAE;EACxB,MAAM,CAAC,OAAO;EACd,WAAW;EACZ,CAAC,CACL;;;;;;;CAQD,MAAM,kBAAkB,eAAuC;EAC7D,MAAM,QAAQ,YAAY,MAAM,aAAa,CAAC,MAAM;AAMpD,UAHa,QAAQ,YAAY,MAAM,OAAO,MAAM,CAAC,KAAK,MAAM,EAAE,KAAK,GAAG,QAAQ,QAAQ,EAG9E,QAAQ,MAAM,CAAC,EAAE,OAAO;GACpC;CAEF,MAAM,iBAAiB,eAAsC;EAC3D,MAAM,QAAQ,YAAY,MAAM,aAAa,CAAC,MAAM;AAEpD,SAAO,QAAQ,WAAW,MAAM,OAAO,MAAM,CAAC,KAAK,MAAM,EAAE,KAAK,GAAG,QAAQ,OAAO;GAClF;;;;;;CAOF,MAAM,QAAqB,WAA0B,GAAG,SAA0B;AAChF,MAAI,WAAW;AACb,iBAAc,QAAQ,QAAQ,QAAQ,CAAC,MAAM,MAAM,EAAE,OAAO,UAAU,IAAI;AAC1E,sBAAmB,QAAS,KAAK,MAAkC;;AAErE,aAAW,MAAM;;;CAInB,MAAM,cAAoB;AACxB,aAAW,MAAM;AACjB,SAAO;;;CAIT,MAAM,kBAAkB,UAAwB;AAC9C,cAAY,QAAQ;;;CAItB,MAAM,cAAoB;AACxB,cAAY,QAAQ;AACpB,gBAAc,QAAQ;AACtB,qBAAmB,QAAQ;;AAG7B,QAAO;EACL;EACA;EACA;EACA;EACA,kBAAkB,eAAe,CAC/B;GACE,OAAO;GACP,UAAU,gBAAgB;GAC3B,EACD;GACE,OAAO;GACP,UAAU,eAAe;GAC1B,CACF,CAAC;EACF;EACA;EACA;EACA;EACD;;;;;;AAUH,IAAa,aAAoC;CAC/C;EACE,MAAM;EACN,IAAI;EACJ,MAAM;EACN,MAAM;EACN,IAAI,EACF,MAAM,yBACP;EACF;CACD;EACE,MAAM;EACN,IAAI;EACJ,MAAM;EACN,MAAM;EACN,IAAI,EACF,MAAM,qBACP;EACF;CACD;EACE,MAAM;EACN,IAAI;EACJ,MAAM;EACN,MAAM;EACN,IAAI,EACF,MAAM,sBACP;EACF;CACF;;;;;AAMD,IAAa,oBAAoB;CAC/B;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACP;CACD;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACN,QAAQ;EACT;CACD;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACP;CACD;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACP;CACD;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACP;CACD;EACE,IAAI;EACJ,MAAM;EACN,WAAW;EACX,MAAM;EACP;CACD;EACE,IAAI;EACJ,MAAM;EACN,QAAQ;EACR,WAAW;EACZ;CACD;EACE,IAAI;EACJ,MAAM;EACN,QAAQ;EACR,WAAW;EACZ;CACD;EACE,IAAI;EACJ,MAAM;EACN,QAAQ;EACR,WAAW;EACZ;CACF"}

package/dist/v2/features/command-palette/index.d.ts

@@ -1,3 +1,3 @@
-export { default as CommandPaletteImport } from './components/CommandPaletteImport.vue';
-export { default as TheCommandPalette } from './TheCommandPalette.vue';
+export { default as CommandPaletteImport } from './components/CommandPaletteImport.vue.js';
+export { default as TheCommandPalette } from './TheCommandPalette.vue.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/v2/features/command-palette/index.js

@@ -1,3 +1,3 @@
-import { t as TheCommandPalette_default } from "../../../TheCommandPalette-Dl9TAeke.js";
-import { t as CommandPaletteImport_default } from "../../../CommandPaletteImport-Diu5dDIY.js";
+import CommandPaletteImport_default from "./components/CommandPaletteImport.vue.js";
+import TheCommandPalette_default from "./TheCommandPalette.vue.js";
 export { CommandPaletteImport_default as CommandPaletteImport, TheCommandPalette_default as TheCommandPalette };

package/dist/v2/features/editor/config.js

@@ -0,0 +1,19 @@
+import { ensureMonacoEnvironment } from "./helpers/ensure-monaco-environment.js";
+import { applyScalarTheme } from "./helpers/theme/apply-scalar-theme.js";
+import { toValue, watch } from "vue";
+import "monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css";
+import "monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
+//#region src/v2/features/editor/config.ts
+/**
+* Configures the Monaco editor with custom Scala theme settings.
+* Applies the theme whenever the theme or dark mode value changes.
+* In development mode, ensures Monaco environment is configured (worker setup handled by Vite config).
+*/
+var useMonacoEditorConfiguration = ({ theme, darkMode }) => {
+	ensureMonacoEnvironment();
+	watch([() => toValue(theme), () => toValue(darkMode)], ([theme, darkMode]) => applyScalarTheme(theme, darkMode), { immediate: true });
+};
+//#endregion
+export { useMonacoEditorConfiguration };
+
+//# sourceMappingURL=config.js.map

package/dist/v2/features/editor/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../../../src/v2/features/editor/config.ts"],"sourcesContent":["import { type MaybeRefOrGetter, toValue, watch } from 'vue'\n\nimport { ensureMonacoEnvironment } from './helpers/ensure-monaco-environment'\nimport { applyScalarTheme } from './helpers/theme/apply-scalar-theme'\n\nimport 'monaco-editor/esm/vs/language/json/monaco.contribution'\nimport 'monaco-editor/esm/vs/basic-languages/yaml/yaml.contribution'\nimport 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding'\nimport 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.css'\nimport 'monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css'\n\n/**\n * Configures the Monaco editor with custom Scala theme settings.\n * Applies the theme whenever the theme or dark mode value changes.\n * In development mode, ensures Monaco environment is configured (worker setup handled by Vite config).\n */\nexport const useMonacoEditorConfiguration = ({\n  theme,\n  darkMode,\n}: {\n  theme: MaybeRefOrGetter<string>\n  darkMode: MaybeRefOrGetter<boolean>\n}): void => {\n  // Ensure Monaco environment only in production to prevent worker misconfiguration.\n  if (!import.meta.env.DEV) {\n    ensureMonacoEnvironment()\n  }\n\n  // Watch for changes to theme or darkMode and apply the Scalar theme immediately.\n  watch([() => toValue(theme), () => toValue(darkMode)], ([theme, darkMode]) => applyScalarTheme(theme, darkMode), {\n    immediate: true,\n  })\n}\n"],"mappings":";;;;;;;;;;;AAgBA,IAAa,gCAAgC,EAC3C,OACA,eAIU;AAGR,0BAAyB;AAI3B,OAAM,OAAO,QAAQ,MAAM,QAAQ,QAAQ,SAAS,CAAC,GAAG,CAAC,OAAO,cAAc,iBAAiB,OAAO,SAAS,EAAE,EAC/G,WAAW,MACZ,CAAC"}

package/dist/v2/features/editor/helpers/configure-language-support.js

@@ -0,0 +1,48 @@
+import openapi_3_1_schema_default from "../schemas/openapi-3.1-schema.json.js";
+import * as monaco from "monaco-editor/esm/vs/editor/editor.api.js";
+import { configureMonacoYaml } from "monaco-yaml";
+//#region src/v2/features/editor/helpers/configure-language-support.ts
+var OPENAPI_JSON_SCHEMA_URI = "inmemory://model/scalar/openapi-json-schema";
+/**
+* Configures JSON language support for the given model URI
+*
+* @param globPattern - The glob pattern to match the files to configure language support for
+*/
+var configureJson = (globPattern) => {
+	const defaults = monaco.languages.json.jsonDefaults;
+	const current = defaults.diagnosticsOptions;
+	const schemas = [...(current.schemas ?? []).filter((s) => s.uri !== OPENAPI_JSON_SCHEMA_URI), {
+		uri: OPENAPI_JSON_SCHEMA_URI,
+		fileMatch: [globPattern],
+		schema: openapi_3_1_schema_default
+	}];
+	defaults.setDiagnosticsOptions({
+		...current,
+		validate: true,
+		enableSchemaRequest: false,
+		schemas
+	});
+};
+/**
+* Configures YAML language support for the given model URI
+*
+* @param globPattern - The glob pattern to match the files to configure language support for
+*/
+var configureYaml = (globPattern) => {
+	configureMonacoYaml(monaco, {
+		enableSchemaRequest: false,
+		validate: true,
+		format: true,
+		completion: true,
+		hover: true,
+		schemas: [{
+			fileMatch: [globPattern],
+			schema: openapi_3_1_schema_default,
+			uri: OPENAPI_JSON_SCHEMA_URI
+		}]
+	});
+};
+//#endregion
+export { configureJson, configureYaml };
+
+//# sourceMappingURL=configure-language-support.js.map

package/dist/v2/features/editor/helpers/configure-language-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-language-support.js","names":[],"sources":["../../../../../src/v2/features/editor/helpers/configure-language-support.ts"],"sourcesContent":["import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'\nimport { configureMonacoYaml } from 'monaco-yaml'\n\nimport openApiJsonSchema from './../schemas/openapi-3.1-schema.json'\n\nconst OPENAPI_JSON_SCHEMA_URI = 'inmemory://model/scalar/openapi-json-schema'\n\n/**\n * Configures JSON language support for the given model URI\n *\n * @param globPattern - The glob pattern to match the files to configure language support for\n */\nexport const configureJson = (globPattern: string): void => {\n  const defaults = monaco.languages.json.jsonDefaults\n  const current = defaults.diagnosticsOptions\n\n  const existingSchemas = current.schemas ?? []\n  const schemas = [\n    ...existingSchemas.filter((s) => s.uri !== OPENAPI_JSON_SCHEMA_URI),\n    {\n      uri: OPENAPI_JSON_SCHEMA_URI,\n      fileMatch: [globPattern],\n      schema: openApiJsonSchema,\n    },\n  ]\n\n  defaults.setDiagnosticsOptions({\n    ...current,\n    validate: true,\n    enableSchemaRequest: false,\n    schemas,\n  })\n}\n\n/**\n * Configures YAML language support for the given model URI\n *\n * @param globPattern - The glob pattern to match the files to configure language support for\n */\nexport const configureYaml = (globPattern: string): void => {\n  configureMonacoYaml(monaco, {\n    enableSchemaRequest: false,\n    validate: true,\n    format: true,\n    completion: true,\n    hover: true,\n    schemas: [\n      {\n        // If YAML file is opened matching this glob\n        fileMatch: [globPattern],\n        schema: openApiJsonSchema,\n        uri: OPENAPI_JSON_SCHEMA_URI,\n      },\n    ],\n  })\n}\n"],"mappings":";;;;AAKA,IAAM,0BAA0B;;;;;;AAOhC,IAAa,iBAAiB,gBAA8B;CAC1D,MAAM,WAAW,OAAO,UAAU,KAAK;CACvC,MAAM,UAAU,SAAS;CAGzB,MAAM,UAAU,CACd,IAFsB,QAAQ,WAAW,EAAE,EAExB,QAAQ,MAAM,EAAE,QAAQ,wBAAwB,EACnE;EACE,KAAK;EACL,WAAW,CAAC,YAAY;EACxB,QAAQ;EACT,CACF;AAED,UAAS,sBAAsB;EAC7B,GAAG;EACH,UAAU;EACV,qBAAqB;EACrB;EACD,CAAC;;;;;;;AAQJ,IAAa,iBAAiB,gBAA8B;AAC1D,qBAAoB,QAAQ;EAC1B,qBAAqB;EACrB,UAAU;EACV,QAAQ;EACR,YAAY;EACZ,OAAO;EACP,SAAS,CACP;GAEE,WAAW,CAAC,YAAY;GACxB,QAAQ;GACR,KAAK;GACN,CACF;EACF,CAAC"}

package/dist/v2/features/editor/helpers/ensure-monaco-environment.js

@@ -0,0 +1,21 @@
+import EditorWorker from "monaco-editor/esm/vs/editor/editor.worker.js?worker";
+import JsonWorker from "monaco-editor/esm/vs/language/json/json.worker.js?worker";
+import YamlWorker from "monaco-yaml/yaml.worker.js?worker";
+//#region src/v2/features/editor/helpers/ensure-monaco-environment.ts
+/**
+* This function ensures that the Monaco Editor's global environment is configured
+* to provide the correct web worker for each language (json, yaml, or the default editor).
+*/
+var ensureMonacoEnvironment = () => {
+	globalThis.MonacoEnvironment ??= { getWorker(_workerId, label) {
+		switch (label) {
+			case "json": return new JsonWorker();
+			case "yaml": return new YamlWorker();
+			default: return new EditorWorker();
+		}
+	} };
+};
+//#endregion
+export { ensureMonacoEnvironment };
+
+//# sourceMappingURL=ensure-monaco-environment.js.map

package/dist/v2/features/editor/helpers/ensure-monaco-environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-monaco-environment.js","names":[],"sources":["../../../../../src/v2/features/editor/helpers/ensure-monaco-environment.ts"],"sourcesContent":["import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker.js?worker'\nimport JsonWorker from 'monaco-editor/esm/vs/language/json/json.worker.js?worker'\nimport YamlWorker from 'monaco-yaml/yaml.worker.js?worker'\n\n/**\n * This function ensures that the Monaco Editor's global environment is configured\n * to provide the correct web worker for each language (json, yaml, or the default editor).\n */\nexport const ensureMonacoEnvironment = (): void => {\n  // Set the MonacoEnvironment on the global scope if it hasn't already been set\n  globalThis.MonacoEnvironment ??= {\n    getWorker(_workerId: string, label: string): Worker {\n      switch (label) {\n        case 'json':\n          return new JsonWorker()\n        case 'yaml':\n          return new YamlWorker()\n        default:\n          return new EditorWorker()\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;AAQA,IAAa,gCAAsC;AAEjD,YAAW,sBAAsB,EAC/B,UAAU,WAAmB,OAAuB;AAClD,UAAQ,OAAR;GACE,KAAK,OACH,QAAO,IAAI,YAAY;GACzB,KAAK,OACH,QAAO,IAAI,YAAY;GACzB,QACE,QAAO,IAAI,cAAc;;IAGhC"}

package/dist/v2/features/editor/helpers/json/create-json-model.js

@@ -0,0 +1,31 @@
+import { getJsonAstNodeFromPath } from "./get-json-ast-node-from-path.js";
+import { configureJson } from "../configure-language-support.js";
+import * as monaco from "monaco-editor";
+//#region src/v2/features/editor/helpers/json/create-json-model.ts
+/**
+* Creates a JSON Monaco editor model with enhanced language support.
+*
+* @param value - The initial JSON content for the model.
+* @returns An object containing the Monaco model and a function to get a range from a JSON path.
+*
+* The returned `getRangeFromPath` function asynchronously finds the AST node for a JSON path,
+* converts its offset and length to a Monaco Range, or returns null if not found.
+*/
+var createJsonModel = (value) => {
+	const model = monaco.editor.createModel(value ?? "", "json");
+	configureJson(model.uri.toString());
+	return {
+		model,
+		getRangeFromPath: async (path) => {
+			const node = await getJsonAstNodeFromPath(model, path);
+			if (!node) return null;
+			const start = model.getPositionAt(node.offset);
+			const end = model.getPositionAt(node.offset + node.length);
+			return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+		}
+	};
+};
+//#endregion
+export { createJsonModel };
+
+//# sourceMappingURL=create-json-model.js.map

package/dist/v2/features/editor/helpers/json/create-json-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-json-model.js","names":[],"sources":["../../../../../../src/v2/features/editor/helpers/json/create-json-model.ts"],"sourcesContent":["import * as monaco from 'monaco-editor'\n\nimport { getJsonAstNodeFromPath } from '@/v2/features/editor/helpers/json/get-json-ast-node-from-path'\nimport type { EditorModel, Path } from '@/v2/features/editor/helpers/model'\n\nimport { configureJson } from '../configure-language-support'\n\n/**\n * Creates a JSON Monaco editor model with enhanced language support.\n *\n * @param value - The initial JSON content for the model.\n * @returns An object containing the Monaco model and a function to get a range from a JSON path.\n *\n * The returned `getRangeFromPath` function asynchronously finds the AST node for a JSON path,\n * converts its offset and length to a Monaco Range, or returns null if not found.\n */\nexport const createJsonModel = (value?: string): EditorModel => {\n  const model = monaco.editor.createModel(value ?? '', 'json')\n\n  // Configure language support\n  configureJson(model.uri.toString())\n\n  return {\n    model,\n    getRangeFromPath: async (path: Path) => {\n      const node = await getJsonAstNodeFromPath(model, path)\n      if (!node) {\n        return null\n      }\n\n      // Convert the AST node to a range\n      const start = model.getPositionAt(node.offset)\n      const end = model.getPositionAt(node.offset + node.length)\n\n      return new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column)\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,IAAa,mBAAmB,UAAgC;CAC9D,MAAM,QAAQ,OAAO,OAAO,YAAY,SAAS,IAAI,OAAO;AAG5D,eAAc,MAAM,IAAI,UAAU,CAAC;AAEnC,QAAO;EACL;EACA,kBAAkB,OAAO,SAAe;GACtC,MAAM,OAAO,MAAM,uBAAuB,OAAO,KAAK;AACtD,OAAI,CAAC,KACH,QAAO;GAIT,MAAM,QAAQ,MAAM,cAAc,KAAK,OAAO;GAC9C,MAAM,MAAM,MAAM,cAAc,KAAK,SAAS,KAAK,OAAO;AAE1D,UAAO,IAAI,OAAO,MAAM,MAAM,YAAY,MAAM,QAAQ,IAAI,YAAY,IAAI,OAAO;;EAEtF"}

package/dist/v2/features/editor/helpers/json/get-json-ast-node-from-path.d.ts

@@ -1,5 +1,5 @@
 import * as monaco from 'monaco-editor';
-import type { JsonPath } from './json-ast';
+import type { JsonPath } from './json-ast.js';
 /**
  * Retrieves a JSON AST node from a Monaco editor model at the specified JSON path.
  *