@scalar/oas-utils 0.10.8 → 0.10.9

package/dist/helpers/parse.js

@@ -1,83 +1,83 @@
-import { parse, stringify } from "yaml";
-const yaml = {
-  /** Parse and throw if the return value is not an object */
-  parse: (val) => {
-    const yamlObject = parse(val, { merge: true, maxAliasCount: 1e4 });
-    if (typeof yamlObject !== "object") {
-      throw Error("Invalid YAML object");
-    }
-    return yamlObject;
-  },
-  /** Parse and return a fallback on failure */
-  parseSafe(val, fallback) {
-    try {
-      return yaml.parse(val);
-    } catch (err) {
-      return typeof fallback === "function" ? fallback(err) : fallback;
-    }
-  },
-  stringify
+import { parse, stringify } from 'yaml';
+/** Yaml handling with optional safeparse */
+export const yaml = {
+    /** Parse and throw if the return value is not an object */
+    parse: (val) => {
+        const yamlObject = parse(val, { merge: true, maxAliasCount: 10000 });
+        if (typeof yamlObject !== 'object') {
+            throw Error('Invalid YAML object');
+        }
+        return yamlObject;
+    },
+    /** Parse and return a fallback on failure */
+    parseSafe(val, fallback) {
+        try {
+            return yaml.parse(val);
+        }
+        catch (err) {
+            return typeof fallback === 'function' ? fallback(err) : fallback;
+        }
+    },
+    stringify,
+};
+/** JSON handling with optional safeparse */
+export const json = {
+    /** Parse and throw if the return value is not an object */
+    parse: (val) => {
+        const jsonObject = JSON.parse(val);
+        if (typeof jsonObject !== 'object') {
+            throw Error('Invalid JSON object');
+        }
+        return jsonObject;
+    },
+    /** Parse and return a fallback on failure */
+    parseSafe(val, fallback) {
+        try {
+            return json.parse(val);
+        }
+        catch (err) {
+            return typeof fallback === 'function' ? fallback(err) : fallback;
+        }
+    },
+    stringify: (val) => JSON.stringify(val),
 };
-const json = {
-  /** Parse and throw if the return value is not an object */
-  parse: (val) => {
-    const jsonObject = JSON.parse(val);
-    if (typeof jsonObject !== "object") {
-      throw Error("Invalid JSON object");
+/**
+ * This helper is used to transform the content of the swagger file to JSON, even it was YAML.
+ */
+export const transformToJson = (value) => {
+    // Try json, then fallback to yaml, then fallback to string
+    return JSON.stringify(json.parseSafe(value, yaml.parseSafe(value, value)));
+};
+/** Validates a JSON string if provided. Otherwise returns the raw YAML */
+export function formatJsonOrYamlString(value) {
+    // If we don't start with a bracket assume yaml
+    const trimmed = value.trim();
+    if (trimmed[0] !== '{' && trimmed[0] !== '[') {
+        return value;
     }
-    return jsonObject;
-  },
-  /** Parse and return a fallback on failure */
-  parseSafe(val, fallback) {
     try {
-      return json.parse(val);
-    } catch (err) {
-      return typeof fallback === "function" ? fallback(err) : fallback;
+        // JSON
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        // YAML
+        return value;
     }
-  },
-  stringify: (val) => JSON.stringify(val)
-};
-const isJsonString = (value) => {
-  if (typeof value !== "string") {
-    return false;
-  }
-  return !!json.parseSafe(value, false);
-};
-const transformToJson = (value) => {
-  return JSON.stringify(json.parseSafe(value, yaml.parseSafe(value, value)));
-};
-function formatJsonOrYamlString(value) {
-  const trimmed = value.trim();
-  if (trimmed[0] !== "{" && trimmed[0] !== "[") {
-    return value;
-  }
-  try {
-    return JSON.stringify(JSON.parse(value), null, 2);
-  } catch {
-    return value;
-  }
 }
-const parseJsonOrYaml = (value) => {
-  if (typeof value !== "string") {
-    return value;
-  }
-  const jsonObject = json.parseSafe(value, null);
-  if (jsonObject) {
-    return jsonObject;
-  }
-  if (value.length > 0 && ["{", "["].includes(value[0] ?? "")) {
-    throw Error("Invalid JSON or YAML");
-  }
-  return yaml.parseSafe(value, (err) => {
-    throw Error(err);
-  });
-};
-export {
-  formatJsonOrYamlString,
-  isJsonString,
-  json,
-  parseJsonOrYaml,
-  transformToJson,
-  yaml
+/** Parse JSON or YAML into an object */
+export const parseJsonOrYaml = (value) => {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const jsonObject = json.parseSafe(value, null);
+    if (jsonObject) {
+        return jsonObject;
+    }
+    // Value is probably supposed to be JSON. Throw
+    if (value.length > 0 && ['{', '['].includes(value[0] ?? '')) {
+        throw Error('Invalid JSON or YAML');
+    }
+    return yaml.parseSafe(value, (err) => {
+        throw Error(err);
+    });
 };
-//# sourceMappingURL=parse.js.map

package/dist/helpers/schema-model.js

@@ -1,17 +1,14 @@
-function schemaModel(data, schema, throwError = true, errorLocation) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    console.group("Schema Error" + (errorLocation ? ` - ${errorLocation}` : ""));
-    console.warn(JSON.stringify(result.error.format(), null, 2));
-    console.log("Received: ", data);
-    console.groupEnd();
-  }
-  if (throwError && !result.success) {
-    throw new Error("Zod validation failure");
-  }
-  return result.data;
+/** Parse a Zod */
+export function schemaModel(data, schema, throwError = true, errorLocation) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        console.group('Schema Error' + (errorLocation ? ` - ${errorLocation}` : ''));
+        console.warn(JSON.stringify(result.error.format(), null, 2));
+        console.log('Received: ', data);
+        console.groupEnd();
+    }
+    if (throwError && !result.success) {
+        throw new Error('Zod validation failure');
+    }
+    return result.data;
 }
-export {
-  schemaModel
-};
-//# sourceMappingURL=schema-model.js.map

package/dist/helpers/security/get-schemes.js

@@ -1,9 +1,8 @@
-import { isDefined } from "@scalar/helpers/array/is-defined";
-const getSchemes = (selectedSecuritySchemes, securitySchemes) => {
-  const uids = new Set(selectedSecuritySchemes.flat());
-  return Array.from(uids).map((uid) => securitySchemes[uid]).filter(isDefined);
+import { isDefined } from '@scalar/helpers/array/is-defined';
+/** Parses a list of selected security scheme uids which may be an array or single uid and returns a flattened array of security schemes */
+export const getSchemes = (selectedSecuritySchemes, securitySchemes) => {
+    const uids = new Set(selectedSecuritySchemes.flat());
+    return Array.from(uids)
+        .map((uid) => securitySchemes[uid])
+        .filter(isDefined);
 };
-export {
-  getSchemes
-};
-//# sourceMappingURL=get-schemes.js.map

package/dist/helpers/security/has-token.js

@@ -1,20 +1,19 @@
-const hasToken = (scheme) => {
-  if (scheme.type === "apiKey") {
-    return Boolean(scheme.value);
-  }
-  if (scheme.type === "http") {
-    return Boolean(
-      scheme.scheme === "bearer" && scheme.token || scheme.scheme === "basic" && scheme.username && scheme.password
-    );
-  }
-  if (scheme.type === "oauth2") {
-    return Boolean(
-      scheme.flows.authorizationCode?.token || scheme.flows.clientCredentials?.token || scheme.flows.password?.token || scheme.flows.implicit?.token
-    );
-  }
-  return false;
+/** Pass in a security scheme and it will return true if it has a token or value depending on the scheme type */
+export const hasToken = (scheme) => {
+    // ApiKey
+    if (scheme.type === 'apiKey') {
+        return Boolean(scheme.value);
+    }
+    // Http
+    if (scheme.type === 'http') {
+        return Boolean((scheme.scheme === 'bearer' && scheme.token) || (scheme.scheme === 'basic' && scheme.username && scheme.password));
+    }
+    // OAuth2 just check for A token
+    if (scheme.type === 'oauth2') {
+        return Boolean(scheme.flows.authorizationCode?.token ||
+            scheme.flows.clientCredentials?.token ||
+            scheme.flows.password?.token ||
+            scheme.flows.implicit?.token);
+    }
+    return false;
 };
-export {
-  hasToken
-};
-//# sourceMappingURL=has-token.js.map

package/dist/helpers/security/index.js

@@ -1,7 +1,2 @@
-import { getSchemes } from "./get-schemes.js";
-import { hasToken } from "./has-token.js";
-export {
-  getSchemes,
-  hasToken
-};
-//# sourceMappingURL=index.js.map
+export { getSchemes } from './get-schemes.js';
+export { hasToken } from './has-token.js';

package/dist/helpers/servers.js

@@ -1,97 +1,146 @@
-import { isDefined } from "@scalar/helpers/array/is-defined";
-import { combineUrlAndPath } from "@scalar/helpers/url/merge-urls";
-import { serverSchema } from "../entities/spec/server.js";
-function getServersFromDocument(servers, options = {}) {
-  if (!servers?.length) {
-    const fallbackServer = createFallbackServer(options);
-    return fallbackServer ? [fallbackServer] : [];
-  }
-  if (!Array.isArray(servers)) {
-    return [];
-  }
-  const validServers = servers.map((server) => processServerObject(server, options)).filter(isDefined);
-  if (validServers.length === 0) {
-    const fallbackServer = createFallbackServer(options);
-    return fallbackServer ? [fallbackServer] : [];
-  }
-  return validServers;
+import { isDefined } from '@scalar/helpers/array/is-defined';
+import { combineUrlAndPath } from '@scalar/helpers/url/merge-urls';
+import { serverSchema } from '../entities/spec/server.js';
+/**
+ * Retrieves and processes servers from an OpenAPI document.
+ *
+ * This function handles several scenarios:
+ * 1. No servers provided - creates a default server from document URL or fallback
+ * 2. Invalid server configurations - filters them out with warnings
+ * 3. Relative URLs - resolves them to absolute URLs using available base URLs
+ *
+ * @param servers - Array of OpenAPI server objects from the document
+ * @param options - Configuration options for server processing
+ * @returns Array of validated Server entities
+ */
+export function getServersFromDocument(servers, options = {}) {
+    // Handle case where no servers are provided
+    if (!servers?.length) {
+        const fallbackServer = createFallbackServer(options);
+        return fallbackServer ? [fallbackServer] : [];
+    }
+    // Handle invalid server array
+    if (!Array.isArray(servers)) {
+        return [];
+    }
+    // Process each server and filter out invalid ones
+    const validServers = servers.map((server) => processServerObject(server, options)).filter(isDefined);
+    // If all servers were invalid, provide a fallback
+    if (validServers.length === 0) {
+        const fallbackServer = createFallbackServer(options);
+        return fallbackServer ? [fallbackServer] : [];
+    }
+    return validServers;
 }
+/**
+ * Extracts the base URL (protocol + hostname) from a document URL.
+ * Returns undefined if the URL is invalid.
+ */
 function extractBaseUrlFromDocumentUrl(documentUrl) {
-  try {
-    const url = new URL(documentUrl);
-    const port = url.port ? `:${url.port}` : "";
-    return `${url.protocol}//${url.hostname}${port}`;
-  } catch {
-    return void 0;
-  }
+    try {
+        const url = new URL(documentUrl);
+        const port = url.port ? `:${url.port}` : '';
+        return `${url.protocol}//${url.hostname}${port}`;
+    }
+    catch {
+        return undefined;
+    }
 }
+/**
+ * Gets the fallback URL from window.location.origin if available.
+ */
 function getFallbackUrl() {
-  if (typeof window === "undefined" || typeof window?.location?.origin !== "string") {
-    return void 0;
-  }
-  return window.location.origin;
+    if (typeof window === 'undefined' || typeof window?.location?.origin !== 'string') {
+        return undefined;
+    }
+    return window.location.origin;
 }
+/**
+ * Creates a server object from a URL string, with error handling.
+ */
 function createServerFromUrl(url, context) {
-  try {
-    return serverSchema.parse({ url });
-  } catch {
-    console.warn(`Failed to create server from ${context}:`, url);
-    return void 0;
-  }
+    try {
+        return serverSchema.parse({ url });
+    }
+    catch {
+        console.warn(`Failed to create server from ${context}:`, url);
+        return undefined;
+    }
 }
+/**
+ * Creates a default server using the document URL as the base.
+ */
 function createDefaultServerFromDocumentUrl(documentUrl) {
-  const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
-  if (!baseUrl) {
-    return void 0;
-  }
-  return createServerFromUrl(baseUrl, "document URL");
+    const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
+    if (!baseUrl) {
+        return undefined;
+    }
+    return createServerFromUrl(baseUrl, 'document URL');
 }
+/**
+ * Creates a default server using the fallback URL (window.location.origin).
+ */
 function createDefaultServerFromFallback() {
-  const fallbackUrl = getFallbackUrl();
-  if (!fallbackUrl) {
-    return void 0;
-  }
-  return createServerFromUrl(fallbackUrl, "fallback URL");
+    const fallbackUrl = getFallbackUrl();
+    if (!fallbackUrl) {
+        return undefined;
+    }
+    return createServerFromUrl(fallbackUrl, 'fallback URL');
 }
+/**
+ * Resolves a relative server URL to an absolute URL using available base URLs.
+ * Uses a priority system: baseServerURL > documentUrl > fallbackUrl.
+ */
 function resolveRelativeServerUrl(serverUrl, options) {
-  const { baseServerURL, documentUrl } = options;
-  if (baseServerURL) {
-    return combineUrlAndPath(baseServerURL, serverUrl);
-  }
-  if (documentUrl) {
-    const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
-    if (baseUrl) {
-      return combineUrlAndPath(baseUrl, serverUrl);
-    }
-  }
-  const fallbackUrl = getFallbackUrl();
-  if (fallbackUrl) {
-    return combineUrlAndPath(fallbackUrl, serverUrl);
-  }
-  return serverUrl;
+    const { baseServerURL, documentUrl } = options;
+    // Priority 1: Use provided base server URL
+    if (baseServerURL) {
+        return combineUrlAndPath(baseServerURL, serverUrl);
+    }
+    // Priority 2: Extract base URL from document URL
+    if (documentUrl) {
+        const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
+        if (baseUrl) {
+            return combineUrlAndPath(baseUrl, serverUrl);
+        }
+    }
+    // Priority 3: Use fallback URL (window.location.origin)
+    const fallbackUrl = getFallbackUrl();
+    if (fallbackUrl) {
+        return combineUrlAndPath(fallbackUrl, serverUrl);
+    }
+    // If no base URL is available, return the original URL
+    return serverUrl;
 }
+/**
+ * Processes a single server object, handling validation and URL resolution.
+ */
 function processServerObject(server, options) {
-  try {
-    const parsedServer = serverSchema.parse(server);
-    if (parsedServer.url?.startsWith("/")) {
-      parsedServer.url = resolveRelativeServerUrl(parsedServer.url, options);
-    }
-    return parsedServer;
-  } catch (error) {
-    console.warn("Invalid server configuration:", server, "Error:", error);
-    return void 0;
-  }
+    try {
+        const parsedServer = serverSchema.parse(server);
+        // Resolve relative URLs to absolute URLs
+        if (parsedServer.url?.startsWith('/')) {
+            parsedServer.url = resolveRelativeServerUrl(parsedServer.url, options);
+        }
+        return parsedServer;
+    }
+    catch (error) {
+        console.warn('Invalid server configuration:', server, 'Error:', error);
+        return undefined;
+    }
 }
+/**
+ * Creates a fallback server when no valid servers are available.
+ * Uses document URL first, then fallback URL.
+ */
 function createFallbackServer(options) {
-  if (options.documentUrl) {
-    const defaultServer = createDefaultServerFromDocumentUrl(options.documentUrl);
-    if (defaultServer) {
-      return defaultServer;
+    // Priority 1: Try to create default server from document URL
+    if (options.documentUrl) {
+        const defaultServer = createDefaultServerFromDocumentUrl(options.documentUrl);
+        if (defaultServer) {
+            return defaultServer;
+        }
     }
-  }
-  return createDefaultServerFromFallback();
+    // Priority 2: Try to create default server from fallback URL
+    return createDefaultServerFromFallback();
 }
-export {
-  getServersFromDocument
-};
-//# sourceMappingURL=servers.js.map

package/dist/helpers/should-ignore-entity.js

@@ -1,5 +1,4 @@
-const shouldIgnoreEntity = (data) => data?.["x-internal"] === true || data?.["x-scalar-ignore"] === true;
-export {
-  shouldIgnoreEntity
-};
-//# sourceMappingURL=should-ignore-entity.js.map
+/**
+ * Check if an entity should be ignored
+ */
+export const shouldIgnoreEntity = (data) => data?.['x-internal'] === true || data?.['x-scalar-ignore'] === true;

package/dist/migrations/data-version.js

@@ -1,7 +1,15 @@
-const DATA_VERSION = "2.5.0";
-const DATA_VERSION_LS_LEY = "scalar_api_client_data_version";
-export {
-  DATA_VERSION,
-  DATA_VERSION_LS_LEY
-};
-//# sourceMappingURL=data-version.js.map
+/**
+ * Ensure we update this every migration
+ *
+ * previous data versions:
+ * - undefined
+ * - 0.0.0
+ * - 2.1.0 - refactor
+ * - 2.2.0 - auth compliancy
+ * - 2.3.0 - environments
+ * - 2.4.0 - draft collection servers
+ * - 2.5.0 - accept header
+ */
+export const DATA_VERSION = '2.5.0';
+/** The localStorage key under which the data version is stored */
+export const DATA_VERSION_LS_LEY = 'scalar_api_client_data_version';

package/dist/migrations/generate-types.js

@@ -1,38 +1,40 @@
-import { writeFile } from "node:fs";
-import { cookieSchema } from "../entities/cookie/cookie.js";
-import { environmentSchema } from "../entities/environment/environment.js";
-import { collectionSchema } from "../entities/spec/collection.js";
-import { requestExampleSchema } from "../entities/spec/request-examples.js";
-import { requestSchema } from "../entities/spec/requests.js";
-import { serverSchema } from "../entities/spec/server.js";
-import { tagSchema } from "../entities/spec/spec-objects.js";
-import { workspaceSchema } from "../entities/workspace/workspace.js";
-import { DATA_VERSION } from "../migrations/data-version.js";
-import { securitySchemeSchema } from "@scalar/types/entities";
-import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
-console.warn("Make sure the generate types file is updated for the current version");
-console.info("Generating...");
+import { writeFile } from 'node:fs';
+import { securitySchemeSchema } from '@scalar/types/entities';
+import { createTypeAlias, printNode, zodToTs } from 'zod-to-ts';
+import { cookieSchema } from '../entities/cookie/cookie.js';
+import { environmentSchema } from '../entities/environment/environment.js';
+import { collectionSchema } from '../entities/spec/collection.js';
+import { requestExampleSchema } from '../entities/spec/request-examples.js';
+import { requestSchema } from '../entities/spec/requests.js';
+import { serverSchema } from '../entities/spec/server.js';
+import { tagSchema } from '../entities/spec/spec-objects.js';
+import { workspaceSchema } from '../entities/workspace/workspace.js';
+import { DATA_VERSION } from '../migrations/data-version.js';
+console.warn('Make sure the generate types file is updated for the current version');
+console.info('Generating...');
 const entities = [
-  { identifier: "Collection", schema: collectionSchema },
-  { identifier: "Cookie", schema: cookieSchema },
-  { identifier: "Environment", schema: environmentSchema },
-  { identifier: "Tag", schema: tagSchema },
-  { identifier: "RequestExample", schema: requestExampleSchema },
-  { identifier: "Request", schema: requestSchema },
-  { identifier: "SecurityScheme", schema: securitySchemeSchema },
-  { identifier: "Server", schema: serverSchema },
-  { identifier: "Workspace", schema: workspaceSchema }
+    { identifier: 'Collection', schema: collectionSchema },
+    { identifier: 'Cookie', schema: cookieSchema },
+    { identifier: 'Environment', schema: environmentSchema },
+    { identifier: 'Tag', schema: tagSchema },
+    { identifier: 'RequestExample', schema: requestExampleSchema },
+    { identifier: 'Request', schema: requestSchema },
+    { identifier: 'SecurityScheme', schema: securitySchemeSchema },
+    { identifier: 'Server', schema: serverSchema },
+    { identifier: 'Workspace', schema: workspaceSchema },
 ];
-let typeString = entities.reduce(
-  (prev, { identifier, schema }) => {
+/**
+ * Export the types in a namespace
+ * TODO:
+ * - go back to typescript compiler api and print pretty types as these ones are optional
+ */
+let typeString = entities.reduce((prev, { identifier, schema }) => {
     const { node } = zodToTs(schema, identifier);
     const typeAlias = createTypeAlias(node, identifier);
-    const nodeString = "  export " + printNode(typeAlias) + "\n\n";
+    const nodeString = '  export ' + printNode(typeAlias) + '\n\n';
     return prev + nodeString;
-  },
-  `export namespace v_${DATA_VERSION.replace(/\./g, "_")} {
-`
-);
+}, `export namespace v_${DATA_VERSION.replace(/\./g, '_')} {\n`);
+// Add all types data object
 typeString += `
   export type DataRecord = { 
     collections: Record<string, Collection>
@@ -47,10 +49,5 @@ typeString += `
   }
 }
 `;
-writeFile(
-  __dirname + `/v-${DATA_VERSION}/types.generated.ts`,
-  typeString,
-  { flag: "w" },
-  (err) => err ? console.error(err) : console.log("Generation complete!")
-);
-//# sourceMappingURL=generate-types.js.map
+// Write to file
+writeFile(import.meta.dirname + `/v-${DATA_VERSION}/types.generated.ts`, typeString, { flag: 'w' }, (err) => err ? console.error(err) : console.log('Generation complete!'));

package/dist/migrations/index.js

@@ -1,18 +1,4 @@
-import { DATA_VERSION, DATA_VERSION_LS_LEY } from "./data-version.js";
-import {
-  migrateLocalStorageToIndexDb,
-  shouldMigrateToIndexDb,
-  transformLegacyDataToWorkspace
-} from "./migrate-to-indexdb.js";
-import { migrator } from "./migrator.js";
-import { semverLessThan } from "./semver.js";
-export {
-  DATA_VERSION,
-  DATA_VERSION_LS_LEY,
-  migrateLocalStorageToIndexDb,
-  migrator,
-  semverLessThan,
-  shouldMigrateToIndexDb,
-  transformLegacyDataToWorkspace
-};
-//# sourceMappingURL=index.js.map
+export { DATA_VERSION, DATA_VERSION_LS_LEY } from './data-version.js';
+export { migrateLocalStorageToIndexDb, shouldMigrateToIndexDb, transformLegacyDataToWorkspace, } from './migrate-to-indexdb.js';
+export { migrator } from './migrator.js';
+export { semverLessThan } from './semver.js';