@speclynx/apidom-reference 4.0.2 → 4.0.3

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

@@ -0,0 +1,88 @@
+import { cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { isAsyncApi2Element, mediaTypes } from '@speclynx/apidom-ns-asyncapi-2';
+import DereferenceStrategy from "../DereferenceStrategy.mjs";
+import Reference from "../../../Reference.mjs";
+import ReferenceSet from "../../../ReferenceSet.mjs";
+import AsyncAPI2DereferenceVisitor from "./visitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AsyncAPI2DereferenceStrategy extends DereferenceStrategy {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'asyncapi-2'
+    });
+  }
+  canDereference(file) {
+    // assert by media type
+    if (file.mediaType !== 'text/plain') {
+      return mediaTypes.includes(file.mediaType);
+    }
+
+    // assert by inspecting ApiDOM
+    return isAsyncApi2Element(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(ref => ref.uri === file.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 AsyncAPI2DereferenceVisitor({
+      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 a 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 { AsyncAPI2DereferenceVisitor };
+export default AsyncAPI2DereferenceStrategy;

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

@@ -0,0 +1,133 @@
+import { Element, cloneDeep } from '@speclynx/apidom-datamodel';
+import { traverseAsync } from '@speclynx/apidom-traverse';
+import { isAsyncApi2Element, mediaTypes } from '@speclynx/apidom-ns-asyncapi-2';
+
+import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy.ts';
+import File from '../../../File.ts';
+import Reference from '../../../Reference.ts';
+import ReferenceSet from '../../../ReferenceSet.ts';
+import AsyncAPI2DereferenceVisitor 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 { AsyncAPI2DereferenceVisitorOptions } 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 AsyncAPI2DeferenceStrategyOptions extends Omit<
+  DereferenceStrategyOptions,
+  'name'
+> {}
+
+/**
+ * @public
+ */
+class AsyncAPI2DereferenceStrategy extends DereferenceStrategy {
+  constructor(options?: AsyncAPI2DeferenceStrategyOptions) {
+    super({ ...(options ?? {}), name: 'asyncapi-2' });
+  }
+
+  canDereference(file: File): boolean {
+    // assert by media type
+    if (file.mediaType !== 'text/plain') {
+      return mediaTypes.includes(file.mediaType);
+    }
+
+    // assert by inspecting ApiDOM
+    return isAsyncApi2Element(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: 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((ref) => ref.uri === file.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 AsyncAPI2DereferenceVisitor({ 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 a 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 { AsyncAPI2DereferenceVisitor };
+export default AsyncAPI2DereferenceStrategy;