@mat3ra/esse 2024.2.6-0 → 2024.2.19-0

package/.eslintrc.json

@@ -1,3 +1,11 @@
 {
-    "extends": ["@exabyte-io/eslint-config"]
+    "extends": ["@exabyte-io/eslint-config"],
+    "ignorePatterns": ["lib/js/**/*.js", "lib/js/**/*.ts"],
+    "settings": {
+        "import/resolver": {
+          "node": {
+            "extensions": [".js", ".jsx", ".ts", ".tsx"]
+          }
+        }
+    }
 }

package/.mocharc.json

@@ -0,0 +1,5 @@
+{
+    "extension": ["ts"],
+    "spec": "tests/js/**/*.ts",
+    "require": "ts-node/register"
+  }

package/build_schemas.js

@@ -4,23 +4,12 @@
  * downstream consumption to avoid FS calls in the browser.
  */
 const fs = require("fs");
-const path = require("path");
-const mergeAllOf = require("json-schema-merge-allof");
-const { ESSE } = require("./lib/js/esse");
+const JSONSchemasGenerator = require("./lib/js/esse/JSONSchemasGenerator").default;
 
 // JS Modules
 
-const esse = new ESSE();
-const { schemas, wrappedExamples, propertiesManifest, results } = esse;
-const schema = esse.buildGlobalSchema();
-
-fs.writeFileSync(
-    "./schemas.js",
-    "module.exports = {schemas: " + JSON.stringify(schemas) + "}",
-    "utf8",
-);
-
-fs.writeFileSync("./schema.js", "module.exports = " + JSON.stringify(schema), "utf8");
+const generator = new JSONSchemasGenerator();
+const { schemas, wrappedExamples, propertiesManifest, results } = generator;
 
 if (process.env.BUILD_PYTHON_MODULES === "true") {
     // PY Modules
@@ -52,21 +41,7 @@ if (process.env.BUILD_ASSETS !== "true") {
 }
 
 const subfolder = process.env.BUILD_PATH || "./docs/js/";
-schemas.forEach((s) => {
-    let mergedSchema = s;
-    if (process.env.SKIP_MERGE_ALLOF !== "true") {
-        mergedSchema = mergeAllOf(s, {
-            resolvers: { defaultResolver: mergeAllOf.options.resolvers.title },
-        });
-    }
-    const id_as_path = mergedSchema.$id.replace("-", "_");
-    const full_path = `${subfolder}/schema/${id_as_path}.json`;
-    fs.mkdirSync(path.dirname(full_path), { recursive: true });
-    fs.writeFileSync(full_path, JSON.stringify(mergedSchema, null, 4), "utf8");
-});
-wrappedExamples.forEach((e) => {
-    const id_as_path = e.path.replace("-", "_");
-    const full_path = `${subfolder}/example/${id_as_path}.json`;
-    fs.mkdirSync(path.dirname(full_path), { recursive: true });
-    fs.writeFileSync(full_path, JSON.stringify(e.data, null, 4), "utf8");
-});
+const skipMergeAllOff = process.env.SKIP_MERGE_ALLOF === "true";
+
+generator.writeResolvedSchemas(subfolder, skipMergeAllOff);
+generator.writeResolvedExamples(subfolder);

package/compile_ts.ts

@@ -0,0 +1,3 @@
+import compileTS from "./src/js/scripts/compileTs";
+
+compileTS("./lib/js/schema", `./lib/js/types.ts`);

package/example/models_directory/re.json

@@ -1,4 +1,5 @@
 {
+    "name": "regression",
     "categories": {
         "tier1": "st",
         "tier2": "det",

package/example/workflow/subworkflow.json

@@ -12,7 +12,7 @@
     ],
     "units": [
         {
-            "...": "include(unit.json)"
+            "...": "include(unit/execution.json)"
         }
     ]
 }

package/example/workflow.json

@@ -28,7 +28,8 @@
         {
             "_id": "LCthJ6E2QabYCZqf4",
             "flowchartId": "05c362dc27ff1bb98d16fd60",
-            "type": "subworkflow"
+            "type": "subworkflow",
+            "name": "subworkflow unit"
         }
     ]
 }

package/lib/js/esse/JSONSchemasGenerator.d.ts

@@ -0,0 +1,20 @@
+import { JSONSchema, JSONSchemaWithPath } from "./utils";
+interface JSONSchemasGeneratorConfig {
+    schemasDir: string;
+    examplesDir?: string;
+    propertiesManifestDir?: string;
+}
+export default class JSONSchemasGenerator implements JSONSchemasGeneratorConfig {
+    readonly schemas: JSONSchema[];
+    readonly examples?: JSONSchema[];
+    readonly wrappedExamples: JSONSchemaWithPath[];
+    readonly propertiesManifest: object;
+    readonly results: object;
+    readonly schemasDir: string;
+    readonly examplesDir?: string;
+    readonly propertiesManifestDir?: string;
+    constructor(config?: JSONSchemasGeneratorConfig);
+    writeResolvedSchemas(subfolder: string, skipMergeAllOff?: boolean): void;
+    writeResolvedExamples(subfolder: string): void;
+}
+export {};

package/lib/js/esse/JSONSchemasGenerator.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable class-methods-use-this */
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const json_schema_merge_allof_1 = __importDefault(require("json-schema-merge-allof"));
+const path_1 = __importDefault(require("path"));
+const settings_1 = require("./settings");
+const utils_1 = require("./utils");
+const DEFAULT_CONFIG = {
+    schemasDir: settings_1.SCHEMAS_DIR,
+    examplesDir: settings_1.EXAMPLES_DIR,
+    propertiesManifestDir: settings_1.PROPERTIES_MANIFEST_PATH,
+};
+class JSONSchemasGenerator {
+    constructor(config = DEFAULT_CONFIG) {
+        this.schemasDir = config.schemasDir;
+        this.examplesDir = config.examplesDir;
+        this.propertiesManifestDir = config.propertiesManifestDir;
+        this.schemas = (0, utils_1.parseIncludeReferenceStatementsByDir)(this.schemasDir);
+        this.wrappedExamples = this.examplesDir
+            ? (0, utils_1.parseIncludeReferenceStatementsByDir)(this.examplesDir, true)
+            : [];
+        this.examples = this.wrappedExamples.map((example) => example.data);
+        this.propertiesManifest = this.propertiesManifestDir
+            ? js_yaml_1.default.load(fs_1.default.readFileSync(this.propertiesManifestDir, "utf-8"))
+            : {};
+        this.results = Object.entries(this.propertiesManifest)
+            .map((k) => (k[1].isResult ? k[0] : null))
+            .filter((x) => x);
+    }
+    writeResolvedSchemas(subfolder, skipMergeAllOff = false) {
+        const schemasFolder = `${subfolder}/schema`;
+        fs_1.default.rmSync(schemasFolder, { recursive: true, force: true });
+        const mergeAllOfConfig = {
+            resolvers: { defaultResolver: json_schema_merge_allof_1.default.options.resolvers.title },
+        };
+        const schemas = this.schemas.map((schema) => {
+            var _a;
+            console.log(`Resolving schema: ${schema.$id}`);
+            const mergedSchema = skipMergeAllOff ? schema : (0, json_schema_merge_allof_1.default)(schema, mergeAllOfConfig);
+            const idAsPath = (_a = mergedSchema.$id) === null || _a === void 0 ? void 0 : _a.replace(/-/g, "_");
+            const fullPath = `${schemasFolder}/${idAsPath}.json`;
+            fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
+            fs_1.default.writeFileSync(fullPath, JSON.stringify(mergedSchema, null, 4), "utf8");
+            return mergedSchema;
+        });
+        fs_1.default.writeFileSync(`${subfolder}/schemas.json`, `${JSON.stringify(schemas)}`);
+    }
+    writeResolvedExamples(subfolder) {
+        const examplesFolder = `${subfolder}/example`;
+        fs_1.default.rmSync(`${examplesFolder}`, { recursive: true, force: true });
+        this.wrappedExamples.forEach((e) => {
+            const idAsPath = e.path.replace(/-/g, "_");
+            const fullPath = `${examplesFolder}/${idAsPath}.json`;
+            fs_1.default.mkdirSync(path_1.default.dirname(fullPath), { recursive: true });
+            fs_1.default.writeFileSync(fullPath, JSON.stringify(e.data, null, 4), "utf8");
+        });
+    }
+}
+exports.default = JSONSchemasGenerator;

package/lib/js/esse/JSONSchemasInterface.d.ts

@@ -0,0 +1,31 @@
+import { JSONSchema } from "./utils";
+export type JSONSchemasInterfaceQuery = {
+    [key in keyof JSONSchema]: {
+        $regex: string;
+    };
+};
+export default class JSONSchemasInterface {
+    static schemasCache: Map<string, import("json-schema").JSONSchema7>;
+    static setSchemas(schema: JSONSchema[]): void;
+    static addSchema(schema: JSONSchema): void;
+    static getSchemaById(schemaId: string): import("json-schema").JSONSchema7 | undefined;
+    /**
+     * @example <caption>Search by $id regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   $id: {
+     *     $regex: 'software-application'
+     *   }
+     * })
+     *
+     * @example <caption>Search by $id and title regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   $id: {
+     *     $regex: 'software-application'
+     *   },
+     *   title: {
+     *     $regex: 'application'
+     *   }
+     * })
+     */
+    static matchSchema(query: JSONSchemasInterfaceQuery): import("json-schema").JSONSchema7 | undefined;
+}

package/lib/js/esse/JSONSchemasInterface.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class JSONSchemasInterface {
+    static setSchemas(schema) {
+        schema.forEach((schema) => this.addSchema(schema));
+    }
+    static addSchema(schema) {
+        if (schema.$id) {
+            this.schemasCache.set(schema.$id, schema);
+        }
+    }
+    static getSchemaById(schemaId) {
+        return this.schemasCache.get(schemaId);
+    }
+    /**
+     * @example <caption>Search by $id regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   $id: {
+     *     $regex: 'software-application'
+     *   }
+     * })
+     *
+     * @example <caption>Search by $id and title regex</caption>
+     * JSONSchemasInterface.matchSchema({
+     *   $id: {
+     *     $regex: 'software-application'
+     *   },
+     *   title: {
+     *     $regex: 'application'
+     *   }
+     * })
+     */
+    static matchSchema(query) {
+        const searchFields = Object.keys(query);
+        return Array.from(this.schemasCache.values()).find((schema) => {
+            return searchFields.every((field) => {
+                const queryField = query[field];
+                const schemaField = schema[field];
+                if (!queryField || typeof schemaField !== "string") {
+                    return;
+                }
+                return new RegExp(queryField.$regex).test(schemaField);
+            });
+        });
+    }
+}
+exports.default = JSONSchemasInterface;
+JSONSchemasInterface.schemasCache = new Map();

package/lib/js/esse/JSONSchemasInterfaceServer.d.ts

@@ -0,0 +1,9 @@
+import { SchemaObject } from "ajv";
+import JSONSchemasInterface from "./JSONSchemasInterface";
+export declare function readSchemaFolderSync(folderPath: string): SchemaObject[];
+export default class JSONSchemasInterfaceServer extends JSONSchemasInterface {
+    static schemaFolder: string;
+    static setSchemaFolder(schemaFolder: string): void;
+    static readSchemaFolder(): void;
+    static getSchemaById(schemaId: string): import("json-schema").JSONSchema7 | undefined;
+}

package/lib/js/esse/JSONSchemasInterfaceServer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSchemaFolderSync = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const filesystem_1 = require("../utils/filesystem");
+const JSONSchemasInterface_1 = __importDefault(require("./JSONSchemasInterface"));
+function readSchemaFolderSync(folderPath) {
+    const schemas = [];
+    (0, filesystem_1.walkDirSync)(folderPath, (filePath) => {
+        if (path_1.default.extname(filePath) !== ".json") {
+            return;
+        }
+        const schema = JSON.parse(fs_1.default.readFileSync(filePath).toString());
+        schemas.push(schema);
+    });
+    return schemas;
+}
+exports.readSchemaFolderSync = readSchemaFolderSync;
+class JSONSchemasInterfaceServer extends JSONSchemasInterface_1.default {
+    static setSchemaFolder(schemaFolder) {
+        if (this.schemaFolder !== schemaFolder) {
+            this.schemaFolder = schemaFolder;
+            this.readSchemaFolder();
+        }
+    }
+    static readSchemaFolder() {
+        const schemas = readSchemaFolderSync(this.schemaFolder);
+        schemas.forEach((schema) => {
+            if (schema.$id) {
+                this.schemasCache.set(schema.$id, schema);
+            }
+        });
+    }
+    static getSchemaById(schemaId) {
+        if (this.schemasCache.size === 0) {
+            this.readSchemaFolder();
+        }
+        return super.getSchemaById(schemaId);
+    }
+}
+exports.default = JSONSchemasInterfaceServer;
+JSONSchemasInterfaceServer.schemaFolder = path_1.default.resolve(__dirname, "./../schema");

package/lib/js/esse/schemaUtils.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchema, JSONSchemaDefinition } from "./utils";
+export type MapSchema = (prop: JSONSchemaDefinition) => JSONSchemaDefinition | undefined;
+export declare function mapObjectDeep(object: JSONSchemaDefinition, mapValue: MapSchema): JSONSchema;
+export declare function mapObjectDeep(object: JSONSchemaDefinition[], mapValue: MapSchema): JSONSchema[];

package/lib/js/esse/schemaUtils.js

@@ -1,78 +1,17 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.buildSchemaDefinitions = buildSchemaDefinitions;
-exports.makeFlatSchemaKey = makeFlatSchemaKey;
-exports.makeFlatSchemaRef = makeFlatSchemaRef;
-exports.mapObjectDeep = mapObjectDeep;
-
-var _keyBy = _interopRequireDefault(require("lodash/keyBy"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapObjectDeep = void 0;
 function mapObjectDeep(object, mapValue) {
-  if (_typeof(object) !== "object") {
-    return object;
-  }
-
-  if (Array.isArray(object)) {
-    return object.map(function (innerValue) {
-      return mapValue(innerValue) || mapObjectDeep(innerValue, mapValue);
+    if (typeof object !== "object" || object === null) {
+        return object;
+    }
+    if (Array.isArray(object)) {
+        return object.map((innerValue) => mapObjectDeep(innerValue, mapValue));
+    }
+    const mappedObject = mapValue(object) || object;
+    const entries = Object.entries(mappedObject).map(([key, value]) => {
+        return [key, mapObjectDeep(value, mapValue)];
     });
-  }
-
-  var entries = Object.entries(object).map(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        value = _ref2[1];
-
-    var res = mapValue(value);
-    return [key, res === undefined ? mapObjectDeep(value, mapValue) : res];
-  });
-  return Object.fromEntries(entries);
-}
-
-function makeFlatSchemaKey(schemaId) {
-  return schemaId.replace(/[^a-zA-Z-]/g, ":");
-}
-
-function makeFlatSchemaRef(schemaId) {
-  return {
-    $ref: "#/definitions/".concat(makeFlatSchemaKey(schemaId))
-  };
+    return Object.fromEntries(entries);
 }
-
-function buildSchemaDefinitions(originalSchemas) {
-  var schemas = originalSchemas.map(function (schema) {
-    return mapObjectDeep(schema, function (value) {
-      if (_typeof(value) === "object" && value.$id) {
-        return makeFlatSchemaRef(value.$id);
-      }
-
-      if (_typeof(value) === "object" && value.$ref) {
-        // assume value.$ref is a $id
-        return makeFlatSchemaRef(value.$ref);
-      }
-    });
-  });
-  return (0, _keyBy["default"])(schemas, function (_ref3) {
-    var $id = _ref3.$id;
-    return makeFlatSchemaKey($id);
-  });
-}
+exports.mapObjectDeep = mapObjectDeep;

package/lib/js/esse/settings.d.ts

@@ -0,0 +1,3 @@
+export declare const SCHEMAS_DIR: string;
+export declare const EXAMPLES_DIR: string;
+export declare const PROPERTIES_MANIFEST_PATH: string;

package/lib/js/esse/settings.js

@@ -1,22 +1,10 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SCHEMAS_DIR = exports.PROPERTIES_MANIFEST_PATH = exports.EXAMPLES_DIR = void 0;
-
-var _path = _interopRequireDefault(require("path"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-var SCHEMAS_DIR = _path["default"].resolve(__dirname, "../../../schema");
-
-exports.SCHEMAS_DIR = SCHEMAS_DIR;
-
-var EXAMPLES_DIR = _path["default"].resolve(__dirname, "../../../example");
-
-exports.EXAMPLES_DIR = EXAMPLES_DIR;
-
-var PROPERTIES_MANIFEST_PATH = _path["default"].resolve(__dirname, "../../../manifest/properties.yaml");
-
-exports.PROPERTIES_MANIFEST_PATH = PROPERTIES_MANIFEST_PATH;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPERTIES_MANIFEST_PATH = exports.EXAMPLES_DIR = exports.SCHEMAS_DIR = void 0;
+const path_1 = __importDefault(require("path"));
+exports.SCHEMAS_DIR = path_1.default.resolve(__dirname, "../../../schema");
+exports.EXAMPLES_DIR = path_1.default.resolve(__dirname, "../../../example");
+exports.PROPERTIES_MANIFEST_PATH = path_1.default.resolve(__dirname, "../../../manifest/properties.yaml");

package/lib/js/esse/types.d.ts

@@ -0,0 +1,3 @@
+export interface AnyObject {
+    [key: string]: unknown;
+}

package/lib/js/esse/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/js/esse/utils.d.ts

@@ -0,0 +1,14 @@
+import { JSONSchema7, JSONSchema7Definition } from "json-schema";
+export type JSONSchema = JSONSchema7;
+export type JSONSchemaDefinition = JSONSchema7Definition;
+/**
+ * Resolves `include` and `$ref` statements.
+ * @param filePath {String} file to parse.
+ */
+export declare function parseIncludeReferenceStatements(filePath: string): JSONSchema;
+export interface JSONSchemaWithPath {
+    data: JSONSchema;
+    path: string;
+}
+export declare function parseIncludeReferenceStatementsByDir(dirPath: string, wrapInDataAndPath: true): JSONSchemaWithPath[];
+export declare function parseIncludeReferenceStatementsByDir(dirPath: string, wrapInDataAndPath?: false): JSONSchema[];

package/lib/js/esse/utils.js

@@ -1,74 +1,54 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parseIncludeReferenceStatements = parseIncludeReferenceStatements;
-exports.parseIncludeReferenceStatementsByDir = parseIncludeReferenceStatementsByDir;
-
-var _file = _interopRequireDefault(require("file"));
-
-var _jsonSchemaDerefSync = _interopRequireDefault(require("json-schema-deref-sync"));
-
-var _path2 = _interopRequireDefault(require("path"));
-
-var _json_include = require("../json_include");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncludeReferenceStatementsByDir = exports.parseIncludeReferenceStatements = void 0;
+const json_schema_deref_sync_1 = __importDefault(require("json-schema-deref-sync"));
+const path_1 = __importDefault(require("path"));
+const json_include_1 = require("../json_include");
+const filesystem_1 = require("../utils/filesystem");
 /**
  * Resolves `include` and `$ref` statements.
  * @param filePath {String} file to parse.
  */
 function parseIncludeReferenceStatements(filePath) {
-  var jsonResolver = new _json_include.JSONInclude();
-  var parsed = jsonResolver.parseIncludeStatements(filePath);
-
-  var dirPath = _path2["default"].dirname(filePath);
-
-  var dereferenced = (0, _jsonSchemaDerefSync["default"])(parsed, {
-    baseFolder: dirPath
-  }); // handle circular references and use non-dereferenced source
-
-  if (dereferenced instanceof Error && dereferenced.message === "Circular self reference") {
-    dereferenced = parsed;
-  }
-
-  return dereferenced;
+    const jsonResolver = new json_include_1.JSONInclude();
+    const parsed = jsonResolver.parseIncludeStatements(filePath);
+    const dirPath = path_1.default.dirname(filePath);
+    let dereferenced = (0, json_schema_deref_sync_1.default)(parsed, { baseFolder: dirPath, removeIds: true });
+    // handle circular references and use non-dereferenced source
+    if (dereferenced instanceof Error && dereferenced.message === "Circular self reference") {
+        dereferenced = parsed;
+    }
+    return dereferenced;
 }
+exports.parseIncludeReferenceStatements = parseIncludeReferenceStatements;
 /**
  * Resolves `include` and `$ref` statements for all the JSON files inside a given directory.
- * @param dirPath {String} directory to parse.
+ * @param dirPath directory to parse.
  */
-
-
-function parseIncludeReferenceStatementsByDir(dirPath) {
-  var wrapInDataAndPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var data = [];
-
-  var topDir = _path2["default"].resolve(__dirname, "../../../");
-
-  _file["default"].walkSync(dirPath, function (dirPath_, dirs_, files_) {
-    files_.forEach(function (file_) {
-      var filePath = _path2["default"].join(dirPath_, file_);
-
-      if (filePath.endsWith(".json")) {
-        var config = parseIncludeReferenceStatements(filePath);
-
-        if (wrapInDataAndPath) {
-          var _path = _path2["default"].join( // remove leading slashes and "example" from path
-          _path2["default"].dirname(filePath).replace(_path2["default"].join(topDir, "example"), "").replace(/^\/+/, ""), _path2["default"].basename(filePath).replace(".json", ""));
-
-          data.push({
-            data: config,
-            path: _path
-          });
-        } else {
-          data.push(config);
+function parseIncludeReferenceStatementsByDir(dirPath, wrapInDataAndPath = false) {
+    const schemas = [];
+    const schemasWithPath = [];
+    const topDir = path_1.default.resolve(__dirname, "../../../");
+    (0, filesystem_1.walkDirSync)(dirPath, (filePath) => {
+        if (filePath.endsWith(".json")) {
+            const config = parseIncludeReferenceStatements(filePath);
+            if (wrapInDataAndPath) {
+                const _path = path_1.default.join(
+                // remove leading slashes and "example" from path
+                path_1.default
+                    .dirname(filePath)
+                    .replace(path_1.default.join(topDir, "example"), "")
+                    .replace(/^\/+/, ""), path_1.default.basename(filePath).replace(".json", ""));
+                schemasWithPath.push({ data: config, path: _path });
+            }
+            else {
+                schemas.push(config);
+            }
         }
-      }
     });
-  });
-
-  return data;
-}
+    return wrapInDataAndPath ? schemasWithPath : schemas;
+}
+exports.parseIncludeReferenceStatementsByDir = parseIncludeReferenceStatementsByDir;