@scalar/openapi-parser 0.25.4 → 0.25.5

package/dist/utils/load/load.js

@@ -1,98 +1,122 @@
-import { ERRORS } from "../../configuration/index.js";
-import { getEntrypoint } from "../../utils/get-entrypoint.js";
-import { getListOfReferences } from "../../utils/get-list-of-references.js";
-import { makeFilesystem } from "../../utils/make-filesystem.js";
-import { normalize } from "../../utils/normalize.js";
-async function load(value, options) {
-  const errors = [];
-  if (options?.filesystem?.find((entry) => entry.filename === value)) {
-    return {
-      specification: getEntrypoint(options.filesystem)?.specification,
-      filesystem: options.filesystem,
-      errors
-    };
-  }
-  const plugin = options?.plugins?.find((thisPlugin) => thisPlugin.check(value));
-  let content;
-  if (plugin) {
-    try {
-      content = normalize(await plugin.get(value));
-    } catch (_error) {
-      if (options?.throwOnError) {
-        throw new Error(ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace("%s", value));
-      }
-      errors.push({
-        code: "EXTERNAL_REFERENCE_NOT_FOUND",
-        message: ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace("%s", value)
-      });
-      return {
-        specification: null,
-        filesystem: [],
-        errors
-      };
+import { ERRORS } from '../../configuration/index.js';
+import { getEntrypoint } from '../../utils/get-entrypoint.js';
+import { getListOfReferences } from '../../utils/get-list-of-references.js';
+import { makeFilesystem } from '../../utils/make-filesystem.js';
+import { normalize } from '../../utils/normalize.js';
+/**
+ * @deprecated This function is deprecated and will be removed in a future version.
+ * Please use the new bundler utility instead:
+ * ```ts
+ * import { bundle } from "@scalar/json-magic/bundle"
+ * ```
+ *
+ * Loads an OpenAPI document, including any external references.
+ *
+ * This function handles loading content from various sources, normalizes the content,
+ * and recursively loads any external references found within the definition.
+ *
+ * It builds a filesystem representation of all loaded content and collects any errors
+ * encountered during the process.
+ */
+export async function load(value, options) {
+    const errors = [];
+    // Don't load a reference twice, check the filesystem before fetching something
+    if (options?.filesystem?.find((entry) => entry.filename === value)) {
+        return {
+            specification: getEntrypoint(options.filesystem)?.specification,
+            filesystem: options.filesystem,
+            errors,
+        };
     }
-  } else {
-    content = normalize(value);
-  }
-  if (content === void 0) {
-    if (options?.throwOnError) {
-      throw new Error("No content to load");
+    // Check whether the value is an URL or file path
+    const plugin = options?.plugins?.find((thisPlugin) => thisPlugin.check(value));
+    let content;
+    if (plugin) {
+        try {
+            content = normalize(await plugin.get(value));
+        }
+        catch (_error) {
+            if (options?.throwOnError) {
+                throw new Error(ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace('%s', value));
+            }
+            errors.push({
+                code: 'EXTERNAL_REFERENCE_NOT_FOUND',
+                message: ERRORS.EXTERNAL_REFERENCE_NOT_FOUND.replace('%s', value),
+            });
+            return {
+                specification: null,
+                filesystem: [],
+                errors,
+            };
+        }
     }
-    errors.push({
-      code: "NO_CONTENT",
-      message: ERRORS.NO_CONTENT
-    });
-    return {
-      specification: null,
-      filesystem: [],
-      errors
-    };
-  }
-  let filesystem = makeFilesystem(content, {
-    filename: options?.filename ?? null
-  });
-  const newEntry = options?.filename ? filesystem.find((entry) => entry.filename === options?.filename) : getEntrypoint(filesystem);
-  const listOfReferences = newEntry.references ?? getListOfReferences(content);
-  if (listOfReferences.length === 0) {
-    return {
-      specification: getEntrypoint(filesystem)?.specification,
-      filesystem,
-      errors
-    };
-  }
-  for (const reference of listOfReferences) {
-    const otherPlugin = options?.plugins?.find((thisPlugin) => thisPlugin.check(reference));
-    if (!otherPlugin) {
-      continue;
+    else {
+        content = normalize(value);
     }
-    const target = otherPlugin.check(reference) && otherPlugin.resolvePath ? otherPlugin.resolvePath(value, reference) : reference;
-    if (filesystem.find((entry) => entry.filename === reference)) {
-      continue;
+    // No content
+    if (content === undefined) {
+        if (options?.throwOnError) {
+            throw new Error('No content to load');
+        }
+        errors.push({
+            code: 'NO_CONTENT',
+            message: ERRORS.NO_CONTENT,
+        });
+        return {
+            specification: null,
+            filesystem: [],
+            errors,
+        };
     }
-    const { filesystem: referencedFiles, errors: newErrors } = await load(target, {
-      ...options,
-      // Make the filename the exact same value as the $ref
-      // TODO: This leads to problems, if there are multiple references with the same file name but in different folders
-      filename: reference
+    let filesystem = makeFilesystem(content, {
+        filename: options?.filename ?? null,
     });
-    errors.push(...newErrors);
-    filesystem = [
-      ...filesystem,
-      ...referencedFiles.map((file) => {
+    // Get references from file system entry, or from the content
+    const newEntry = options?.filename
+        ? filesystem.find((entry) => entry.filename === options?.filename)
+        : getEntrypoint(filesystem);
+    const listOfReferences = newEntry.references ?? getListOfReferences(content);
+    // No other references
+    if (listOfReferences.length === 0) {
         return {
-          ...file,
-          isEntrypoint: false
+            specification: getEntrypoint(filesystem)?.specification,
+            filesystem,
+            errors,
         };
-      })
-    ];
-  }
-  return {
-    specification: getEntrypoint(filesystem)?.specification,
-    filesystem,
-    errors
-  };
+    }
+    // Load other external references
+    for (const reference of listOfReferences) {
+        // Find a matching plugin
+        const otherPlugin = options?.plugins?.find((thisPlugin) => thisPlugin.check(reference));
+        // Skip if no plugin is found (internal references don't need a plugin for example)
+        if (!otherPlugin) {
+            continue;
+        }
+        const target = otherPlugin.check(reference) && otherPlugin.resolvePath ? otherPlugin.resolvePath(value, reference) : reference;
+        // Don't load a reference twice, check the filesystem before fetching something
+        if (filesystem.find((entry) => entry.filename === reference)) {
+            continue;
+        }
+        const { filesystem: referencedFiles, errors: newErrors } = await load(target, {
+            ...options,
+            // Make the filename the exact same value as the $ref
+            // TODO: This leads to problems, if there are multiple references with the same file name but in different folders
+            filename: reference,
+        });
+        errors.push(...newErrors);
+        filesystem = [
+            ...filesystem,
+            ...referencedFiles.map((file) => {
+                return {
+                    ...file,
+                    isEntrypoint: false,
+                };
+            }),
+        ];
+    }
+    return {
+        specification: getEntrypoint(filesystem)?.specification,
+        filesystem,
+        errors,
+    };
 }
-export {
-  load
-};
-//# sourceMappingURL=load.js.map

package/dist/utils/make-filesystem.js

@@ -1,23 +1,22 @@
-import { getListOfReferences } from "./get-list-of-references.js";
-import { isFilesystem } from "./is-filesystem.js";
-import { normalize } from "./normalize.js";
-function makeFilesystem(value, overwrites = {}) {
-  if (isFilesystem(value)) {
-    return value;
-  }
-  const specification = normalize(value);
-  return [
-    {
-      isEntrypoint: true,
-      specification,
-      filename: null,
-      dir: "./",
-      references: getListOfReferences(specification),
-      ...overwrites
+import { getListOfReferences } from './get-list-of-references.js';
+import { isFilesystem } from './is-filesystem.js';
+import { normalize } from './normalize.js';
+export function makeFilesystem(value, overwrites = {}) {
+    // Keep as is
+    if (isFilesystem(value)) {
+        return value;
     }
-  ];
+    // Make an object
+    const specification = normalize(value);
+    // Create fake filesystem
+    return [
+        {
+            isEntrypoint: true,
+            specification,
+            filename: null,
+            dir: './',
+            references: getListOfReferences(specification),
+            ...overwrites,
+        },
+    ];
 }
-export {
-  makeFilesystem
-};
-//# sourceMappingURL=make-filesystem.js.map

package/dist/utils/normalize.js

@@ -1,33 +1,36 @@
-import { parse } from "yaml";
-import { isFilesystem } from "./is-filesystem.js";
-function normalize(content) {
-  if (content === null) {
-    return void 0;
-  }
-  if (typeof content === "string") {
-    if (content.trim() === "") {
-      return void 0;
+import { parse } from 'yaml';
+import { isFilesystem } from './is-filesystem.js';
+/**
+ * Normalize the OpenAPI document (YAML, JSON, object) to a JavaScript object.
+ *
+ * Doesn't modify the object if it's a `Filesystem` (multiple files) already.
+ */
+export function normalize(content) {
+    if (content === null) {
+        return undefined;
     }
-    try {
-      return JSON.parse(content);
-    } catch {
-      const hasColon = /^[^:]+:/.test(content);
-      const isJson = content.slice(0, 50).trimStart().startsWith("{");
-      if (!hasColon || isJson) {
-        return void 0;
-      }
-      return parse(content, {
-        maxAliasCount: 1e4,
-        merge: true
-      });
+    if (typeof content === 'string') {
+        if (content.trim() === '') {
+            return undefined;
+        }
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            // Does it look like YAML?
+            const hasColon = /^[^:]+:/.test(content);
+            const isJson = content.slice(0, 50).trimStart().startsWith('{');
+            if (!hasColon || isJson) {
+                return undefined;
+            }
+            return parse(content, {
+                maxAliasCount: 10000,
+                merge: true,
+            });
+        }
+    }
+    if (isFilesystem(content)) {
+        return content;
     }
-  }
-  if (isFilesystem(content)) {
     return content;
-  }
-  return content;
 }
-export {
-  normalize
-};
-//# sourceMappingURL=normalize.js.map

package/dist/utils/openapi/actions/details.js

@@ -1,11 +1,10 @@
-import { getEntrypoint } from "../../../utils/get-entrypoint.js";
-import { details as detailsUtility } from "../../../utils/details.js";
-import { workThroughQueue } from "../utils/workThroughQueue.js";
-async function details(queue) {
-  const { filesystem } = await workThroughQueue(queue);
-  return detailsUtility(getEntrypoint(filesystem).specification);
+import { getEntrypoint } from '../../../utils/get-entrypoint.js';
+import { details as detailsUtility } from '../../../utils/details.js';
+import { workThroughQueue } from '../utils/workThroughQueue.js';
+/**
+ * Run the chained tasks and return just some basic information about the OpenAPI document
+ */
+export async function details(queue) {
+    const { filesystem } = await workThroughQueue(queue);
+    return detailsUtility(getEntrypoint(filesystem).specification);
 }
-export {
-  details
-};
-//# sourceMappingURL=details.js.map

package/dist/utils/openapi/actions/files.js

@@ -1,9 +1,8 @@
-import { workThroughQueue } from "../utils/workThroughQueue.js";
-async function files(queue) {
-  const { filesystem } = await workThroughQueue(queue);
-  return filesystem;
+import { workThroughQueue } from '../utils/workThroughQueue.js';
+/**
+ * Run the chained tasks and return just the filesystem
+ */
+export async function files(queue) {
+    const { filesystem } = await workThroughQueue(queue);
+    return filesystem;
 }
-export {
-  files
-};
-//# sourceMappingURL=files.js.map

package/dist/utils/openapi/actions/get.js

@@ -1,11 +1,10 @@
-import { workThroughQueue } from "../utils/workThroughQueue.js";
-async function get(queue) {
-  return {
-    filesystem: [],
-    ...await workThroughQueue(queue)
-  };
+import { workThroughQueue } from '../utils/workThroughQueue.js';
+/**
+ * Run the chained tasks and return the results
+ */
+export async function get(queue) {
+    return {
+        filesystem: [],
+        ...(await workThroughQueue(queue)),
+    };
 }
-export {
-  get
-};
-//# sourceMappingURL=get.js.map

package/dist/utils/openapi/actions/toJson.js

@@ -1,11 +1,10 @@
-import { getEntrypoint } from "../../../utils/get-entrypoint.js";
-import { toJson as toJsonUtility } from "../../../utils/to-json.js";
-import { workThroughQueue } from "../utils/workThroughQueue.js";
-async function toJson(queue) {
-  const { filesystem } = await workThroughQueue(queue);
-  return toJsonUtility(getEntrypoint(filesystem).specification);
+import { getEntrypoint } from '../../../utils/get-entrypoint.js';
+import { toJson as toJsonUtility } from '../../../utils/to-json.js';
+import { workThroughQueue } from '../utils/workThroughQueue.js';
+/**
+ * Run the chained tasks and return the results
+ */
+export async function toJson(queue) {
+    const { filesystem } = await workThroughQueue(queue);
+    return toJsonUtility(getEntrypoint(filesystem).specification);
 }
-export {
-  toJson
-};
-//# sourceMappingURL=toJson.js.map

package/dist/utils/openapi/actions/toYaml.js

@@ -1,11 +1,10 @@
-import { getEntrypoint } from "../../../utils/get-entrypoint.js";
-import { toYaml as toYamlUtility } from "../../../utils/to-yaml.js";
-import { workThroughQueue } from "../utils/workThroughQueue.js";
-async function toYaml(queue) {
-  const { filesystem } = await workThroughQueue(queue);
-  return toYamlUtility(getEntrypoint(filesystem).specification);
+import { getEntrypoint } from '../../../utils/get-entrypoint.js';
+import { toYaml as toYamlUtility } from '../../../utils/to-yaml.js';
+import { workThroughQueue } from '../utils/workThroughQueue.js';
+/**
+ * Run the chained tasks and return the results
+ */
+export async function toYaml(queue) {
+    const { filesystem } = await workThroughQueue(queue);
+    return toYamlUtility(getEntrypoint(filesystem).specification);
 }
-export {
-  toYaml
-};
-//# sourceMappingURL=toYaml.js.map

package/dist/utils/openapi/commands/dereferenceCommand.js

@@ -1,27 +1,26 @@
-import { details } from "../actions/details.js";
-import { files } from "../actions/files.js";
-import { get } from "../actions/get.js";
-import { toJson } from "../actions/toJson.js";
-import { toYaml } from "../actions/toYaml.js";
-import { queueTask } from "../utils/queueTask.js";
-function dereferenceCommand(previousQueue, options) {
-  const task = {
-    name: "dereference",
-    options: {
-      throwOnError: previousQueue.options?.throwOnError,
-      ...options ?? {}
-    }
-  };
-  const queue = queueTask(previousQueue, task);
-  return {
-    details: () => details(queue),
-    files: () => files(queue),
-    get: () => get(queue),
-    toJson: () => toJson(queue),
-    toYaml: () => toYaml(queue)
-  };
+import { details } from '../actions/details.js';
+import { files } from '../actions/files.js';
+import { get } from '../actions/get.js';
+import { toJson } from '../actions/toJson.js';
+import { toYaml } from '../actions/toYaml.js';
+import { queueTask } from '../utils/queueTask.js';
+/**
+ * Dereference the given OpenAPI document
+ */
+export function dereferenceCommand(previousQueue, options) {
+    const task = {
+        name: 'dereference',
+        options: {
+            throwOnError: previousQueue.options?.throwOnError,
+            ...(options ?? {}),
+        },
+    };
+    const queue = queueTask(previousQueue, task);
+    return {
+        details: () => details(queue),
+        files: () => files(queue),
+        get: () => get(queue),
+        toJson: () => toJson(queue),
+        toYaml: () => toYaml(queue),
+    };
 }
-export {
-  dereferenceCommand
-};
-//# sourceMappingURL=dereferenceCommand.js.map

package/dist/utils/openapi/commands/filterCommand.js

@@ -1,26 +1,25 @@
-import { details } from "../actions/details.js";
-import { files } from "../actions/files.js";
-import { get } from "../actions/get.js";
-import { toJson } from "../actions/toJson.js";
-import { toYaml } from "../actions/toYaml.js";
-import { queueTask } from "../utils/queueTask.js";
-import { dereferenceCommand } from "./dereferenceCommand.js";
-function filterCommand(previousQueue, options) {
-  const task = {
-    name: "filter",
-    options
-  };
-  const queue = queueTask(previousQueue, task);
-  return {
-    dereference: (dereferenceOptions) => dereferenceCommand(queue, dereferenceOptions),
-    details: () => details(queue),
-    files: () => files(queue),
-    get: () => get(queue),
-    toJson: () => toJson(queue),
-    toYaml: () => toYaml(queue)
-  };
+import { details } from '../actions/details.js';
+import { files } from '../actions/files.js';
+import { get } from '../actions/get.js';
+import { toJson } from '../actions/toJson.js';
+import { toYaml } from '../actions/toYaml.js';
+import { queueTask } from '../utils/queueTask.js';
+import { dereferenceCommand } from './dereferenceCommand.js';
+/**
+ * Filter the given OpenAPI document
+ */
+export function filterCommand(previousQueue, options) {
+    const task = {
+        name: 'filter',
+        options,
+    };
+    const queue = queueTask(previousQueue, task);
+    return {
+        dereference: (dereferenceOptions) => dereferenceCommand(queue, dereferenceOptions),
+        details: () => details(queue),
+        files: () => files(queue),
+        get: () => get(queue),
+        toJson: () => toJson(queue),
+        toYaml: () => toYaml(queue),
+    };
 }
-export {
-  filterCommand
-};
-//# sourceMappingURL=filterCommand.js.map

package/dist/utils/openapi/commands/loadCommand.js

@@ -1,42 +1,41 @@
-import { details } from "../actions/details.js";
-import { files } from "../actions/files.js";
-import { get } from "../actions/get.js";
-import { toJson } from "../actions/toJson.js";
-import { toYaml } from "../actions/toYaml.js";
-import { queueTask } from "../utils/queueTask.js";
-import { dereferenceCommand } from "./dereferenceCommand.js";
-import { filterCommand } from "./filterCommand.js";
-import { upgradeCommand } from "./upgradeCommand.js";
-import { validateCommand } from "./validateCommand.js";
-function loadCommand(previousQueue, input, options) {
-  const task = {
-    name: "load",
-    options: {
-      // global
-      throwOnError: previousQueue.options?.throwOnError,
-      // local
-      ...options
-    }
-  };
-  const queue = {
-    // Add the load task
-    ...queueTask(previousQueue, task),
-    // Add input to the queue
-    input
-  };
-  return {
-    dereference: (dereferenceOptions) => dereferenceCommand(queue, dereferenceOptions),
-    details: () => details(queue),
-    files: () => files(queue),
-    filter: (callback) => filterCommand(queue, callback),
-    get: () => get(queue),
-    upgrade: () => upgradeCommand(queue),
-    toJson: () => toJson(queue),
-    toYaml: () => toYaml(queue),
-    validate: (validateOptions) => validateCommand(queue, validateOptions)
-  };
+import { details } from '../actions/details.js';
+import { files } from '../actions/files.js';
+import { get } from '../actions/get.js';
+import { toJson } from '../actions/toJson.js';
+import { toYaml } from '../actions/toYaml.js';
+import { queueTask } from '../utils/queueTask.js';
+import { dereferenceCommand } from './dereferenceCommand.js';
+import { filterCommand } from './filterCommand.js';
+import { upgradeCommand } from './upgradeCommand.js';
+import { validateCommand } from './validateCommand.js';
+/**
+ * Pass any OpenAPI document
+ */
+export function loadCommand(previousQueue, input, options) {
+    const task = {
+        name: 'load',
+        options: {
+            // global
+            throwOnError: previousQueue.options?.throwOnError,
+            // local
+            ...options,
+        },
+    };
+    const queue = {
+        // Add the load task
+        ...queueTask(previousQueue, task),
+        // Add input to the queue
+        input,
+    };
+    return {
+        dereference: (dereferenceOptions) => dereferenceCommand(queue, dereferenceOptions),
+        details: () => details(queue),
+        files: () => files(queue),
+        filter: (callback) => filterCommand(queue, callback),
+        get: () => get(queue),
+        upgrade: () => upgradeCommand(queue),
+        toJson: () => toJson(queue),
+        toYaml: () => toYaml(queue),
+        validate: (validateOptions) => validateCommand(queue, validateOptions),
+    };
 }
-export {
-  loadCommand
-};
-//# sourceMappingURL=loadCommand.js.map