@speclynx/apidom-ns-json-schema-draft-4 1.12.1

package/src/refractor/specification.mjs

@@ -0,0 +1,177 @@
+import FallbackVisitor from "./visitors/FallbackVisitor.mjs";
+import JSONSchemaVisitor from "./visitors/json-schema/index.mjs";
+import JSONSchemaItemsVisitor from "./visitors/json-schema/ItemsVisitor.mjs";
+import JSONSchemaRequiredVisitor from "./visitors/json-schema/RequiredVisitor.mjs";
+import JSONSchemaPropertiesVisitor from "./visitors/json-schema/PropertiesVisitor.mjs";
+import JSONSchemaPatternPropertiesVisitor from "./visitors/json-schema/PatternPropertiesVisitor.mjs";
+import JSONSchemaDependenciesVisitor from "./visitors/json-schema/DependenciesVisitor.mjs";
+import JSONSchemaEnumVisitor from "./visitors/json-schema/EnumVisitor.mjs";
+import JSONSchemaTypeVisitor from "./visitors/json-schema/TypeVisitor.mjs";
+import JSONSchemaAllOfVisitor from "./visitors/json-schema/AllOfVisitor.mjs";
+import JSONSchemaAnyOfVisitor from "./visitors/json-schema/AnyOfVisitor.mjs";
+import JSONSchemaOneOfVisitor from "./visitors/json-schema/OneOfVisitor.mjs";
+import JSONSchemaDefinitionsVisitor from "./visitors/json-schema/DefinitionsVisitor.mjs";
+import JSONSchemaLinksVisitor from "./visitors/json-schema/LinksVisitor.mjs";
+import JSONReferenceVisitor from "./visitors/json-schema/json-reference/index.mjs";
+import JSONReference$RefVisitor from "./visitors/json-schema/json-reference/$RefVisitor.mjs";
+import JSONSchemaOrJSONReferenceVisitor from "./visitors/json-schema/JSONSchemaOrJSONReferenceVisitor.mjs";
+import MediaVisitor from "./visitors/json-schema/media/index.mjs";
+import LinkDescriptionVisitor from "./visitors/json-schema/link-description/index.mjs";
+/**
+ * Specification object allows us to have complete control over visitors
+ * when traversing the ApiDOM.
+ * Specification also allows us to create amended refractors from
+ * existing ones by manipulating it.
+ *
+ * Note: Specification object allows to use absolute internal JSON pointers.
+ * @public
+ */
+const specification = {
+  visitors: {
+    value: FallbackVisitor,
+    JSONSchemaOrJSONReferenceVisitor,
+    document: {
+      objects: {
+        JSONSchema: {
+          $visitor: JSONSchemaVisitor,
+          fixedFields: {
+            // core vocabulary
+            id: {
+              $ref: '#/visitors/value'
+            },
+            $schema: {
+              $ref: '#/visitors/value'
+            },
+            // validation vocabulary
+            // validation keywords for numeric instances (number and integer)
+            multipleOf: {
+              $ref: '#/visitors/value'
+            },
+            maximum: {
+              $ref: '#/visitors/value'
+            },
+            exclusiveMaximum: {
+              $ref: '#/visitors/value'
+            },
+            minimum: {
+              $ref: '#/visitors/value'
+            },
+            exclusiveMinimum: {
+              $ref: '#/visitors/value'
+            },
+            // validation keywords for strings
+            maxLength: {
+              $ref: '#/visitors/value'
+            },
+            minLength: {
+              $ref: '#/visitors/value'
+            },
+            pattern: {
+              $ref: '#/visitors/value'
+            },
+            // validation keywords for arrays
+            additionalItems: JSONSchemaOrJSONReferenceVisitor,
+            items: JSONSchemaItemsVisitor,
+            maxItems: {
+              $ref: '#/visitors/value'
+            },
+            minItems: {
+              $ref: '#/visitors/value'
+            },
+            uniqueItems: {
+              $ref: '#/visitors/value'
+            },
+            // validation keywords for objects
+            maxProperties: {
+              $ref: '#/visitors/value'
+            },
+            minProperties: {
+              $ref: '#/visitors/value'
+            },
+            required: JSONSchemaRequiredVisitor,
+            properties: JSONSchemaPropertiesVisitor,
+            additionalProperties: JSONSchemaOrJSONReferenceVisitor,
+            patternProperties: JSONSchemaPatternPropertiesVisitor,
+            dependencies: JSONSchemaDependenciesVisitor,
+            // validation keywords for any instance type
+            enum: JSONSchemaEnumVisitor,
+            type: JSONSchemaTypeVisitor,
+            allOf: JSONSchemaAllOfVisitor,
+            anyOf: JSONSchemaAnyOfVisitor,
+            oneOf: JSONSchemaOneOfVisitor,
+            not: JSONSchemaOrJSONReferenceVisitor,
+            definitions: JSONSchemaDefinitionsVisitor,
+            // metadata keywords
+            title: {
+              $ref: '#/visitors/value'
+            },
+            description: {
+              $ref: '#/visitors/value'
+            },
+            default: {
+              $ref: '#/visitors/value'
+            },
+            // semantic validation with "format"
+            format: {
+              $ref: '#/visitors/value'
+            },
+            // JSON Hyper-Schema
+            base: {
+              $ref: '#/visitors/value'
+            },
+            links: JSONSchemaLinksVisitor,
+            media: {
+              $ref: '#/visitors/document/objects/Media'
+            },
+            readOnly: {
+              $ref: '#/visitors/value'
+            }
+          }
+        },
+        JSONReference: {
+          $visitor: JSONReferenceVisitor,
+          fixedFields: {
+            $ref: JSONReference$RefVisitor
+          }
+        },
+        Media: {
+          $visitor: MediaVisitor,
+          fixedFields: {
+            binaryEncoding: {
+              $ref: '#/visitors/value'
+            },
+            type: {
+              $ref: '#/visitors/value'
+            }
+          }
+        },
+        LinkDescription: {
+          $visitor: LinkDescriptionVisitor,
+          fixedFields: {
+            href: {
+              $ref: '#/visitors/value'
+            },
+            rel: {
+              $ref: '#/visitors/value'
+            },
+            title: {
+              $ref: '#/visitors/value'
+            },
+            targetSchema: JSONSchemaOrJSONReferenceVisitor,
+            mediaType: {
+              $ref: '#/visitors/value'
+            },
+            method: {
+              $ref: '#/visitors/value'
+            },
+            encType: {
+              $ref: '#/visitors/value'
+            },
+            schema: JSONSchemaOrJSONReferenceVisitor
+          }
+        }
+      }
+    }
+  }
+};
+export default specification;

package/src/refractor/toolbox.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var jsonSchemaDraft4Predicates = _interopRequireWildcard(require("../predicates.cjs"));
+var _namespace = _interopRequireDefault(require("../namespace.cjs"));
+const createToolbox = () => {
+  const namespace = (0, _apidomCore.createNamespace)(_namespace.default);
+  const predicates = {
+    ...jsonSchemaDraft4Predicates,
+    isStringElement: _apidomCore.isStringElement
+  };
+  return {
+    predicates,
+    namespace
+  };
+};
+var _default = exports.default = createToolbox;

package/src/refractor/toolbox.mjs

@@ -0,0 +1,15 @@
+import { createNamespace, isStringElement } from '@speclynx/apidom-core';
+import * as jsonSchemaDraft4Predicates from "../predicates.mjs";
+import jsonSchemaDraft4Namespace from "../namespace.mjs";
+const createToolbox = () => {
+  const namespace = createNamespace(jsonSchemaDraft4Namespace);
+  const predicates = {
+    ...jsonSchemaDraft4Predicates,
+    isStringElement
+  };
+  return {
+    predicates,
+    namespace
+  };
+};
+export default createToolbox;

package/src/refractor/visitors/FallbackVisitor.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _Visitor = _interopRequireDefault(require("./Visitor.cjs"));
+/**
+ * This visitor is responsible for falling back to current traversed element
+ * Given JSONSchemaVisitor expects ObjectElement to be traversed. If
+ * different Element is provided FallBackVisitor is responsible to assigning
+ * this Element as current element.
+ * @public
+ */
+
+/**
+ * @public
+ */
+class FallbackVisitor extends _Visitor.default {
+  enter(element) {
+    this.element = (0, _apidomCore.cloneDeep)(element);
+    return _apidomCore.BREAK;
+  }
+}
+var _default = exports.default = FallbackVisitor;

package/src/refractor/visitors/FallbackVisitor.mjs

@@ -0,0 +1,19 @@
+import { BREAK, cloneDeep } from '@speclynx/apidom-core';
+import Visitor from "./Visitor.mjs";
+/**
+ * This visitor is responsible for falling back to current traversed element
+ * Given JSONSchemaVisitor expects ObjectElement to be traversed. If
+ * different Element is provided FallBackVisitor is responsible to assigning
+ * this Element as current element.
+ * @public
+ */
+/**
+ * @public
+ */
+class FallbackVisitor extends Visitor {
+  enter(element) {
+    this.element = cloneDeep(element);
+    return BREAK;
+  }
+}
+export default FallbackVisitor;

package/src/refractor/visitors/SpecificationVisitor.cjs

@@ -0,0 +1,74 @@
+"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 _apidomCore = require("@speclynx/apidom-core");
+var _Visitor = _interopRequireDefault(require("./Visitor.cjs"));
+var _FallbackVisitor = _interopRequireDefault(require("./FallbackVisitor.cjs"));
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ * @public
+ */
+
+/**
+ * @public
+ */
+class SpecificationVisitor extends _Visitor.default {
+  specObj;
+  passingOptionsNames = ['specObj', 'parent'];
+  constructor({
+    specObj,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specObj = specObj;
+  }
+  retrievePassingOptions() {
+    return (0, _ramda.pick)(this.passingOptionsNames, this);
+  }
+  retrieveFixedFields(specPath) {
+    const fixedFields = (0, _ramda.path)(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
+    }
+    return [];
+  }
+  retrieveVisitor(specPath) {
+    if ((0, _ramda.pathSatisfies)(_ramdaAdjunct.isFunction, ['visitors', ...specPath], this.specObj)) {
+      return (0, _ramda.path)(['visitors', ...specPath], this.specObj);
+    }
+    return (0, _ramda.path)(['visitors', ...specPath, '$visitor'], this.specObj);
+  }
+  retrieveVisitorInstance(specPath, options = {}) {
+    const passingOpts = this.retrievePassingOptions();
+    const VisitorClz = this.retrieveVisitor(specPath);
+    const visitorOpts = {
+      ...passingOpts,
+      ...options
+    };
+    return new VisitorClz(visitorOpts);
+  }
+  toRefractedElement(specPath, element, options = {}) {
+    /**
+     * This is `Visitor shortcut`: mechanism for short-circuiting the traversal and replacing
+     * it by basic node cloning.
+     *
+     * Visiting the element is equivalent to cloning it  if the prototype of a visitor
+     * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+     * bootstrapping the traversal cycle for fields that don't require any special visiting.
+     */
+    const visitor = this.retrieveVisitorInstance(specPath, options);
+    if (visitor instanceof _FallbackVisitor.default && visitor?.constructor === _FallbackVisitor.default) {
+      return (0, _apidomCore.cloneDeep)(element);
+    }
+    (0, _apidomCore.visit)(element, visitor, options);
+    return visitor.element;
+  }
+}
+var _default = exports.default = SpecificationVisitor;

package/src/refractor/visitors/SpecificationVisitor.mjs

@@ -0,0 +1,68 @@
+import { pathSatisfies, path, pick } from 'ramda';
+import { isFunction } from 'ramda-adjunct';
+import { visit, cloneDeep } from '@speclynx/apidom-core';
+import Visitor from "./Visitor.mjs";
+import FallbackVisitor from "./FallbackVisitor.mjs";
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ * @public
+ */
+/**
+ * @public
+ */
+class SpecificationVisitor extends Visitor {
+  specObj;
+  passingOptionsNames = ['specObj', 'parent'];
+  constructor({
+    specObj,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specObj = specObj;
+  }
+  retrievePassingOptions() {
+    return pick(this.passingOptionsNames, this);
+  }
+  retrieveFixedFields(specPath) {
+    const fixedFields = path(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
+    }
+    return [];
+  }
+  retrieveVisitor(specPath) {
+    if (pathSatisfies(isFunction, ['visitors', ...specPath], this.specObj)) {
+      return path(['visitors', ...specPath], this.specObj);
+    }
+    return path(['visitors', ...specPath, '$visitor'], this.specObj);
+  }
+  retrieveVisitorInstance(specPath, options = {}) {
+    const passingOpts = this.retrievePassingOptions();
+    const VisitorClz = this.retrieveVisitor(specPath);
+    const visitorOpts = {
+      ...passingOpts,
+      ...options
+    };
+    return new VisitorClz(visitorOpts);
+  }
+  toRefractedElement(specPath, element, options = {}) {
+    /**
+     * This is `Visitor shortcut`: mechanism for short-circuiting the traversal and replacing
+     * it by basic node cloning.
+     *
+     * Visiting the element is equivalent to cloning it  if the prototype of a visitor
+     * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+     * bootstrapping the traversal cycle for fields that don't require any special visiting.
+     */
+    const visitor = this.retrieveVisitorInstance(specPath, options);
+    if (visitor instanceof FallbackVisitor && visitor?.constructor === FallbackVisitor) {
+      return cloneDeep(element);
+    }
+    visit(element, visitor, options);
+    return visitor.element;
+  }
+}
+export default SpecificationVisitor;

package/src/refractor/visitors/Visitor.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Visitor {
+  element;
+  constructor(options) {
+    Object.assign(this, options);
+  }
+  copyMetaAndAttributes(from, to) {
+    if (from.meta.length > 0 || to.meta.length > 0) {
+      to.meta = (0, _apidomCore.deepmerge)(to.meta, from.meta);
+      if ((0, _apidomCore.hasElementSourceMap)(from)) {
+        // avoid deep merging of source maps
+        to.meta.set('sourceMap', from.meta.get('sourceMap'));
+      }
+    }
+    if (from.attributes.length > 0 || from.meta.length > 0) {
+      to.attributes = (0, _apidomCore.deepmerge)(to.attributes, from.attributes);
+    }
+  }
+}
+var _default = exports.default = Visitor;

package/src/refractor/visitors/Visitor.mjs

@@ -0,0 +1,28 @@
+import { hasElementSourceMap, deepmerge } from '@speclynx/apidom-core';
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class Visitor {
+  element;
+  constructor(options) {
+    Object.assign(this, options);
+  }
+  copyMetaAndAttributes(from, to) {
+    if (from.meta.length > 0 || to.meta.length > 0) {
+      to.meta = deepmerge(to.meta, from.meta);
+      if (hasElementSourceMap(from)) {
+        // avoid deep merging of source maps
+        to.meta.set('sourceMap', from.meta.get('sourceMap'));
+      }
+    }
+    if (from.attributes.length > 0 || from.meta.length > 0) {
+      to.attributes = deepmerge(to.attributes, from.attributes);
+    }
+  }
+}
+export default Visitor;

package/src/refractor/visitors/generics/AlternatingVisitor.cjs

@@ -0,0 +1,42 @@
+"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 _apidomCore = require("@speclynx/apidom-core");
+var _SpecificationVisitor = _interopRequireDefault(require("../SpecificationVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class AlternatingVisitor extends _SpecificationVisitor.default {
+  alternator;
+  constructor({
+    alternator,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.alternator = alternator;
+  }
+  enter(element) {
+    const functions = this.alternator.map(({
+      predicate,
+      specPath
+    }) => (0, _ramda.ifElse)(predicate, (0, _ramda.always)(specPath), _ramdaAdjunct.stubUndefined));
+    const specPath = (0, _ramdaAdjunct.dispatch)(functions)(element);
+    this.element = this.toRefractedElement(specPath, element);
+    return _apidomCore.BREAK;
+  }
+}
+var _default = exports.default = AlternatingVisitor;

package/src/refractor/visitors/generics/AlternatingVisitor.mjs

@@ -0,0 +1,35 @@
+import { ifElse, always } from 'ramda';
+import { dispatch, stubUndefined } from 'ramda-adjunct';
+import { BREAK } from '@speclynx/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class AlternatingVisitor extends SpecificationVisitor {
+  alternator;
+  constructor({
+    alternator,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.alternator = alternator;
+  }
+  enter(element) {
+    const functions = this.alternator.map(({
+      predicate,
+      specPath
+    }) => ifElse(predicate, always(specPath), stubUndefined));
+    const specPath = dispatch(functions)(element);
+    this.element = this.toRefractedElement(specPath, element);
+    return BREAK;
+  }
+}
+export default AlternatingVisitor;

package/src/refractor/visitors/generics/FixedFieldsVisitor.cjs

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomCore = require("@speclynx/apidom-core");
+var _SpecificationVisitor = _interopRequireDefault(require("../SpecificationVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class FixedFieldsVisitor extends _SpecificationVisitor.default {
+  specPath;
+  ignoredFields;
+  constructor({
+    specPath,
+    ignoredFields,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields || [];
+  }
+  ObjectElement(objectElement) {
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      if ((0, _apidomCore.isStringElement)(key) && fields.includes((0, _apidomCore.toValue)(key)) && !this.ignoredFields.includes((0, _apidomCore.toValue)(key))) {
+        const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', (0, _apidomCore.toValue)(key)], value);
+        const newMemberElement = new _apidomCore.MemberElement((0, _apidomCore.cloneDeep)(key), fixedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('fixed-field');
+        this.element.content.push(newMemberElement);
+      } else if (!this.ignoredFields.includes((0, _apidomCore.toValue)(key))) {
+        this.element.content.push((0, _apidomCore.cloneDeep)(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    return _apidomCore.BREAK;
+  }
+}
+var _default = exports.default = FixedFieldsVisitor;

package/src/refractor/visitors/generics/FixedFieldsVisitor.mjs

@@ -0,0 +1,46 @@
+import { isStringElement, MemberElement, BREAK, cloneDeep, toValue } from '@speclynx/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class FixedFieldsVisitor extends SpecificationVisitor {
+  specPath;
+  ignoredFields;
+  constructor({
+    specPath,
+    ignoredFields,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields || [];
+  }
+  ObjectElement(objectElement) {
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      if (isStringElement(key) && fields.includes(toValue(key)) && !this.ignoredFields.includes(toValue(key))) {
+        const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', toValue(key)], value);
+        const newMemberElement = new MemberElement(cloneDeep(key), fixedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('fixed-field');
+        this.element.content.push(newMemberElement);
+      } else if (!this.ignoredFields.includes(toValue(key))) {
+        this.element.content.push(cloneDeep(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    return BREAK;
+  }
+}
+export default FixedFieldsVisitor;

package/src/refractor/visitors/generics/MapVisitor.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramdaAdjunct = require("ramda-adjunct");
+var _PatternedFieldsVisitor = _interopRequireDefault(require("./PatternedFieldsVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class MapVisitor extends _PatternedFieldsVisitor.default {
+  constructor(options) {
+    super(options);
+    this.fieldPatternPredicate = _ramdaAdjunct.isNonEmptyString;
+  }
+}
+var _default = exports.default = MapVisitor;

package/src/refractor/visitors/generics/MapVisitor.mjs

@@ -0,0 +1,15 @@
+import { isNonEmptyString } from 'ramda-adjunct';
+import PatternedFieldsVisitor from "./PatternedFieldsVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class MapVisitor extends PatternedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.fieldPatternPredicate = isNonEmptyString;
+  }
+}
+export default MapVisitor;