@speclynx/apidom-reference 1.12.1

package/src/resolve/resolvers/HTTPResolver.mjs

@@ -0,0 +1,31 @@
+import Resolver from "./Resolver.mjs";
+import * as url from "../../util/url.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class HTTPResolver extends Resolver {
+  timeout;
+  redirects;
+  withCredentials;
+  constructor(options) {
+    const {
+      name = 'http-resolver',
+      timeout = 5000,
+      redirects = 5,
+      withCredentials = false
+    } = options ?? {};
+    super({
+      name
+    });
+    this.timeout = timeout;
+    this.redirects = redirects;
+    this.withCredentials = withCredentials;
+  }
+  canRead(file) {
+    return url.isHttpUrl(file.uri);
+  }
+}
+export default HTTPResolver;

package/src/resolve/resolvers/Resolver.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Resolver {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+var _default = exports.default = Resolver;

package/src/resolve/resolvers/Resolver.mjs

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Resolver {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+export default Resolver;

package/src/resolve/resolvers/file/index-browser.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Resolver = _interopRequireDefault(require("../Resolver.cjs"));
+var _ResolverError = _interopRequireDefault(require("../../../errors/ResolverError.cjs"));
+/**
+ * @public
+ */
+class FileResolver extends _Resolver.default {
+  constructor() {
+    super({
+      name: 'file'
+    });
+  }
+  canRead() {
+    return false;
+  }
+  read() {
+    throw new _ResolverError.default('FileResolver is not intended to be used in browser context.');
+  }
+}
+var _default = exports.default = FileResolver;

package/src/resolve/resolvers/file/index-browser.mjs

@@ -0,0 +1,19 @@
+import Resolver from "../Resolver.mjs";
+import ResolverError from "../../../errors/ResolverError.mjs";
+/**
+ * @public
+ */
+class FileResolver extends Resolver {
+  constructor() {
+    super({
+      name: 'file'
+    });
+  }
+  canRead() {
+    return false;
+  }
+  read() {
+    throw new ResolverError('FileResolver is not intended to be used in browser context.');
+  }
+}
+export default FileResolver;

package/src/resolve/resolvers/file/index-node.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _nodeFs = require("node:fs");
+var _nodeUtil = require("node:util");
+var _minimatch = _interopRequireDefault(require("minimatch"));
+var _Resolver = _interopRequireDefault(require("../Resolver.cjs"));
+var url = _interopRequireWildcard(require("../../../util/url.cjs"));
+var _ResolverError = _interopRequireDefault(require("../../../errors/ResolverError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class FileResolver extends _Resolver.default {
+  fileAllowList;
+  constructor(options) {
+    const {
+      fileAllowList = []
+    } = options ?? {};
+    super({
+      name: 'file'
+    });
+    this.fileAllowList = fileAllowList;
+  }
+  canRead(file) {
+    return url.isFileSystemPath(file.uri) && this.fileAllowList.some(pattern => {
+      return typeof pattern === 'string' ? (0, _minimatch.default)(file.uri, pattern, {
+        matchBase: true
+      }) : pattern.test(file.uri);
+    });
+  }
+  async read(file) {
+    const fileSystemPath = url.toFileSystemPath(file.uri);
+    try {
+      return await (0, _nodeUtil.promisify)(_nodeFs.readFile)(fileSystemPath);
+    } catch (error) {
+      throw new _ResolverError.default(`Error opening file "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = FileResolver;

package/src/resolve/resolvers/file/index-node.mjs

@@ -0,0 +1,42 @@
+import { readFile } from 'node:fs';
+import { promisify } from 'node:util';
+import minimatch from 'minimatch';
+import Resolver from "../Resolver.mjs";
+import * as url from "../../../util/url.mjs";
+import ResolverError from "../../../errors/ResolverError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class FileResolver extends Resolver {
+  fileAllowList;
+  constructor(options) {
+    const {
+      fileAllowList = []
+    } = options ?? {};
+    super({
+      name: 'file'
+    });
+    this.fileAllowList = fileAllowList;
+  }
+  canRead(file) {
+    return url.isFileSystemPath(file.uri) && this.fileAllowList.some(pattern => {
+      return typeof pattern === 'string' ? minimatch(file.uri, pattern, {
+        matchBase: true
+      }) : pattern.test(file.uri);
+    });
+  }
+  async read(file) {
+    const fileSystemPath = url.toFileSystemPath(file.uri);
+    try {
+      return await promisify(readFile)(fileSystemPath);
+    } catch (error) {
+      throw new ResolverError(`Error opening file "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default FileResolver;

package/src/resolve/resolvers/http-axios/index.cjs

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _axios = _interopRequireDefault(require("axios"));
+var _HTTPResolver = _interopRequireDefault(require("../HTTPResolver.cjs"));
+var _ResolverError = _interopRequireDefault(require("../../../errors/ResolverError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class HTTPResolverAxios extends _HTTPResolver.default {
+  axiosConfig = {};
+  axiosInstance;
+  previousAxiosConfig;
+  constructor(options) {
+    const {
+      axiosConfig = {},
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'http-axios'
+    });
+    this.axiosConfig = axiosConfig;
+  }
+  getHttpClient() {
+    if (this.axiosInstance === undefined || this.previousAxiosConfig !== this.axiosConfig) {
+      const config = (0, _ramda.omit)(['interceptors'], this.axiosConfig);
+      const {
+        interceptors
+      } = this.axiosConfig;
+      this.axiosInstance = _axios.default.create({
+        timeout: this.timeout,
+        maxRedirects: this.redirects,
+        withCredentials: this.withCredentials,
+        responseType: 'arraybuffer',
+        ...config
+      });
+
+      // settings up request interceptors
+      if (Array.isArray(interceptors?.request)) {
+        interceptors.request.forEach(requestInterceptor => {
+          this.axiosInstance.interceptors.request.use(...(0, _ramdaAdjunct.ensureArray)(requestInterceptor));
+        });
+      }
+
+      // settings up response interceptors
+      if (Array.isArray(interceptors?.response)) {
+        interceptors.response.forEach(responseInterceptor => {
+          this.axiosInstance.interceptors.response.use(...(0, _ramdaAdjunct.ensureArray)(responseInterceptor));
+        });
+      }
+      this.previousAxiosConfig = this.axiosConfig;
+    }
+    return this.axiosInstance;
+  }
+  async read(file) {
+    const client = this.getHttpClient();
+    try {
+      const response = await client.get(file.uri);
+      return response.data;
+    } catch (error) {
+      throw new _ResolverError.default(`Error downloading "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = HTTPResolverAxios;

package/src/resolve/resolvers/http-axios/index.mjs

@@ -0,0 +1,73 @@
+import { omit } from 'ramda';
+import { ensureArray } from 'ramda-adjunct';
+import axios from 'axios';
+import HTTPResolver from "../HTTPResolver.mjs";
+import ResolverError from "../../../errors/ResolverError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class HTTPResolverAxios extends HTTPResolver {
+  axiosConfig = {};
+  axiosInstance;
+  previousAxiosConfig;
+  constructor(options) {
+    const {
+      axiosConfig = {},
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'http-axios'
+    });
+    this.axiosConfig = axiosConfig;
+  }
+  getHttpClient() {
+    if (this.axiosInstance === undefined || this.previousAxiosConfig !== this.axiosConfig) {
+      const config = omit(['interceptors'], this.axiosConfig);
+      const {
+        interceptors
+      } = this.axiosConfig;
+      this.axiosInstance = axios.create({
+        timeout: this.timeout,
+        maxRedirects: this.redirects,
+        withCredentials: this.withCredentials,
+        responseType: 'arraybuffer',
+        ...config
+      });
+
+      // settings up request interceptors
+      if (Array.isArray(interceptors?.request)) {
+        interceptors.request.forEach(requestInterceptor => {
+          this.axiosInstance.interceptors.request.use(...ensureArray(requestInterceptor));
+        });
+      }
+
+      // settings up response interceptors
+      if (Array.isArray(interceptors?.response)) {
+        interceptors.response.forEach(responseInterceptor => {
+          this.axiosInstance.interceptors.response.use(...ensureArray(responseInterceptor));
+        });
+      }
+      this.previousAxiosConfig = this.axiosConfig;
+    }
+    return this.axiosInstance;
+  }
+  async read(file) {
+    const client = this.getHttpClient();
+    try {
+      const response = await client.get(file.uri);
+      return response.data;
+    } catch (error) {
+      throw new ResolverError(`Error downloading "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default HTTPResolverAxios;

package/src/resolve/strategies/ResolveStrategy.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ResolveStrategy {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+var _default = exports.default = ResolveStrategy;

package/src/resolve/strategies/ResolveStrategy.mjs

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ResolveStrategy {
+  name;
+  constructor({
+    name
+  }) {
+    this.name = name;
+  }
+}
+export default ResolveStrategy;

package/src/resolve/strategies/apidom/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ResolveStrategy = _interopRequireDefault(require("../ResolveStrategy.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _util = require("../../../options/util.cjs");
+var _UnmatchedDereferenceStrategyError = _interopRequireDefault(require("../../../errors/UnmatchedDereferenceStrategyError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class ApiDOMResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'apidom'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default('"apidom" dereference strategy is not available.');
+    }
+    const refSet = new _ReferenceSet.default();
+    const mergedOptions = (0, _util.merge)(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+var _default = exports.default = ApiDOMResolveStrategy;

package/src/resolve/strategies/apidom/index.mjs

@@ -0,0 +1,43 @@
+import ResolveStrategy from "../ResolveStrategy.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import { merge as mergeOptions } from "../../../options/util.mjs";
+import UnmatchedDereferenceStrategyError from "../../../errors/UnmatchedDereferenceStrategyError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class ApiDOMResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'apidom'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'apidom');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError('"apidom" dereference strategy is not available.');
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default ApiDOMResolveStrategy;

package/src/resolve/strategies/asyncapi-2/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ResolveStrategy = _interopRequireDefault(require("../ResolveStrategy.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _util = require("../../../options/util.cjs");
+var _UnmatchedDereferenceStrategyError = _interopRequireDefault(require("../../../errors/UnmatchedDereferenceStrategyError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AsyncAPI2ResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'asyncapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default('"asyncapi-2" dereference strategy is not available.');
+    }
+    const refSet = new _ReferenceSet.default();
+    const mergedOptions = (0, _util.merge)(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+var _default = exports.default = AsyncAPI2ResolveStrategy;

package/src/resolve/strategies/asyncapi-2/index.mjs

@@ -0,0 +1,43 @@
+import ResolveStrategy from "../ResolveStrategy.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import { merge as mergeOptions } from "../../../options/util.mjs";
+import UnmatchedDereferenceStrategyError from "../../../errors/UnmatchedDereferenceStrategyError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AsyncAPI2ResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'asyncapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'asyncapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError('"asyncapi-2" dereference strategy is not available.');
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default AsyncAPI2ResolveStrategy;

package/src/resolve/strategies/openapi-2/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ResolveStrategy = _interopRequireDefault(require("../ResolveStrategy.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _util = require("../../../options/util.cjs");
+var _UnmatchedDereferenceStrategyError = _interopRequireDefault(require("../../../errors/UnmatchedDereferenceStrategyError.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class OpenAPI2ResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default('"openapi-2" dereference strategy is not available.');
+    }
+    const refSet = new _ReferenceSet.default();
+    const mergedOptions = (0, _util.merge)(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+var _default = exports.default = OpenAPI2ResolveStrategy;

package/src/resolve/strategies/openapi-2/index.mjs

@@ -0,0 +1,43 @@
+import ResolveStrategy from "../ResolveStrategy.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import { merge as mergeOptions } from "../../../options/util.mjs";
+import UnmatchedDereferenceStrategyError from "../../../errors/UnmatchedDereferenceStrategyError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class OpenAPI2ResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-2'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-2');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-2');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError('"openapi-2" dereference strategy is not available.');
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default OpenAPI2ResolveStrategy;