@scalar/workspace-store 0.5.2 → 0.7.0

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAG/E,OAAO,EAAoB,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,wCAAwC,CAAA;AACpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AAI5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAGxD,eAAO,MAAM,mBAAmB,0BAA0B,CAAA;AAE1D,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,qBAAqB,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,0BAA0B,CAAA;AAC1D,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,0BAA0B,CAAA;AAC5D,KAAK,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,0BAA0B,CAAA;AAEnF,KAAK,sBAAsB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;AAE1D,KAAK,8BAA8B,GAAG;IACpC,SAAS,EAAE,sBAAsB,EAAE,CAAA;IACnC,IAAI,CAAC,EAAE,aAAa,CAAA;IACpB,MAAM,CAAC,EAAE,uBAAuB,CAAA;CACjC,CAAA;AACD,KAAK,0BAA0B,GAC3B,CAAC;IACC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,QAAQ,CAAA;CACf,GAAG,8BAA8B,CAAC,GACnC,CAAC;IACC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,KAAK,CAAA;CACZ,GAAG,8BAA8B,CAAC,CAAA;AAIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/server.js

@@ -4,9 +4,10 @@ import fs from "node:fs/promises";
 import { cwd } from "node:process";
 import { createNavigation } from "./navigation/index.js";
 import { extensions } from "./schemas/extensions.js";
-import { coerceValue } from "./schemas/typebox-coerce.js";
 import { OpenAPIDocumentSchema } from "./schemas/v3.1/strict/openapi-document.js";
 import { keyOf } from "./helpers/general.js";
+import { fetchUrls, readFiles } from "@scalar/openapi-parser/plugins";
+import { coerceValue } from "./schemas/typebox-coerce.js";
 const DEFAULT_ASSETS_FOLDER = "assets";
 const WORKSPACE_FILE_NAME = "scalar-workspace.json";
 const httpMethods = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
@@ -75,30 +76,52 @@ function externalizePathReferences(document, meta) {
   });
   return result;
 }
-function createServerWorkspaceStore(workspaceProps) {
-  const documents = workspaceProps.documents.map((el) => {
-    const document = upgrade(el.document).specification;
-    const castedDocument = coerceValue(OpenAPIDocumentSchema, document);
-    return { ...el, document: castedDocument };
-  });
-  const assets = documents.reduce((acc, { name, document }) => {
-    acc[name] = {
-      components: document.components,
-      operations: document.paths && escapePaths(filterHttpMethodsOnly(document.paths))
-    };
-    return acc;
-  }, {});
+async function loadDocument(workspaceDocument) {
+  if ("url" in workspaceDocument) {
+    return fetchUrls().exec(workspaceDocument.url);
+  }
+  if ("path" in workspaceDocument) {
+    return readFiles().exec(workspaceDocument.path);
+  }
+  return {
+    ok: true,
+    data: workspaceDocument.document
+  };
+}
+async function createServerWorkspaceStore(workspaceProps) {
   const workspace = {
     ...workspaceProps.meta,
-    documents: documents.reduce((acc, { name, document, meta }) => {
-      const options = workspaceProps.mode === "ssr" ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl } : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER };
-      const components = externalizeComponentReferences(document, options);
-      const paths = externalizePathReferences(document, options);
-      const { entries } = createNavigation(document, workspaceProps.config ?? {});
-      acc[name] = { ...meta, ...document, components, paths, [extensions.document.navigation]: entries };
-      return acc;
-    }, {})
+    documents: {}
+  };
+  const assets = {};
+  const addDocumentSync = (document, meta) => {
+    const { name, ...documentMeta } = meta;
+    const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document).specification);
+    assets[meta.name] = {
+      components: documentV3.components,
+      operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths))
+    };
+    const options = workspaceProps.mode === "ssr" ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl } : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER };
+    const components = externalizeComponentReferences(documentV3, options);
+    const paths = externalizePathReferences(documentV3, options);
+    const { entries } = createNavigation(documentV3, workspaceProps.config ?? {});
+    workspace.documents[meta.name] = {
+      ...documentMeta,
+      ...documentV3,
+      components,
+      paths,
+      [extensions.document.navigation]: entries
+    };
   };
+  const addDocument = async (input) => {
+    const document = await loadDocument(input);
+    if (!document.ok) {
+      console.warn(`Failed to load document "${input.name}`);
+      return;
+    }
+    addDocumentSync(document.data, { name: input.name, ...input.meta });
+  };
+  await Promise.all(workspaceProps.documents.map(addDocument));
   return {
     /**
      * Generates workspace chunks by writing components and operations to the filesystem.
@@ -176,36 +199,16 @@ function createServerWorkspaceStore(workspaceProps) {
       return getValueByPath(assets, parseJsonPointer(pointer));
     },
     /**
-     * Adds a new document to the workspace.
+     * Adds a new document to the workspace asynchronously.
      *
-     * The document will be:
-     * - Upgraded to OpenAPI 3.1 if needed
-     * - Split into components and operations chunks
-     * - Have its references externalized based on the workspace mode
-     * - Added to the workspace with its metadata
+     * This function:
+     * 1. Loads the document using the provided input
+     * 2. Checks if the document loaded successfully
+     * 3. If successful, adds the document to the workspace using addDocumentSync
      *
-     * @param document - The OpenAPI document to add
-     * @param meta - Document metadata including required name and optional settings
+     * @param input - The document input containing the document source and metadata
      */
-    addDocument: (document, meta) => {
-      const { name, ...documentMeta } = meta;
-      const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document).specification);
-      assets[meta.name] = {
-        components: documentV3.components,
-        operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths))
-      };
-      const options = workspaceProps.mode === "ssr" ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl } : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER };
-      const components = externalizeComponentReferences(documentV3, options);
-      const paths = externalizePathReferences(documentV3, options);
-      const { entries } = createNavigation(documentV3, workspaceProps.config ?? {});
-      workspace.documents[meta.name] = {
-        ...documentMeta,
-        ...documentV3,
-        components,
-        paths,
-        [extensions.document.navigation]: entries
-      };
-    }
+    addDocument
   };
 }
 export {

package/dist/server.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/server.ts"],
-  "sourcesContent": ["import { escapeJsonPointer, upgrade } from '@scalar/openapi-parser'\nimport { getValueByPath, parseJsonPointer } from './helpers/json-path-utils'\nimport type { WorkspaceDocumentMeta, WorkspaceMeta } from './schemas/workspace'\nimport fs from 'node:fs/promises'\nimport { cwd } from 'node:process'\nimport { createNavigation, type createNavigationOptions } from '@/navigation'\nimport { extensions } from '@/schemas/extensions'\nimport { coerceValue } from '@/schemas/typebox-coerce'\nimport { OpenAPIDocumentSchema, type OpenApiDocument } from '@/schemas/v3.1/strict/openapi-document'\nimport type { PathsObject } from '@/schemas/v3.1/strict/paths'\nimport { keyOf } from '@/helpers/general'\nimport type { ComponentsObject } from '@/schemas/v3.1/strict/components'\nimport type { OperationObject } from '@/schemas/v3.1/strict/path-operations'\n\nconst DEFAULT_ASSETS_FOLDER = 'assets'\nexport const WORKSPACE_FILE_NAME = 'scalar-workspace.json'\n\n// TODO: support input document from different sources\ntype CreateServerWorkspaceStoreBase = {\n  documents: {\n    name: string\n    document: Record<string, unknown> | string\n    meta?: WorkspaceDocumentMeta\n  }[]\n  meta?: WorkspaceMeta\n  config?: createNavigationOptions\n}\ntype CreateServerWorkspaceStore =\n  | ({\n      directory?: string\n      mode: 'static'\n    } & CreateServerWorkspaceStoreBase)\n  | ({\n      baseUrl: string\n      mode: 'ssr'\n    } & CreateServerWorkspaceStoreBase)\n\nconst httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])\n\n/**\n * Filters an OpenAPI PathsObject to only include standard HTTP methods.\n * Removes any vendor extensions or other non-HTTP properties.\n *\n * @param paths - The OpenAPI PathsObject to filter\n * @returns A new PathsObject containing only standard HTTP methods\n *\n * @example\n * Input: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"x-custom\": {...},\n *     \"post\": {...}\n *   }\n * }\n * Output: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"post\": {...}\n *   }\n * }\n */\nexport function filterHttpMethodsOnly(paths: PathsObject) {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  // Todo: skip extension properties\n  for (const [path, methods] of Object.entries(paths)) {\n    if (!methods) {\n      continue\n    }\n\n    const filteredMethods: Record<string, any> = {}\n\n    for (const [method, operation] of Object.entries(methods)) {\n      if (httpMethods.has(method.toLowerCase())) {\n        filteredMethods[method] = operation\n      }\n    }\n\n    if (Object.keys(filteredMethods).length > 0) {\n      result[path] = filteredMethods\n    }\n  }\n\n  return result\n}\n\n/**\n * Escapes path keys in an OpenAPI PathsObject to be JSON Pointer compatible.\n * This is necessary because OpenAPI paths can contain characters that need to be escaped\n * when used as JSON Pointer references (like '/' and '~').\n *\n * @example\n * Input: { \"/users/{id}\": { ... } }\n * Output: { \"/users~1{id}\": { ... } }\n */\nexport function escapePaths(paths: Record<string, Record<string, OperationObject>>) {\n  const result: Record<string, Record<string, OperationObject>> = {}\n  Object.keys(paths).forEach((path) => {\n    result[escapeJsonPointer(path)] = paths[path]\n  })\n\n  return result\n}\n\n/**\n * Externalizes components by turning them into refs.\n */\nexport function externalizeComponentReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.components) {\n    return result\n  }\n\n  Object.entries(document.components).forEach(([type, component]) => {\n    if (!component || typeof component !== 'object') {\n      return result\n    }\n\n    result[type] = {}\n    Object.keys(component).forEach((name) => {\n      const ref =\n        meta.mode === 'ssr'\n          ? `${meta.baseUrl}/${meta.name}/components/${type}/${name}#`\n          : `./chunks/${meta.name}/components/${type}/${name}.json#`\n\n      result[type][name] = { '$ref': ref, $global: true }\n    })\n  })\n\n  return result\n}\n\n/**\n * Externalizes paths operations by turning them into refs.\n */\nexport function externalizePathReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.paths) {\n    return result\n  }\n\n  Object.entries(document.paths).forEach(([path, pathItem]) => {\n    if (!pathItem || typeof pathItem !== 'object') {\n      return result\n    }\n\n    const pathItemRecord = pathItem as Record<string, unknown>\n\n    result[path] = {}\n\n    const escapedPath = escapeJsonPointer(path)\n\n    keyOf(pathItemRecord).forEach((type) => {\n      if (httpMethods.has(type)) {\n        const ref =\n          meta.mode === 'ssr'\n            ? `${meta.baseUrl}/${meta.name}/operations/${escapedPath}/${type}#`\n            : `./chunks/${meta.name}/operations/${escapedPath}/${type}.json#`\n\n        result[path][type] = { '$ref': ref, $global: true }\n      } else {\n        result[path][type] = pathItemRecord[type]\n      }\n    })\n  })\n\n  return result\n}\n\n/**\n * Create server state workspace store\n */\nexport function createServerWorkspaceStore(workspaceProps: CreateServerWorkspaceStore) {\n  const documents = workspaceProps.documents.map((el) => {\n    const document = upgrade(el.document).specification\n\n    const castedDocument = coerceValue(OpenAPIDocumentSchema, document)\n\n    return { ...el, document: castedDocument }\n  })\n\n  /**\n   * A map of document chunks that can be loaded asynchronously by the client.\n   * Each document is split into components and operations to enable lazy loading.\n   * The keys are document names and values contain the components and operations\n   * for that document.\n   */\n  const assets = documents.reduce<\n    Record<string, { components?: ComponentsObject; operations?: Record<string, Record<string, OperationObject>> }>\n  >((acc, { name, document }) => {\n    acc[name] = {\n      components: document.components,\n      operations: document.paths && escapePaths(filterHttpMethodsOnly(document.paths)),\n    }\n    return acc\n  }, {})\n\n  /**\n   * Base workspace document containing essential metadata and document references.\n   *\n   * This workspace document provides the minimal information needed for initial rendering.\n   * All components and path operations are replaced with references to enable lazy loading.\n   *\n   * In SSR mode, references point to API endpoints.\n   * In static mode, references point to filesystem chunks.\n   */\n  const workspace = {\n    ...workspaceProps.meta,\n    documents: documents.reduce<Record<string, Record<string, unknown>>>((acc, { name, document, meta }) => {\n      const options =\n        workspaceProps.mode === 'ssr'\n          ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl }\n          : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER }\n\n      // Transform the original document by setting all the components and paths operations on refs\n      const components = externalizeComponentReferences(document, options)\n      const paths = externalizePathReferences(document, options)\n\n      // Here we create the sidebar\n      const { entries } = createNavigation(document, workspaceProps.config ?? {})\n\n      acc[name] = { ...meta, ...document, components, paths, [extensions.document.navigation]: entries }\n      return acc\n    }, {}),\n  }\n\n  return {\n    /**\n     * Generates workspace chunks by writing components and operations to the filesystem.\n     *\n     * This method is only available in static mode. It creates a directory structure containing:\n     * - A workspace file with metadata and document references\n     * - Component chunks split by type (schemas, parameters, etc)\n     * - Operation chunks split by path and HTTP method\n     *\n     * The generated workspace references will be relative file paths pointing to these chunks.\n     *\n     * @throws {Error} If called when mode is not 'static'\n     */\n    generateWorkspaceChunks: async () => {\n      if (workspaceProps.mode !== 'static') {\n        throw 'Mode has to be set to `static` to generate filesystem workspace chunks'\n      }\n\n      // Write the workspace document\n      const basePath = `${cwd()}/${workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER}`\n      await fs.mkdir(basePath, { recursive: true })\n\n      // Write the workspace contents on the file system\n      await fs.writeFile(`${basePath}/${WORKSPACE_FILE_NAME}`, JSON.stringify(workspace))\n\n      // Write the chunks\n      for (const [name, { components, operations }] of Object.entries(assets)) {\n        // Write the components chunks\n        if (components) {\n          for (const [type, component] of Object.entries(components as Record<string, Record<string, unknown>>)) {\n            const componentPath = `${basePath}/chunks/${name}/components/${type}`\n            await fs.mkdir(componentPath, { recursive: true })\n\n            for (const [key, value] of Object.entries(component)) {\n              await fs.writeFile(`${componentPath}/${key}.json`, JSON.stringify(value))\n            }\n          }\n        }\n\n        // Write the operations chunks\n        if (operations) {\n          for (const [path, methods] of Object.entries(operations)) {\n            const operationPath = `${basePath}/chunks/${name}/operations/${path}`\n            await fs.mkdir(operationPath, { recursive: true })\n\n            for (const [method, operation] of Object.entries(methods)) {\n              await fs.writeFile(`${operationPath}/${method}.json`, JSON.stringify(operation))\n            }\n          }\n        }\n      }\n    },\n    /**\n     * Returns the workspace document containing metadata and all sparse documents.\n     *\n     * The workspace document includes:\n     * - Global workspace metadata (theme, active document, etc)\n     * - Document metadata and sparse document\n     * - In SSR mode: References point to in-memory chunks\n     * - In static mode: References point to filesystem chunks\n     *\n     * @returns The complete workspace document\n     */\n    getWorkspace: () => {\n      return workspace\n    },\n    /**\n     * Retrieves a chunk of data from the workspace using a JSON Pointer\n     *\n     * A JSON Pointer is a string that references a specific location in a JSON document.\n     * Only components and operations chunks can be retrieved.\n     *\n     * @example\n     * ```ts\n     * // Get a component\n     * get('#/document-name/components/schemas/User')\n     *\n     * // Get an operation\n     * get('#/document-name/operations/pets/get')\n     * ```\n     *\n     * @param pointer - The JSON Pointer string to locate the chunk\n     * @returns The chunk data if found, undefined otherwise\n     */\n    get: (pointer: string) => {\n      return getValueByPath(assets, parseJsonPointer(pointer))\n    },\n    /**\n     * Adds a new document to the workspace.\n     *\n     * The document will be:\n     * - Upgraded to OpenAPI 3.1 if needed\n     * - Split into components and operations chunks\n     * - Have its references externalized based on the workspace mode\n     * - Added to the workspace with its metadata\n     *\n     * @param document - The OpenAPI document to add\n     * @param meta - Document metadata including required name and optional settings\n     */\n    addDocument: (document: Record<string, unknown>, meta: { name: string } & WorkspaceDocumentMeta) => {\n      const { name, ...documentMeta } = meta\n\n      const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document).specification)\n\n      // add the assets\n      assets[meta.name] = {\n        components: documentV3.components,\n        operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths)),\n      }\n\n      const options =\n        workspaceProps.mode === 'ssr'\n          ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl }\n          : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER }\n\n      const components = externalizeComponentReferences(documentV3, options)\n      const paths = externalizePathReferences(documentV3, options)\n\n      // Build the sidebar entries\n      const { entries } = createNavigation(documentV3, workspaceProps.config ?? {})\n\n      // The document is now a minimal version with externalized references to components and operations.\n      // These references will be resolved asynchronously when needed through the workspace's get() method.\n      workspace.documents[meta.name] = {\n        ...documentMeta,\n        ...documentV3,\n        components,\n        paths,\n        [extensions.document.navigation]: entries,\n      }\n    },\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { escapeJsonPointer, upgrade } from '@scalar/openapi-parser'\nimport { getValueByPath, parseJsonPointer } from './helpers/json-path-utils'\nimport type { WorkspaceDocumentMeta, WorkspaceMeta } from './schemas/workspace'\nimport fs from 'node:fs/promises'\nimport { cwd } from 'node:process'\nimport { createNavigation, type createNavigationOptions } from '@/navigation'\nimport { extensions } from '@/schemas/extensions'\nimport { OpenAPIDocumentSchema, type OpenApiDocument } from '@/schemas/v3.1/strict/openapi-document'\nimport type { PathsObject } from '@/schemas/v3.1/strict/paths'\nimport { keyOf } from '@/helpers/general'\nimport type { OperationObject } from '@/schemas/v3.1/strict/path-operations'\nimport { fetchUrls, readFiles } from '@scalar/openapi-parser/plugins'\nimport { coerceValue } from '@/schemas/typebox-coerce'\nimport type { ComponentsObject } from '@/schemas/v3.1/strict/components'\nimport type { TraversedEntry } from '@/navigation/types'\n\nconst DEFAULT_ASSETS_FOLDER = 'assets'\nexport const WORKSPACE_FILE_NAME = 'scalar-workspace.json'\n\ntype WorkspaceDocumentMetaInput = {\n  name: string\n  meta?: WorkspaceDocumentMeta\n}\n\ntype UrlDoc = { url: string } & WorkspaceDocumentMetaInput\ntype FileDoc = { path: string } & WorkspaceDocumentMetaInput\ntype ObjectDoc = { document: Record<string, unknown> } & WorkspaceDocumentMetaInput\n\ntype WorkspaceDocumentInput = UrlDoc | ObjectDoc | FileDoc\n\ntype CreateServerWorkspaceStoreBase = {\n  documents: WorkspaceDocumentInput[]\n  meta?: WorkspaceMeta\n  config?: createNavigationOptions\n}\ntype CreateServerWorkspaceStore =\n  | ({\n      directory?: string\n      mode: 'static'\n    } & CreateServerWorkspaceStoreBase)\n  | ({\n      baseUrl: string\n      mode: 'ssr'\n    } & CreateServerWorkspaceStoreBase)\n\nconst httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])\n\n/**\n * Filters an OpenAPI PathsObject to only include standard HTTP methods.\n * Removes any vendor extensions or other non-HTTP properties.\n *\n * @param paths - The OpenAPI PathsObject to filter\n * @returns A new PathsObject containing only standard HTTP methods\n *\n * @example\n * Input: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"x-custom\": {...},\n *     \"post\": {...}\n *   }\n * }\n * Output: {\n *   \"/users\": {\n *     \"get\": {...},\n *     \"post\": {...}\n *   }\n * }\n */\nexport function filterHttpMethodsOnly(paths: PathsObject) {\n  const result: Record<string, Record<string, OperationObject>> = {}\n\n  // Todo: skip extension properties\n  for (const [path, methods] of Object.entries(paths)) {\n    if (!methods) {\n      continue\n    }\n\n    const filteredMethods: Record<string, any> = {}\n\n    for (const [method, operation] of Object.entries(methods)) {\n      if (httpMethods.has(method.toLowerCase())) {\n        filteredMethods[method] = operation\n      }\n    }\n\n    if (Object.keys(filteredMethods).length > 0) {\n      result[path] = filteredMethods\n    }\n  }\n\n  return result\n}\n\n/**\n * Escapes path keys in an OpenAPI PathsObject to be JSON Pointer compatible.\n * This is necessary because OpenAPI paths can contain characters that need to be escaped\n * when used as JSON Pointer references (like '/' and '~').\n *\n * @example\n * Input: { \"/users/{id}\": { ... } }\n * Output: { \"/users~1{id}\": { ... } }\n */\nexport function escapePaths(paths: Record<string, Record<string, OperationObject>>) {\n  const result: Record<string, Record<string, OperationObject>> = {}\n  Object.keys(paths).forEach((path) => {\n    result[escapeJsonPointer(path)] = paths[path]\n  })\n\n  return result\n}\n\n/**\n * Externalizes components by turning them into refs.\n */\nexport function externalizeComponentReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.components) {\n    return result\n  }\n\n  Object.entries(document.components).forEach(([type, component]) => {\n    if (!component || typeof component !== 'object') {\n      return result\n    }\n\n    result[type] = {}\n    Object.keys(component).forEach((name) => {\n      const ref =\n        meta.mode === 'ssr'\n          ? `${meta.baseUrl}/${meta.name}/components/${type}/${name}#`\n          : `./chunks/${meta.name}/components/${type}/${name}.json#`\n\n      result[type][name] = { '$ref': ref, $global: true }\n    })\n  })\n\n  return result\n}\n\n/**\n * Externalizes paths operations by turning them into refs.\n */\nexport function externalizePathReferences(\n  document: OpenApiDocument,\n  meta: { mode: 'ssr'; name: string; baseUrl: string } | { mode: 'static'; name: string; directory: string },\n) {\n  const result: Record<string, any> = {}\n\n  if (!document.paths) {\n    return result\n  }\n\n  Object.entries(document.paths).forEach(([path, pathItem]) => {\n    if (!pathItem || typeof pathItem !== 'object') {\n      return result\n    }\n\n    const pathItemRecord = pathItem as Record<string, unknown>\n\n    result[path] = {}\n\n    const escapedPath = escapeJsonPointer(path)\n\n    keyOf(pathItemRecord).forEach((type) => {\n      if (httpMethods.has(type)) {\n        const ref =\n          meta.mode === 'ssr'\n            ? `${meta.baseUrl}/${meta.name}/operations/${escapedPath}/${type}#`\n            : `./chunks/${meta.name}/operations/${escapedPath}/${type}.json#`\n\n        result[path][type] = { '$ref': ref, $global: true }\n      } else {\n        result[path][type] = pathItemRecord[type]\n      }\n    })\n  })\n\n  return result\n}\n\n/**\n * Resolves a workspace document from various input sources (URL, local file, or direct document object).\n *\n * @param workspaceDocument - The document input to resolve, which can be:\n *   - A URL to fetch the document from\n *   - A local file path to read the document from\n *   - A direct document object\n * @returns A promise that resolves to an object containing:\n *   - ok: boolean indicating if the resolution was successful\n *   - data: The resolved document data\n *\n * @example\n * // Resolve from URL\n * const urlDoc = await loadDocument({ name: 'api', url: 'https://api.example.com/openapi.json' })\n *\n * // Resolve direct document\n * const directDoc = await loadDocument({\n *   name: 'inline',\n *   document: { openapi: '3.0.0', paths: {} }\n * })\n */\nasync function loadDocument(workspaceDocument: WorkspaceDocumentInput) {\n  if ('url' in workspaceDocument) {\n    return fetchUrls().exec(workspaceDocument.url)\n  }\n\n  if ('path' in workspaceDocument) {\n    return readFiles().exec(workspaceDocument.path)\n  }\n\n  return {\n    ok: true as const,\n    data: workspaceDocument.document,\n  }\n}\n\n/**\n * Create server state workspace store\n */\nexport async function createServerWorkspaceStore(workspaceProps: CreateServerWorkspaceStore) {\n  /**\n   * Base workspace document containing essential metadata and document references.\n   *\n   * This workspace document provides the minimal information needed for initial rendering.\n   * All components and path operations are replaced with references to enable lazy loading.\n   *\n   * In SSR mode, references point to API endpoints.\n   * In static mode, references point to filesystem chunks.\n   */\n  const workspace = {\n    ...workspaceProps.meta,\n    documents: {} as Record<string, OpenApiDocument & { [extensions.document.navigation]: TraversedEntry[] }>,\n  }\n\n  /**\n   * A map of document chunks that can be loaded asynchronously by the client.\n   * Each document is split into components and operations to enable lazy loading.\n   * The keys are document names and values contain the components and operations\n   * for that document.\n   */\n  const assets = {} as Record<\n    string,\n    { components?: ComponentsObject; operations?: Record<string, Record<string, OperationObject>> }\n  >\n\n  /**\n   * Adds a new document to the workspace.\n   *\n   * This function processes an OpenAPI document by:\n   * 1. Converting it to OpenAPI 3.1 format if needed\n   * 2. Separating it into reusable components and path operations\n   * 3. Externalizing references based on the workspace mode (SSR or static)\n   * 4. Adding the processed document to the workspace with its metadata\n   *\n   * The resulting document contains minimal information with externalized references\n   * that will be resolved on-demand through the workspace's get() method.\n   *\n   * @param document - The OpenAPI document to process and add\n   * @param meta - Document metadata containing the required name and optional settings\n   */\n  const addDocumentSync = (document: Record<string, unknown>, meta: { name: string } & WorkspaceDocumentMeta) => {\n    const { name, ...documentMeta } = meta\n\n    const documentV3 = coerceValue(OpenAPIDocumentSchema, upgrade(document).specification)\n\n    // add the assets\n    assets[meta.name] = {\n      components: documentV3.components,\n      operations: documentV3.paths && escapePaths(filterHttpMethodsOnly(documentV3.paths)),\n    }\n\n    const options =\n      workspaceProps.mode === 'ssr'\n        ? { mode: workspaceProps.mode, name, baseUrl: workspaceProps.baseUrl }\n        : { mode: workspaceProps.mode, name, directory: workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER }\n\n    const components = externalizeComponentReferences(documentV3, options)\n    const paths = externalizePathReferences(documentV3, options)\n\n    // Build the sidebar entries\n    const { entries } = createNavigation(documentV3, workspaceProps.config ?? {})\n\n    // The document is now a minimal version with externalized references to components and operations.\n    // These references will be resolved asynchronously when needed through the workspace's get() method.\n    workspace.documents[meta.name] = {\n      ...documentMeta,\n      ...documentV3,\n      components,\n      paths,\n      [extensions.document.navigation]: entries,\n    }\n  }\n\n  /**\n   * Adds a new document to the workspace asynchronously.\n   *\n   * This function:\n   * 1. Loads the document using the provided input\n   * 2. Checks if the document loaded successfully\n   * 3. If successful, adds the document to the workspace using addDocumentSync\n   *\n   * @param input - The document input containing the document source and metadata\n   */\n  const addDocument = async (input: WorkspaceDocumentInput) => {\n    const document = await loadDocument(input)\n\n    if (!document.ok) {\n      console.warn(`Failed to load document \"${input.name}`)\n      return\n    }\n\n    addDocumentSync(document.data as Record<string, unknown>, { name: input.name, ...input.meta })\n  }\n\n  // Load and process all initial documents in parallel\n  await Promise.all(workspaceProps.documents.map(addDocument))\n\n  return {\n    /**\n     * Generates workspace chunks by writing components and operations to the filesystem.\n     *\n     * This method is only available in static mode. It creates a directory structure containing:\n     * - A workspace file with metadata and document references\n     * - Component chunks split by type (schemas, parameters, etc)\n     * - Operation chunks split by path and HTTP method\n     *\n     * The generated workspace references will be relative file paths pointing to these chunks.\n     *\n     * @throws {Error} If called when mode is not 'static'\n     */\n    generateWorkspaceChunks: async () => {\n      if (workspaceProps.mode !== 'static') {\n        throw 'Mode has to be set to `static` to generate filesystem workspace chunks'\n      }\n\n      // Write the workspace document\n      const basePath = `${cwd()}/${workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER}`\n      await fs.mkdir(basePath, { recursive: true })\n\n      // Write the workspace contents on the file system\n      await fs.writeFile(`${basePath}/${WORKSPACE_FILE_NAME}`, JSON.stringify(workspace))\n\n      // Write the chunks\n      for (const [name, { components, operations }] of Object.entries(assets)) {\n        // Write the components chunks\n        if (components) {\n          for (const [type, component] of Object.entries(components as Record<string, Record<string, unknown>>)) {\n            const componentPath = `${basePath}/chunks/${name}/components/${type}`\n            await fs.mkdir(componentPath, { recursive: true })\n\n            for (const [key, value] of Object.entries(component)) {\n              await fs.writeFile(`${componentPath}/${key}.json`, JSON.stringify(value))\n            }\n          }\n        }\n\n        // Write the operations chunks\n        if (operations) {\n          for (const [path, methods] of Object.entries(operations)) {\n            const operationPath = `${basePath}/chunks/${name}/operations/${path}`\n            await fs.mkdir(operationPath, { recursive: true })\n\n            for (const [method, operation] of Object.entries(methods)) {\n              await fs.writeFile(`${operationPath}/${method}.json`, JSON.stringify(operation))\n            }\n          }\n        }\n      }\n    },\n    /**\n     * Returns the workspace document containing metadata and all sparse documents.\n     *\n     * The workspace document includes:\n     * - Global workspace metadata (theme, active document, etc)\n     * - Document metadata and sparse document\n     * - In SSR mode: References point to in-memory chunks\n     * - In static mode: References point to filesystem chunks\n     *\n     * @returns The complete workspace document\n     */\n    getWorkspace: () => {\n      return workspace\n    },\n    /**\n     * Retrieves a chunk of data from the workspace using a JSON Pointer\n     *\n     * A JSON Pointer is a string that references a specific location in a JSON document.\n     * Only components and operations chunks can be retrieved.\n     *\n     * @example\n     * ```ts\n     * // Get a component\n     * get('#/document-name/components/schemas/User')\n     *\n     * // Get an operation\n     * get('#/document-name/operations/pets/get')\n     * ```\n     *\n     * @param pointer - The JSON Pointer string to locate the chunk\n     * @returns The chunk data if found, undefined otherwise\n     */\n    get: (pointer: string) => {\n      return getValueByPath(assets, parseJsonPointer(pointer))\n    },\n    /**\n     * Adds a new document to the workspace asynchronously.\n     *\n     * This function:\n     * 1. Loads the document using the provided input\n     * 2. Checks if the document loaded successfully\n     * 3. If successful, adds the document to the workspace using addDocumentSync\n     *\n     * @param input - The document input containing the document source and metadata\n     */\n    addDocument,\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Applies a type transformation to a given type T based on the Transform parameter.
+ *
+ * This utility type supports common TypeScript transformations:
+ * - 'NonNullable': Removes null and undefined from the type
+ * - 'Partial': Makes all properties optional
+ * - 'Required': Makes all properties required
+ * - 'Readonly': Makes all properties readonly
+ *
+ * If no valid transformation is provided, returns the original type unchanged.
+ *
+ * @template T - The type to transform
+ * @template Transform - The transformation to apply ('NonNullable' | 'Partial' | 'Required' | 'Readonly')
+ */
+type ApplyTransform<T, Transform> = Transform extends 'NonNullable' ? NonNullable<T> : Transform extends 'Partial' ? Partial<T> : Transform extends 'Required' ? Required<T> : Transform extends 'Readonly' ? Readonly<T> : T;
+/**
+ * Recursively applies a type transformation to all levels of a nested type structure.
+ *
+ * This utility type traverses through complex nested types and applies the specified transformation
+ * at each level. It handles:
+ * - Functions: Returns the function type unchanged (no transformation applied)
+ * - Arrays: Recursively transforms each element in the array
+ * - Objects: Recursively transforms each property value in the object
+ * - Primitives: Applies the transformation directly using ApplyTransform
+ *
+ * The transformation is applied using the ApplyTransform utility, which supports:
+ * 'NonNullable', 'Partial', 'Required', and 'Readonly' transformations.
+ *
+ * @template T - The type to recursively transform
+ * @template Transform - The transformation to apply at each level
+ * @example
+ * // Make all properties in a nested object optional
+ * type OptionalNested = DeepTransform<{ a: { b: string } }, 'Partial'>
+ * // Result: { a?: { b?: string } }
+ */
+export type DeepTransform<T, Transform> = T extends (...args: any[]) => any ? T : T extends Array<infer U> ? Array<DeepTransform<U, Transform>> : T extends object ? {
+    [K in keyof T]-?: DeepTransform<ApplyTransform<NonNullable<T[K]>, Transform>, Transform>;
+} : ApplyTransform<NonNullable<T>, Transform>;
+/**
+ * Converts a readonly array type to a mutable array type.
+ *
+ * This utility type removes the readonly modifier from all elements in an array type,
+ * allowing the array to be modified. It's useful when you need to work with mutable
+ * versions of readonly arrays in TypeScript.
+ *
+ * @template T - The readonly array type to convert to mutable
+ * @example
+ * // Convert a readonly array to mutable
+ * type ReadonlyNumbers = readonly number[]
+ * type MutableNumbers = MutableArray<ReadonlyNumbers>
+ * // Result: number[]
+ */
+export type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,KAAK,cAAc,CAAC,CAAC,EAAE,SAAS,IAAI,SAAS,SAAS,aAAa,GAC/D,WAAW,CAAC,CAAC,CAAC,GACd,SAAS,SAAS,SAAS,GACzB,OAAO,CAAC,CAAC,CAAC,GACV,SAAS,SAAS,UAAU,GAC1B,QAAQ,CAAC,CAAC,CAAC,GACX,SAAS,SAAS,UAAU,GAC1B,QAAQ,CAAC,CAAC,CAAC,GAEX,CAAC,CAAA;AAEX;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,SAAS,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACvE,CAAC,GACD,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACtB,KAAK,CAAC,aAAa,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GAClC,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC;CAAE,GAC5F,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,IAAI;IACnD,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/package.json

@@ -16,7 +16,7 @@
     "openapi",
     "scalar"
   ],
-  "version": "0.5.2",
+  "version": "0.7.0",
   "engines": {
     "node": ">=18"
   },
@@ -32,6 +32,16 @@
       "types": "./dist/schemas.d.ts",
       "default": "./dist/schemas.js"
     },
+    "./schemas/v3.1/*": {
+      "import": "./dist/schemas/v3.1/*.js",
+      "types": "./dist/schemas/v3.1/*.d.ts",
+      "default": "./dist/schemas/v3.1/*.js"
+    },
+    "./schemas/v3.1/strict/*": {
+      "import": "./dist/schemas/v3.1/strict/*.js",
+      "types": "./dist/schemas/v3.1/strict/*.d.ts",
+      "default": "./dist/schemas/v3.1/strict/*.js"
+    },
     "./server": {
       "import": "./dist/server.js",
       "types": "./dist/server.d.ts",
@@ -43,16 +53,17 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@sinclair/typebox": "0.34.33",
+    "@sinclair/typebox": "0.34.37",
     "github-slugger": "^2.0.0",
     "vue": "^3.5.12",
-    "@scalar/helpers": "0.0.4",
-    "@scalar/openapi-parser": "0.18.0",
     "@scalar/code-highlight": "0.1.4",
-    "@scalar/openapi-types": "0.3.3"
+    "@scalar/helpers": "0.0.5",
+    "@scalar/openapi-types": "0.3.4",
+    "@scalar/openapi-parser": "0.18.0",
+    "@scalar/types": "0.2.5"
   },
   "devDependencies": {
-    "@google-cloud/storage": "7.13.0",
+    "@google-cloud/storage": "7.16.0",
     "fastify": "^5.3.3",
     "vite": "5.4.19",
     "vitest": "^1.6.0",
@@ -67,6 +78,7 @@
     "lint:fix": "eslint .  --fix",
     "test": "vitest",
     "types:build": "scalar-types-build",
-    "types:check": "scalar-types-check"
+    "types:check": "scalar-types-check",
+    "generate-json-schemas": "vite-node ./scripts/generate-json-schemas.ts"
   }
 }