@speclynx/apidom-reference 4.0.2 → 4.0.3

package/src/parse/parsers/asyncapi-yaml-2/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomParserAdapterAsyncapiYaml = require("@speclynx/apidom-parser-adapter-asyncapi-yaml-2");
+var _ParserError = _interopRequireDefault(require("../../../errors/ParserError.cjs"));
+var _Parser = _interopRequireDefault(require("../Parser.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AsyncAPIYAML2Parser extends _Parser.default {
+  refractorOpts;
+  constructor(options) {
+    const {
+      fileExtensions = [],
+      mediaTypes = _apidomParserAdapterAsyncapiYaml.mediaTypes,
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'asyncapi-yaml-2',
+      fileExtensions,
+      mediaTypes
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return (0, _apidomParserAdapterAsyncapiYaml.detect)(file.toString());
+    }
+    return false;
+  }
+  async parse(file) {
+    const source = file.toString();
+    try {
+      const parserOpts = (0, _ramda.pick)(['sourceMap', 'style', 'strict', 'refractorOpts'], this);
+      return await (0, _apidomParserAdapterAsyncapiYaml.parse)(source, parserOpts);
+    } catch (error) {
+      throw new _ParserError.default(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = AsyncAPIYAML2Parser;

package/src/parse/parsers/asyncapi-yaml-2/index.mjs

@@ -0,0 +1,48 @@
+import { pick } from 'ramda';
+import { parse, mediaTypes as AsyncAPI2MediaTypes, detect } from '@speclynx/apidom-parser-adapter-asyncapi-yaml-2';
+import ParserError from "../../../errors/ParserError.mjs";
+import Parser from "../Parser.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AsyncAPIYAML2Parser extends Parser {
+  refractorOpts;
+  constructor(options) {
+    const {
+      fileExtensions = [],
+      mediaTypes = AsyncAPI2MediaTypes,
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'asyncapi-yaml-2',
+      fileExtensions,
+      mediaTypes
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return detect(file.toString());
+    }
+    return false;
+  }
+  async parse(file) {
+    const source = file.toString();
+    try {
+      const parserOpts = pick(['sourceMap', 'style', 'strict', 'refractorOpts'], this);
+      return await parse(source, parserOpts);
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default AsyncAPIYAML2Parser;

package/src/parse/parsers/asyncapi-yaml-2/index.ts

@@ -0,0 +1,58 @@
+import { pick } from 'ramda';
+import { ParseResultElement } from '@speclynx/apidom-datamodel';
+import {
+  parse,
+  mediaTypes as AsyncAPI2MediaTypes,
+  detect,
+} from '@speclynx/apidom-parser-adapter-asyncapi-yaml-2';
+
+import ParserError from '../../../errors/ParserError.ts';
+import Parser, { ParserOptions } from '../Parser.ts';
+import File from '../../../File.ts';
+
+export type { default as Parser, ParserOptions } from '../Parser.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+
+/**
+ * @public
+ */
+export interface AsyncAPIYAML2ParserOptions extends Omit<ParserOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class AsyncAPIYAML2Parser extends Parser {
+  public refractorOpts!: object;
+
+  constructor(options?: AsyncAPIYAML2ParserOptions) {
+    const { fileExtensions = [], mediaTypes = AsyncAPI2MediaTypes, ...rest } = options ?? {};
+
+    super({ ...rest, name: 'asyncapi-yaml-2', fileExtensions, mediaTypes });
+  }
+
+  async canParse(file: File): Promise<boolean> {
+    const hasSupportedFileExtension =
+      this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return detect(file.toString());
+    }
+    return false;
+  }
+
+  async parse(file: File): Promise<ParseResultElement> {
+    const source = file.toString();
+
+    try {
+      const parserOpts = pick(['sourceMap', 'style', 'strict', 'refractorOpts'], this);
+      return await parse(source, parserOpts);
+    } catch (error: unknown) {
+      throw new ParserError(`Error parsing "${file.uri}"`, { cause: error });
+    }
+  }
+}
+
+export default AsyncAPIYAML2Parser;

package/src/parse/parsers/binary/index-browser.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _ParserError = _interopRequireDefault(require("../../../errors/ParserError.cjs"));
+var _Parser = _interopRequireDefault(require("../Parser.cjs"));
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+
+/**
+ * @public
+ */
+class BinaryParser extends _Parser.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'binary'
+    });
+  }
+  canParse(file) {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+  parse(file) {
+    try {
+      /**
+       * More information about binary strings and btoa function in following link:
+       *   https://developer.mozilla.org/en-US/docs/Web/API/btoa
+       *
+       * @example
+       * ArrayBuffer to base64 conversion:
+       *
+       * const binaryString = String.fromCharCode.apply(null, file.data);
+       * base64String = btoa(binaryString);
+       */
+      const binaryString = unescape(encodeURIComponent(file.toString()));
+      const base64String = btoa(binaryString);
+      const parseResultElement = new _apidomDatamodel.ParseResultElement();
+      if (base64String.length !== 0) {
+        const base64StringElement = new _apidomDatamodel.StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+      return parseResultElement;
+    } catch (error) {
+      throw new _ParserError.default(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = BinaryParser;

package/src/parse/parsers/binary/index-browser.mjs

@@ -0,0 +1,50 @@
+import { ParseResultElement, StringElement } from '@speclynx/apidom-datamodel';
+import ParserError from "../../../errors/ParserError.mjs";
+import Parser from "../Parser.mjs";
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+/**
+ * @public
+ */
+class BinaryParser extends Parser {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'binary'
+    });
+  }
+  canParse(file) {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+  parse(file) {
+    try {
+      /**
+       * More information about binary strings and btoa function in following link:
+       *   https://developer.mozilla.org/en-US/docs/Web/API/btoa
+       *
+       * @example
+       * ArrayBuffer to base64 conversion:
+       *
+       * const binaryString = String.fromCharCode.apply(null, file.data);
+       * base64String = btoa(binaryString);
+       */
+      const binaryString = unescape(encodeURIComponent(file.toString()));
+      const base64String = btoa(binaryString);
+      const parseResultElement = new ParseResultElement();
+      if (base64String.length !== 0) {
+        const base64StringElement = new StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+      return parseResultElement;
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default BinaryParser;

package/src/parse/parsers/binary/index-browser.ts

@@ -0,0 +1,60 @@
+import { ParseResultElement, StringElement } from '@speclynx/apidom-datamodel';
+
+import ParserError from '../../../errors/ParserError.ts';
+import Parser, { ParserOptions } from '../Parser.ts';
+import File from '../../../File.ts';
+
+export type { default as Parser, ParserOptions } from '../Parser.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+
+export interface BinaryParserOptions extends Omit<ParserOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class BinaryParser extends Parser {
+  constructor(options?: BinaryParserOptions) {
+    super({ ...(options ?? {}), name: 'binary' });
+  }
+
+  canParse(file: File): boolean {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+
+  parse(file: File): ParseResultElement {
+    try {
+      /**
+       * More information about binary strings and btoa function in following link:
+       *   https://developer.mozilla.org/en-US/docs/Web/API/btoa
+       *
+       * @example
+       * ArrayBuffer to base64 conversion:
+       *
+       * const binaryString = String.fromCharCode.apply(null, file.data);
+       * base64String = btoa(binaryString);
+       */
+      const binaryString = unescape(encodeURIComponent(file.toString()));
+      const base64String = btoa(binaryString);
+
+      const parseResultElement = new ParseResultElement();
+
+      if (base64String.length !== 0) {
+        const base64StringElement = new StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+
+      return parseResultElement;
+    } catch (error: unknown) {
+      throw new ParserError(`Error parsing "${file.uri}"`, { cause: error });
+    }
+  }
+}
+
+export default BinaryParser;

package/src/parse/parsers/binary/index-node.cjs

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _nodeBuffer = require("node:buffer");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _ParserError = _interopRequireDefault(require("../../../errors/ParserError.cjs"));
+var _Parser = _interopRequireDefault(require("../Parser.cjs"));
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+
+/**
+ * @public
+ */
+class BinaryParser extends _Parser.default {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'binary'
+    });
+  }
+  canParse(file) {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+  parse(file) {
+    let base64String;
+    try {
+      base64String = _nodeBuffer.Buffer.from(file.data).toString('base64');
+    } catch {
+      base64String = _nodeBuffer.Buffer.from(file.toString()).toString('base64');
+    }
+    try {
+      const parseResultElement = new _apidomDatamodel.ParseResultElement();
+      if (base64String.length !== 0) {
+        const base64StringElement = new _apidomDatamodel.StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+      return parseResultElement;
+    } catch (error) {
+      throw new _ParserError.default(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = BinaryParser;

package/src/parse/parsers/binary/index-node.mjs

@@ -0,0 +1,45 @@
+import { Buffer } from 'node:buffer';
+import { ParseResultElement, StringElement } from '@speclynx/apidom-datamodel';
+import ParserError from "../../../errors/ParserError.mjs";
+import Parser from "../Parser.mjs";
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+/**
+ * @public
+ */
+class BinaryParser extends Parser {
+  constructor(options) {
+    super({
+      ...(options ?? {}),
+      name: 'binary'
+    });
+  }
+  canParse(file) {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+  parse(file) {
+    let base64String;
+    try {
+      base64String = Buffer.from(file.data).toString('base64');
+    } catch {
+      base64String = Buffer.from(file.toString()).toString('base64');
+    }
+    try {
+      const parseResultElement = new ParseResultElement();
+      if (base64String.length !== 0) {
+        const base64StringElement = new StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+      return parseResultElement;
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default BinaryParser;

package/src/parse/parsers/binary/index-node.ts

@@ -0,0 +1,57 @@
+import { Buffer } from 'node:buffer';
+import { ParseResultElement, StringElement } from '@speclynx/apidom-datamodel';
+
+import ParserError from '../../../errors/ParserError.ts';
+import Parser, { ParserOptions } from '../Parser.ts';
+import File from '../../../File.ts';
+
+export type { default as Parser, ParserOptions } from '../Parser.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+
+/**
+ * Everything that is not recognized by other parsers will be considered by this parser
+ * as a binary data and will be encoded to Base64 format.
+ * @public
+ */
+
+export interface BinaryParserOptions extends Omit<ParserOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class BinaryParser extends Parser {
+  constructor(options?: BinaryParserOptions) {
+    super({ ...(options ?? {}), name: 'binary' });
+  }
+
+  canParse(file: File): boolean {
+    return this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+  }
+
+  parse(file: File): ParseResultElement {
+    let base64String: string;
+
+    try {
+      type BufferData = Parameters<typeof Buffer.from>[0];
+      base64String = Buffer.from(file.data as BufferData).toString('base64');
+    } catch {
+      base64String = Buffer.from(file.toString()).toString('base64');
+    }
+
+    try {
+      const parseResultElement = new ParseResultElement();
+
+      if (base64String.length !== 0) {
+        const base64StringElement = new StringElement(base64String);
+        base64StringElement.classes.push('result');
+        parseResultElement.push(base64StringElement);
+      }
+
+      return parseResultElement;
+    } catch (error: unknown) {
+      throw new ParserError(`Error parsing "${file.uri}"`, { cause: error });
+    }
+  }
+}
+
+export default BinaryParser;

package/src/parse/parsers/json/index.cjs

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomParserAdapterJson = require("@speclynx/apidom-parser-adapter-json");
+var _ParserError = _interopRequireDefault(require("../../../errors/ParserError.cjs"));
+var _Parser = _interopRequireDefault(require("../Parser.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class JSONParser extends _Parser.default {
+  constructor(options) {
+    const {
+      fileExtensions = [],
+      mediaTypes = _apidomParserAdapterJson.mediaTypes,
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'json',
+      fileExtensions,
+      mediaTypes
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return (0, _apidomParserAdapterJson.detect)(file.toString());
+    }
+    return false;
+  }
+  async parse(file) {
+    const source = file.toString();
+    try {
+      const parserOpts = (0, _ramda.pick)(['sourceMap', 'style', 'strict'], this);
+      return await (0, _apidomParserAdapterJson.parse)(source, parserOpts);
+    } catch (error) {
+      throw new _ParserError.default(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+var _default = exports.default = JSONParser;

package/src/parse/parsers/json/index.mjs

@@ -0,0 +1,47 @@
+import { pick } from 'ramda';
+import { parse, mediaTypes as JSONMediaTypes, detect } from '@speclynx/apidom-parser-adapter-json';
+import ParserError from "../../../errors/ParserError.mjs";
+import Parser from "../Parser.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class JSONParser extends Parser {
+  constructor(options) {
+    const {
+      fileExtensions = [],
+      mediaTypes = JSONMediaTypes,
+      ...rest
+    } = options ?? {};
+    super({
+      ...rest,
+      name: 'json',
+      fileExtensions,
+      mediaTypes
+    });
+  }
+  async canParse(file) {
+    const hasSupportedFileExtension = this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return detect(file.toString());
+    }
+    return false;
+  }
+  async parse(file) {
+    const source = file.toString();
+    try {
+      const parserOpts = pick(['sourceMap', 'style', 'strict'], this);
+      return await parse(source, parserOpts);
+    } catch (error) {
+      throw new ParserError(`Error parsing "${file.uri}"`, {
+        cause: error
+      });
+    }
+  }
+}
+export default JSONParser;

package/src/parse/parsers/json/index.ts

@@ -0,0 +1,52 @@
+import { pick } from 'ramda';
+import { ParseResultElement } from '@speclynx/apidom-datamodel';
+import { parse, mediaTypes as JSONMediaTypes, detect } from '@speclynx/apidom-parser-adapter-json';
+
+import ParserError from '../../../errors/ParserError.ts';
+import Parser, { ParserOptions } from '../Parser.ts';
+import File from '../../../File.ts';
+
+export type { default as Parser, ParserOptions } from '../Parser.ts';
+export type { default as File, FileOptions } from '../../../File.ts';
+
+/**
+ * @public
+ */
+export interface JSONParserOptions extends Omit<ParserOptions, 'name'> {}
+
+/**
+ * @public
+ */
+class JSONParser extends Parser {
+  constructor(options?: JSONParserOptions) {
+    const { fileExtensions = [], mediaTypes = JSONMediaTypes, ...rest } = options ?? {};
+
+    super({ ...rest, name: 'json', fileExtensions, mediaTypes });
+  }
+
+  async canParse(file: File): Promise<boolean> {
+    const hasSupportedFileExtension =
+      this.fileExtensions.length === 0 ? true : this.fileExtensions.includes(file.extension);
+    const hasSupportedMediaType = this.mediaTypes.includes(file.mediaType);
+
+    if (!hasSupportedFileExtension) return false;
+    if (hasSupportedMediaType) return true;
+    if (!hasSupportedMediaType) {
+      return detect(file.toString());
+    }
+    return false;
+  }
+
+  async parse(file: File): Promise<ParseResultElement> {
+    const source = file.toString();
+
+    try {
+      const parserOpts = pick(['sourceMap', 'style', 'strict'], this);
+      return await parse(source, parserOpts);
+    } catch (error: unknown) {
+      throw new ParserError(`Error parsing "${file.uri}"`, { cause: error });
+    }
+  }
+}
+
+export default JSONParser;