@speclynx/apidom-reference 4.0.2 → 4.0.3

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

@@ -0,0 +1,78 @@
+import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import File from '../../../File.ts';
+import { merge as mergeOptions } from '../../../options/util.ts';
+import UnmatchedDereferenceStrategyError from '../../../errors/UnmatchedDereferenceStrategyError.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type { default as ResolveStrategy, ResolveStrategyOptions } from '../ResolveStrategy.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type {
+  ReferenceOptions as ApiDOMReferenceOptions,
+  ReferenceBundleOptions as ApiDOMReferenceBundleOptions,
+  ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions,
+  ReferenceParseOptions as ApiDOMReferenceParseOptions,
+  ReferenceResolveOptions as ApiDOMReferenceResolveOptions,
+} from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../resolvers/Resolver.ts';
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+
+/**
+ * @public
+ */
+export interface AsyncAPI2ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class AsyncAPI2ResolveStrategy extends ResolveStrategy {
+  constructor(options?: AsyncAPI2ResolveStrategyOptions) {
+    super({ ...(options ?? {}), name: 'asyncapi-2' });
+  }
+
+  canResolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'asyncapi-2',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+
+    return dereferenceStrategy.canDereference(file, options);
+  }
+
+  async resolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'asyncapi-2',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(
+        `"asyncapi-2" resolve strategy requires "asyncapi-2" dereference strategy to be configured for file "${file.uri}"`,
+      );
+    }
+
+    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" resolve strategy requires "openapi-2" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    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" resolve strategy requires "openapi-2" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default OpenAPI2ResolveStrategy;

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

@@ -0,0 +1,78 @@
+import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import File from '../../../File.ts';
+import { merge as mergeOptions } from '../../../options/util.ts';
+import UnmatchedDereferenceStrategyError from '../../../errors/UnmatchedDereferenceStrategyError.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type { default as ResolveStrategy, ResolveStrategyOptions } from '../ResolveStrategy.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type {
+  ReferenceOptions as ApiDOMReferenceOptions,
+  ReferenceBundleOptions as ApiDOMReferenceBundleOptions,
+  ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions,
+  ReferenceParseOptions as ApiDOMReferenceParseOptions,
+  ReferenceResolveOptions as ApiDOMReferenceResolveOptions,
+} from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../resolvers/Resolver.ts';
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+
+/**
+ * @public
+ */
+export interface OpenAPI2ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class OpenAPI2ResolveStrategy extends ResolveStrategy {
+  constructor(options?: OpenAPI2ResolveStrategyOptions) {
+    super({ ...(options ?? {}), name: 'openapi-2' });
+  }
+
+  canResolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-2',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+
+    return dereferenceStrategy.canDereference(file, options);
+  }
+
+  async resolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-2',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(
+        `"openapi-2" resolve strategy requires "openapi-2" dereference strategy to be configured for file "${file.uri}"`,
+      );
+    }
+
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: { internal: false },
+      dereference: { refSet },
+    });
+
+    await dereferenceStrategy.dereference(file, mergedOptions);
+
+    return refSet;
+  }
+}
+
+export default OpenAPI2ResolveStrategy;

package/src/resolve/strategies/openapi-3-0/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 OpenAPI3_0ResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-0'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-0');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-0');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default(`"openapi-3-0" resolve strategy requires "openapi-3-0" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    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 = OpenAPI3_0ResolveStrategy;

package/src/resolve/strategies/openapi-3-0/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 OpenAPI3_0ResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-0'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-0');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-0');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(`"openapi-3-0" resolve strategy requires "openapi-3-0" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default OpenAPI3_0ResolveStrategy;

package/src/resolve/strategies/openapi-3-0/index.ts

@@ -0,0 +1,78 @@
+import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import File from '../../../File.ts';
+import { merge as mergeOptions } from '../../../options/util.ts';
+import UnmatchedDereferenceStrategyError from '../../../errors/UnmatchedDereferenceStrategyError.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type { default as ResolveStrategy, ResolveStrategyOptions } from '../ResolveStrategy.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type {
+  ReferenceOptions as ApiDOMReferenceOptions,
+  ReferenceBundleOptions as ApiDOMReferenceBundleOptions,
+  ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions,
+  ReferenceParseOptions as ApiDOMReferenceParseOptions,
+  ReferenceResolveOptions as ApiDOMReferenceResolveOptions,
+} from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../resolvers/Resolver.ts';
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+
+/**
+ * @public
+ */
+export interface OpenAPI3_0ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class OpenAPI3_0ResolveStrategy extends ResolveStrategy {
+  constructor(options?: OpenAPI3_0ResolveStrategyOptions) {
+    super({ ...(options ?? {}), name: 'openapi-3-0' });
+  }
+
+  canResolve(file: File, options: ReferenceOptions): boolean {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-3-0',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+
+    return dereferenceStrategy.canDereference(file, options);
+  }
+
+  async resolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-3-0',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(
+        `"openapi-3-0" resolve strategy requires "openapi-3-0" dereference strategy to be configured for file "${file.uri}"`,
+      );
+    }
+
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: { internal: false },
+      dereference: { refSet },
+    });
+
+    await dereferenceStrategy.dereference(file, mergedOptions);
+
+    return refSet;
+  }
+}
+
+export default OpenAPI3_0ResolveStrategy;

package/src/resolve/strategies/openapi-3-1/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 OpenAPI3_1ResolveStrategy extends _ResolveStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-1'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-1');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-1');
+    if (dereferenceStrategy === undefined) {
+      throw new _UnmatchedDereferenceStrategyError.default(`"openapi-3-1" resolve strategy requires "openapi-3-1" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    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 = OpenAPI3_1ResolveStrategy;

package/src/resolve/strategies/openapi-3-1/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 OpenAPI3_1ResolveStrategy extends ResolveStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-1'
+    });
+  }
+  canResolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-1');
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+    return dereferenceStrategy.canDereference(file, options);
+  }
+  async resolve(file, options) {
+    const dereferenceStrategy = options.dereference.strategies.find(strategy => strategy.name === 'openapi-3-1');
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(`"openapi-3-1" resolve strategy requires "openapi-3-1" dereference strategy to be configured for file "${file.uri}"`);
+    }
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: {
+        internal: false
+      },
+      dereference: {
+        refSet
+      }
+    });
+    await dereferenceStrategy.dereference(file, mergedOptions);
+    return refSet;
+  }
+}
+export default OpenAPI3_1ResolveStrategy;

package/src/resolve/strategies/openapi-3-1/index.ts

@@ -0,0 +1,78 @@
+import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import File from '../../../File.ts';
+import { merge as mergeOptions } from '../../../options/util.ts';
+import UnmatchedDereferenceStrategyError from '../../../errors/UnmatchedDereferenceStrategyError.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type { default as ResolveStrategy, ResolveStrategyOptions } from '../ResolveStrategy.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type {
+  ReferenceOptions as ApiDOMReferenceOptions,
+  ReferenceBundleOptions as ApiDOMReferenceBundleOptions,
+  ReferenceDereferenceOptions as ApiDOMReferenceDereferenceOptions,
+  ReferenceParseOptions as ApiDOMReferenceParseOptions,
+  ReferenceResolveOptions as ApiDOMReferenceResolveOptions,
+} from '../../../options/index.ts';
+export type { default as Parser, ParserOptions } from '../../../parse/parsers/Parser.ts';
+export type { default as Resolver, ResolverOptions } from '../../resolvers/Resolver.ts';
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../../../dereference/strategies/DereferenceStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+
+/**
+ * @public
+ */
+export interface OpenAPI3_1ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class OpenAPI3_1ResolveStrategy extends ResolveStrategy {
+  constructor(options?: OpenAPI3_1ResolveStrategyOptions) {
+    super({ ...(options ?? {}), name: 'openapi-3-1' });
+  }
+
+  canResolve(file: File, options: ReferenceOptions): boolean {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-3-1',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      return false;
+    }
+
+    return dereferenceStrategy.canDereference(file, options);
+  }
+
+  async resolve(file: File, options: ReferenceOptions) {
+    const dereferenceStrategy = options.dereference.strategies.find(
+      (strategy) => strategy.name === 'openapi-3-1',
+    );
+
+    if (dereferenceStrategy === undefined) {
+      throw new UnmatchedDereferenceStrategyError(
+        `"openapi-3-1" resolve strategy requires "openapi-3-1" dereference strategy to be configured for file "${file.uri}"`,
+      );
+    }
+
+    const refSet = new ReferenceSet();
+    const mergedOptions = mergeOptions(options, {
+      resolve: { internal: false },
+      dereference: { refSet },
+    });
+
+    await dereferenceStrategy.dereference(file, mergedOptions);
+
+    return refSet;
+  }
+}
+
+export default OpenAPI3_1ResolveStrategy;

package/src/resolve/util.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.readFile = void 0;
+var _ramda = require("ramda");
+var plugins = _interopRequireWildcard(require("../util/plugins.cjs"));
+var _ResolveError = _interopRequireDefault(require("../errors/ResolveError.cjs"));
+var _UnmatchedResolverError = _interopRequireDefault(require("../errors/UnmatchedResolverError.cjs"));
+/**
+ * Reads the given file, using the configured resolver plugins.
+ */
+
+const readFile = async (file, options) => {
+  const optsBoundResolvers = options.resolve.resolvers.map(resolver => {
+    const clonedResolver = Object.create(resolver);
+    return Object.assign(clonedResolver, options.resolve.resolverOpts);
+  });
+  const resolvers = await plugins.filter('canRead', [file, options], optsBoundResolvers);
+
+  // we couldn't find any resolver for this File
+  if ((0, _ramda.isEmpty)(resolvers)) {
+    throw new _UnmatchedResolverError.default(`Could not find a resolver that can read the file "${file.uri}"`);
+  }
+  try {
+    const {
+      result
+    } = await plugins.run('read', [file, options], resolvers);
+    return result;
+  } catch (error) {
+    throw new _ResolveError.default(`Error while reading file "${file.uri}"`, {
+      cause: error
+    });
+  }
+};
+exports.readFile = readFile;

package/src/resolve/util.mjs

@@ -0,0 +1,30 @@
+import { isEmpty } from 'ramda';
+import * as plugins from "../util/plugins.mjs";
+import ResolveError from "../errors/ResolveError.mjs";
+import UnmatchedResolverError from "../errors/UnmatchedResolverError.mjs";
+/**
+ * Reads the given file, using the configured resolver plugins.
+ */
+
+export const readFile = async (file, options) => {
+  const optsBoundResolvers = options.resolve.resolvers.map(resolver => {
+    const clonedResolver = Object.create(resolver);
+    return Object.assign(clonedResolver, options.resolve.resolverOpts);
+  });
+  const resolvers = await plugins.filter('canRead', [file, options], optsBoundResolvers);
+
+  // we couldn't find any resolver for this File
+  if (isEmpty(resolvers)) {
+    throw new UnmatchedResolverError(`Could not find a resolver that can read the file "${file.uri}"`);
+  }
+  try {
+    const {
+      result
+    } = await plugins.run('read', [file, options], resolvers);
+    return result;
+  } catch (error) {
+    throw new ResolveError(`Error while reading file "${file.uri}"`, {
+      cause: error
+    });
+  }
+};