@speclynx/apidom-reference 4.0.1 → 4.0.3

package/src/dereference/strategies/openapi-3-1/index.cjs

@@ -0,0 +1,99 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.resolveSchema$refField = exports.resolveSchema$idField = exports.maybeRefractToSchemaElement = exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _apidomTraverse = require("@speclynx/apidom-traverse");
+var _apidomNsOpenapi = require("@speclynx/apidom-ns-openapi-3-1");
+var _DereferenceStrategy = _interopRequireDefault(require("../DereferenceStrategy.cjs"));
+var _Reference = _interopRequireDefault(require("../../../Reference.cjs"));
+var _ReferenceSet = _interopRequireDefault(require("../../../ReferenceSet.cjs"));
+var _visitor = _interopRequireDefault(require("./visitor.cjs"));
+exports.OpenAPI3_1DereferenceVisitor = _visitor.default;
+var _util = require("./util.cjs");
+exports.resolveSchema$refField = _util.resolveSchema$refField;
+exports.resolveSchema$idField = _util.resolveSchema$idField;
+exports.maybeRefractToSchemaElement = _util.maybeRefractToSchemaElement;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class OpenAPI3_1DereferenceStrategy extends _DereferenceStrategy.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-1'
+    });
+  }
+  canDereference(file) {
+    // assert by media type
+    if (file.mediaType !== 'text/plain') {
+      return _apidomNsOpenapi.mediaTypes.includes(file.mediaType);
+    }
+
+    // assert by inspecting ApiDOM
+    return (0, _apidomNsOpenapi.isOpenApi3_1Element)(file.parseResult?.result);
+  }
+  async dereference(file, options) {
+    const immutableRefSet = options.dereference.refSet ?? new _ReferenceSet.default();
+    const mutableRefSet = new _ReferenceSet.default();
+    let refSet = immutableRefSet;
+    let reference;
+    if (!immutableRefSet.has(file.uri)) {
+      reference = new _Reference.default({
+        uri: file.uri,
+        value: file.parseResult
+      });
+      immutableRefSet.add(reference);
+    } else {
+      // pre-computed refSet was provided as configuration option
+      reference = immutableRefSet.find((0, _ramda.propEq)(file.uri, 'uri'));
+    }
+
+    /**
+     * Clone refSet due the dereferencing process being mutable.
+     * We don't want to mutate the original refSet and the references.
+     */
+    if (options.dereference.immutable) {
+      immutableRefSet.refs.map(ref => new _Reference.default({
+        ...ref,
+        value: (0, _apidomDatamodel.cloneDeep)(ref.value)
+      })).forEach(ref => mutableRefSet.add(ref));
+      reference = mutableRefSet.find(ref => ref.uri === file.uri);
+      refSet = mutableRefSet;
+    }
+    const visitor = new _visitor.default({
+      reference: reference,
+      options
+    });
+    const dereferencedElement = await (0, _apidomTraverse.traverseAsync)(refSet.rootRef.value, visitor, {
+      mutable: true
+    });
+
+    /**
+     * If immutable option is set, replay refs from the refSet.
+     */
+    if (options.dereference.immutable) {
+      mutableRefSet.refs.filter(ref => ref.uri.startsWith('immutable://')).map(ref => new _Reference.default({
+        ...ref,
+        uri: ref.uri.replace(/^immutable:\/\//, '')
+      })).forEach(ref => immutableRefSet.add(ref));
+    }
+
+    /**
+     * Release all memory if this refSet was not provided as an configuration option.
+     * If provided as configuration option, then provider is responsible for cleanup.
+     */
+    if (options.dereference.refSet === null) {
+      immutableRefSet.clean();
+    }
+    mutableRefSet.clean();
+    return dereferencedElement;
+  }
+}
+var _default = exports.default = OpenAPI3_1DereferenceStrategy;

package/src/dereference/strategies/openapi-3-1/index.mjs

@@ -0,0 +1,90 @@
+import { propEq } from 'ramda';
+import { cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { isOpenApi3_1Element, mediaTypes } from '@speclynx/apidom-ns-openapi-3-1';
+import DereferenceStrategy from "../DereferenceStrategy.mjs";
+import Reference from "../../../Reference.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import OpenAPI3_1DereferenceVisitor from "./visitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class OpenAPI3_1DereferenceStrategy extends DereferenceStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'openapi-3-1'
+    });
+  }
+  canDereference(file) {
+    // assert by media type
+    if (file.mediaType !== 'text/plain') {
+      return mediaTypes.includes(file.mediaType);
+    }
+
+    // assert by inspecting ApiDOM
+    return isOpenApi3_1Element(file.parseResult?.result);
+  }
+  async dereference(file, options) {
+    const immutableRefSet = options.dereference.refSet ?? new ReferenceSet();
+    const mutableRefSet = new ReferenceSet();
+    let refSet = immutableRefSet;
+    let reference;
+    if (!immutableRefSet.has(file.uri)) {
+      reference = new Reference({
+        uri: file.uri,
+        value: file.parseResult
+      });
+      immutableRefSet.add(reference);
+    } else {
+      // pre-computed refSet was provided as configuration option
+      reference = immutableRefSet.find(propEq(file.uri, 'uri'));
+    }
+
+    /**
+     * Clone refSet due the dereferencing process being mutable.
+     * We don't want to mutate the original refSet and the references.
+     */
+    if (options.dereference.immutable) {
+      immutableRefSet.refs.map(ref => new Reference({
+        ...ref,
+        value: cloneDeep(ref.value)
+      })).forEach(ref => mutableRefSet.add(ref));
+      reference = mutableRefSet.find(ref => ref.uri === file.uri);
+      refSet = mutableRefSet;
+    }
+    const visitor = new OpenAPI3_1DereferenceVisitor({
+      reference: reference,
+      options
+    });
+    const dereferencedElement = await traverseAsync(refSet.rootRef.value, visitor, {
+      mutable: true
+    });
+
+    /**
+     * If immutable option is set, replay refs from the refSet.
+     */
+    if (options.dereference.immutable) {
+      mutableRefSet.refs.filter(ref => ref.uri.startsWith('immutable://')).map(ref => new Reference({
+        ...ref,
+        uri: ref.uri.replace(/^immutable:\/\//, '')
+      })).forEach(ref => immutableRefSet.add(ref));
+    }
+
+    /**
+     * Release all memory if this refSet was not provided as an configuration option.
+     * If provided as configuration option, then provider is responsible for cleanup.
+     */
+    if (options.dereference.refSet === null) {
+      immutableRefSet.clean();
+    }
+    mutableRefSet.clean();
+    return dereferencedElement;
+  }
+}
+export { OpenAPI3_1DereferenceVisitor };
+export { resolveSchema$refField, resolveSchema$idField, maybeRefractToSchemaElement } from "./util.mjs";
+export default OpenAPI3_1DereferenceStrategy;

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

@@ -0,0 +1,141 @@
+import { propEq } from 'ramda';
+import { Element, cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { isOpenApi3_1Element, mediaTypes } from '@speclynx/apidom-ns-openapi-3-1';
+
+import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy.ts';
+import File from '../../../File.ts';
+import Reference from '../../../Reference.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import OpenAPI3_1DereferenceVisitor from './visitor.ts';
+import type { ReferenceOptions } from '../../../options/index.ts';
+
+export type {
+  default as DereferenceStrategy,
+  DereferenceStrategyOptions,
+} from '../DereferenceStrategy.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+export type { default as Reference, ReferenceOptions } from '../../../Reference.ts';
+export type { default as ReferenceSet, ReferenceSetOptions } from '../../../ReferenceSet.ts';
+export type { OpenAPI3_1DereferenceVisitorOptions } from './visitor.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 '../../../resolve/resolvers/Resolver.ts';
+export type {
+  default as ResolveStrategy,
+  ResolveStrategyOptions,
+} from '../../../resolve/strategies/ResolveStrategy.ts';
+export type {
+  default as BundleStrategy,
+  BundleStrategyOptions,
+} from '../../../bundle/strategies/BundleStrategy.ts';
+export type { AncestorLineage } from '../../util.ts';
+
+/**
+ * @public
+ */
+export interface OpenAPI3_1DereferenceStrategyOptions extends Omit<
+  DereferenceStrategyOptions,
+  'name'
+> {}
+
+/**
+ * @public
+ */
+class OpenAPI3_1DereferenceStrategy extends DereferenceStrategy {
+  constructor(options?: OpenAPI3_1DereferenceStrategyOptions) {
+    super({ ...(options ?? {}), name: 'openapi-3-1' });
+  }
+
+  canDereference(file: File): boolean {
+    // assert by media type
+    if (file.mediaType !== 'text/plain') {
+      return mediaTypes.includes(file.mediaType);
+    }
+
+    // assert by inspecting ApiDOM
+    return isOpenApi3_1Element(file.parseResult?.result);
+  }
+
+  async dereference(file: File, options: ReferenceOptions): Promise<Element> {
+    const immutableRefSet = options.dereference.refSet ?? new ReferenceSet();
+    const mutableRefSet = new ReferenceSet();
+    let refSet = immutableRefSet;
+    let reference;
+
+    if (!immutableRefSet.has(file.uri)) {
+      reference = new Reference({ uri: file.uri, value: file.parseResult! });
+      immutableRefSet.add(reference);
+    } else {
+      // pre-computed refSet was provided as configuration option
+      reference = immutableRefSet.find(propEq(file.uri, 'uri'));
+    }
+
+    /**
+     * Clone refSet due the dereferencing process being mutable.
+     * We don't want to mutate the original refSet and the references.
+     */
+    if (options.dereference.immutable) {
+      immutableRefSet.refs
+        .map(
+          (ref) =>
+            new Reference({
+              ...ref,
+              value: cloneDeep(ref.value),
+            }),
+        )
+        .forEach((ref) => mutableRefSet.add(ref));
+      reference = mutableRefSet.find((ref) => ref.uri === file.uri);
+      refSet = mutableRefSet;
+    }
+
+    const visitor = new OpenAPI3_1DereferenceVisitor({ reference: reference!, options });
+
+    const dereferencedElement = await traverseAsync(refSet.rootRef!.value, visitor, {
+      mutable: true,
+    });
+
+    /**
+     * If immutable option is set, replay refs from the refSet.
+     */
+    if (options.dereference.immutable) {
+      mutableRefSet.refs
+        .filter((ref) => ref.uri.startsWith('immutable://'))
+        .map(
+          (ref) =>
+            new Reference({
+              ...ref,
+              uri: ref.uri.replace(/^immutable:\/\//, ''),
+            }),
+        )
+        .forEach((ref) => immutableRefSet.add(ref));
+    }
+
+    /**
+     * Release all memory if this refSet was not provided as an configuration option.
+     * If provided as configuration option, then provider is responsible for cleanup.
+     */
+    if (options.dereference.refSet === null) {
+      immutableRefSet.clean();
+    }
+
+    mutableRefSet.clean();
+
+    return dereferencedElement;
+  }
+}
+
+export { OpenAPI3_1DereferenceVisitor };
+export {
+  resolveSchema$refField,
+  resolveSchema$idField,
+  maybeRefractToSchemaElement,
+} from './util.ts';
+
+export default OpenAPI3_1DereferenceStrategy;

package/src/dereference/strategies/openapi-3-1/selectors/$anchor.cjs

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.uriToAnchor = exports.parse = exports.isAnchor = exports.evaluate = exports.JsonSchema$anchorError = void 0;
+var _ramdaAdjunct = require("ramda-adjunct");
+var _apidomCore = require("@speclynx/apidom-core");
+var _apidomTraverse = require("@speclynx/apidom-traverse");
+var _apidomNsJsonSchema = require("@speclynx/apidom-ns-json-schema-2020-12");
+var _url = require("../../../../util/url.cjs");
+var _EvaluationJsonSchema$anchorError = _interopRequireDefault(require("../../../../errors/EvaluationJsonSchema$anchorError.cjs"));
+exports.EvaluationJsonSchema$anchorError = _EvaluationJsonSchema$anchorError.default;
+var _InvalidJsonSchema$anchorError = _interopRequireDefault(require("../../../../errors/InvalidJsonSchema$anchorError.cjs"));
+exports.InvalidJsonSchema$anchorError = _InvalidJsonSchema$anchorError.default;
+var _JsonSchema$anchorError = _interopRequireDefault(require("../../../../errors/JsonSchema$anchorError.cjs"));
+exports.JsonSchema$anchorError = _JsonSchema$anchorError.default;
+/**
+ * @public
+ */
+const isAnchor = uri => {
+  /**
+   *  MUST start with a letter ([A-Za-z]) or underscore ("_"), followed by any number of letters,
+   *  digits ([0-9]), hyphens ("-"), underscores ("_"), and periods (".").
+   *
+   *  https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.8.2.2
+   */
+  return /^[A-Za-z_][A-Za-z_0-9.-]*$/.test(uri);
+};
+
+/**
+ * @public
+ */
+exports.isAnchor = isAnchor;
+const uriToAnchor = uri => {
+  const hash = (0, _url.getHash)(uri);
+  return (0, _ramdaAdjunct.trimCharsStart)('#', hash);
+};
+
+/**
+ * @public
+ */
+exports.uriToAnchor = uriToAnchor;
+const parse = anchor => {
+  if (!isAnchor(anchor)) {
+    throw new _InvalidJsonSchema$anchorError.default(anchor);
+  }
+  return anchor;
+};
+
+/**
+ * Evaluates JSON Schema $anchor against ApiDOM fragment.
+ * @public
+ */
+exports.parse = parse;
+const evaluate = (anchor, element) => {
+  const token = parse(anchor);
+  const resultPath = (0, _apidomTraverse.find)(element,
+  // @ts-ignore
+  path => (0, _apidomNsJsonSchema.isJSONSchemaElement)(path.node) && (0, _apidomCore.toValue)(path.node.$anchor) === token);
+  if ((0, _ramdaAdjunct.isUndefined)(resultPath)) {
+    throw new _EvaluationJsonSchema$anchorError.default(`Evaluation failed on token: "${token}"`);
+  }
+  return resultPath.node;
+};
+exports.evaluate = evaluate;

package/src/dereference/strategies/openapi-3-1/selectors/$anchor.mjs

@@ -0,0 +1,54 @@
+import { trimCharsStart, isUndefined } from 'ramda-adjunct';
+import { toValue } from '@speclynx/apidom-core';
+import { find } from '@speclynx/apidom-traverse';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { getHash } from "../../../../util/url.mjs";
+import EvaluationJsonSchema$anchorError from "../../../../errors/EvaluationJsonSchema$anchorError.mjs";
+import InvalidJsonSchema$anchorError from "../../../../errors/InvalidJsonSchema$anchorError.mjs";
+/**
+ * @public
+ */
+export const isAnchor = uri => {
+  /**
+   *  MUST start with a letter ([A-Za-z]) or underscore ("_"), followed by any number of letters,
+   *  digits ([0-9]), hyphens ("-"), underscores ("_"), and periods (".").
+   *
+   *  https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.8.2.2
+   */
+  return /^[A-Za-z_][A-Za-z_0-9.-]*$/.test(uri);
+};
+
+/**
+ * @public
+ */
+export const uriToAnchor = uri => {
+  const hash = getHash(uri);
+  return trimCharsStart('#', hash);
+};
+
+/**
+ * @public
+ */
+export const parse = anchor => {
+  if (!isAnchor(anchor)) {
+    throw new InvalidJsonSchema$anchorError(anchor);
+  }
+  return anchor;
+};
+
+/**
+ * Evaluates JSON Schema $anchor against ApiDOM fragment.
+ * @public
+ */
+export const evaluate = (anchor, element) => {
+  const token = parse(anchor);
+  const resultPath = find(element,
+  // @ts-ignore
+  path => isJSONSchemaElement(path.node) && toValue(path.node.$anchor) === token);
+  if (isUndefined(resultPath)) {
+    throw new EvaluationJsonSchema$anchorError(`Evaluation failed on token: "${token}"`);
+  }
+  return resultPath.node;
+};
+export { EvaluationJsonSchema$anchorError, InvalidJsonSchema$anchorError };
+export { default as JsonSchema$anchorError } from "../../../../errors/JsonSchema$anchorError.mjs";

package/src/dereference/strategies/openapi-3-1/selectors/$anchor.ts

@@ -0,0 +1,64 @@
+import { trimCharsStart, isUndefined } from 'ramda-adjunct';
+import { Element } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import { find } from '@speclynx/apidom-traverse';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
+
+import { getHash } from '../../../../util/url.ts';
+import EvaluationJsonSchema$anchorError from '../../../../errors/EvaluationJsonSchema$anchorError.ts';
+import InvalidJsonSchema$anchorError from '../../../../errors/InvalidJsonSchema$anchorError.ts';
+
+/**
+ * @public
+ */
+export const isAnchor = (uri: string) => {
+  /**
+   *  MUST start with a letter ([A-Za-z]) or underscore ("_"), followed by any number of letters,
+   *  digits ([0-9]), hyphens ("-"), underscores ("_"), and periods (".").
+   *
+   *  https://json-schema.org/draft/2020-12/json-schema-core.html#rfc.section.8.2.2
+   */
+  return /^[A-Za-z_][A-Za-z_0-9.-]*$/.test(uri);
+};
+
+/**
+ * @public
+ */
+export const uriToAnchor = (uri: string): string => {
+  const hash = getHash(uri);
+  return trimCharsStart('#', hash);
+};
+
+/**
+ * @public
+ */
+export const parse = (anchor: string): string => {
+  if (!isAnchor(anchor)) {
+    throw new InvalidJsonSchema$anchorError(anchor);
+  }
+
+  return anchor;
+};
+
+/**
+ * Evaluates JSON Schema $anchor against ApiDOM fragment.
+ * @public
+ */
+export const evaluate = <T extends Element>(anchor: string, element: T): Element | undefined => {
+  const token = parse(anchor);
+
+  const resultPath = find(
+    element,
+    // @ts-ignore
+    (path) => isJSONSchemaElement(path.node) && toValue(path.node.$anchor) === token,
+  );
+
+  if (isUndefined(resultPath)) {
+    throw new EvaluationJsonSchema$anchorError(`Evaluation failed on token: "${token}"`);
+  }
+
+  return resultPath.node;
+};
+
+export { EvaluationJsonSchema$anchorError, InvalidJsonSchema$anchorError };
+export { default as JsonSchema$anchorError } from '../../../../errors/JsonSchema$anchorError.ts';

package/src/dereference/strategies/openapi-3-1/selectors/uri.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.evaluate = exports.JsonSchemaUriError = void 0;
+var _ramdaAdjunct = require("ramda-adjunct");
+var _apidomTraverse = require("@speclynx/apidom-traverse");
+var _apidomNsJsonSchema = require("@speclynx/apidom-ns-json-schema-2020-12");
+var _apidomJsonPointer = require("@speclynx/apidom-json-pointer");
+var url = _interopRequireWildcard(require("../../../../util/url.cjs"));
+var _EvaluationJsonSchemaUriError = _interopRequireDefault(require("../../../../errors/EvaluationJsonSchemaUriError.cjs"));
+exports.EvaluationJsonSchemaUriError = _EvaluationJsonSchemaUriError.default;
+var _$anchor = require("./$anchor.cjs");
+var _util = require("../util.cjs");
+var _JsonSchemaUriError = _interopRequireDefault(require("../../../../errors/JsonSchemaUriError.cjs"));
+exports.JsonSchemaUriError = _JsonSchemaUriError.default;
+/**
+ * Evaluates JSON Schema $ref containing unknown URI against ApiDOM fragment.
+ * @public
+ */
+const evaluate = (uri, element) => {
+  const {
+    cache
+  } = evaluate;
+  const uriStrippedHash = url.stripHash(uri);
+  const isJSONSchemaElementWith$id = path => (0, _apidomNsJsonSchema.isJSONSchemaElement)(path.node) && typeof path.node.$id !== 'undefined';
+
+  // warm the cache
+  if (!cache.has(element)) {
+    const schemaObjectPaths = (0, _apidomTraverse.filter)(element, isJSONSchemaElementWith$id);
+    cache.set(element, schemaObjectPaths.map(path => path.node));
+  }
+
+  // search for the matching schema
+  const result = cache.get(element).find(e => {
+    const $idBaseURI = (0, _util.resolveSchema$idField)(uriStrippedHash, e);
+    return $idBaseURI === uriStrippedHash;
+  });
+  if ((0, _ramdaAdjunct.isUndefined)(result)) {
+    throw new _EvaluationJsonSchemaUriError.default(`Evaluation failed on URI: "${uri}"`);
+  }
+  if ((0, _$anchor.isAnchor)((0, _$anchor.uriToAnchor)(uri))) {
+    // we're dealing with JSON Schema $anchor here
+    return (0, _$anchor.evaluate)((0, _$anchor.uriToAnchor)(uri), result);
+  }
+  return (0, _apidomJsonPointer.evaluate)(result, _apidomJsonPointer.URIFragmentIdentifier.fromURIReference(uri));
+};
+exports.evaluate = evaluate;
+evaluate.cache = new WeakMap();

package/src/dereference/strategies/openapi-3-1/selectors/uri.mjs

@@ -0,0 +1,42 @@
+import { isUndefined } from 'ramda-adjunct';
+import { filter } from '@speclynx/apidom-traverse';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { URIFragmentIdentifier, evaluate as jsonPointerEvaluate } from '@speclynx/apidom-json-pointer';
+import * as url from "../../../../util/url.mjs";
+import EvaluationJsonSchemaUriError from "../../../../errors/EvaluationJsonSchemaUriError.mjs";
+import { isAnchor, uriToAnchor, evaluate as $anchorEvaluate } from "./$anchor.mjs";
+import { resolveSchema$idField } from "../util.mjs";
+/**
+ * Evaluates JSON Schema $ref containing unknown URI against ApiDOM fragment.
+ * @public
+ */
+export const evaluate = (uri, element) => {
+  const {
+    cache
+  } = evaluate;
+  const uriStrippedHash = url.stripHash(uri);
+  const isJSONSchemaElementWith$id = path => isJSONSchemaElement(path.node) && typeof path.node.$id !== 'undefined';
+
+  // warm the cache
+  if (!cache.has(element)) {
+    const schemaObjectPaths = filter(element, isJSONSchemaElementWith$id);
+    cache.set(element, schemaObjectPaths.map(path => path.node));
+  }
+
+  // search for the matching schema
+  const result = cache.get(element).find(e => {
+    const $idBaseURI = resolveSchema$idField(uriStrippedHash, e);
+    return $idBaseURI === uriStrippedHash;
+  });
+  if (isUndefined(result)) {
+    throw new EvaluationJsonSchemaUriError(`Evaluation failed on URI: "${uri}"`);
+  }
+  if (isAnchor(uriToAnchor(uri))) {
+    // we're dealing with JSON Schema $anchor here
+    return $anchorEvaluate(uriToAnchor(uri), result);
+  }
+  return jsonPointerEvaluate(result, URIFragmentIdentifier.fromURIReference(uri));
+};
+evaluate.cache = new WeakMap();
+export { EvaluationJsonSchemaUriError };
+export { default as JsonSchemaUriError } from "../../../../errors/JsonSchemaUriError.mjs";

package/src/dereference/strategies/openapi-3-1/selectors/uri.ts

@@ -0,0 +1,54 @@
+import { isUndefined } from 'ramda-adjunct';
+import { Element } from '@speclynx/apidom-datamodel';
+import { filter, type Path } from '@speclynx/apidom-traverse';
+import { isJSONSchemaElement, JSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
+import {
+  URIFragmentIdentifier,
+  evaluate as jsonPointerEvaluate,
+} from '@speclynx/apidom-json-pointer';
+
+import * as url from '../../../../util/url.ts';
+import EvaluationJsonSchemaUriError from '../../../../errors/EvaluationJsonSchemaUriError.ts';
+import { isAnchor, uriToAnchor, evaluate as $anchorEvaluate } from './$anchor.ts';
+import { resolveSchema$idField } from '../util.ts';
+
+/**
+ * Evaluates JSON Schema $ref containing unknown URI against ApiDOM fragment.
+ * @public
+ */
+export const evaluate = <T extends Element>(uri: string, element: T): Element | undefined => {
+  const { cache } = evaluate;
+  const uriStrippedHash = url.stripHash(uri);
+  const isJSONSchemaElementWith$id = (path: Path<Element>) =>
+    isJSONSchemaElement(path.node) && typeof (path.node as any).$id !== 'undefined';
+
+  // warm the cache
+  if (!cache.has(element)) {
+    const schemaObjectPaths = filter(element, isJSONSchemaElementWith$id);
+    cache.set(
+      element,
+      schemaObjectPaths.map((path) => path.node),
+    );
+  }
+
+  // search for the matching schema
+  const result = cache.get(element).find((e: JSONSchemaElement) => {
+    const $idBaseURI = resolveSchema$idField(uriStrippedHash, e);
+    return $idBaseURI === uriStrippedHash;
+  });
+
+  if (isUndefined(result)) {
+    throw new EvaluationJsonSchemaUriError(`Evaluation failed on URI: "${uri}"`);
+  }
+
+  if (isAnchor(uriToAnchor(uri))) {
+    // we're dealing with JSON Schema $anchor here
+    return $anchorEvaluate(uriToAnchor(uri), result);
+  }
+
+  return jsonPointerEvaluate(result, URIFragmentIdentifier.fromURIReference(uri));
+};
+evaluate.cache = new WeakMap();
+
+export { EvaluationJsonSchemaUriError };
+export { default as JsonSchemaUriError } from '../../../../errors/JsonSchemaUriError.ts';