@mat3ra/esse 2024.2.6-0 → 2024.2.19-0

package/lib/js/scripts/compileTs.d.ts

@@ -0,0 +1 @@
+export default function compileTS(schemaPath: string, savePath: string): Promise<void>;

package/lib/js/scripts/compileTs.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+const schemaUtils_1 = require("../esse/schemaUtils");
+const filesystem_1 = require("../utils/filesystem");
+/**
+ * By definition, the "compile" function will generate 2 schemas based on the following input:
+ * {
+ *    "title": "schema1",
+ *    "type": "object",
+ *    "properties": {
+ *        "prop": {
+ *             "title": "schema2",
+ *             "type": "string"
+ *        }
+ *    }
+ * }
+ *
+ * Result:
+ * type schema2 = string;
+ *
+ * interface schema1 {
+ *      prop: schema2
+ * }
+ *
+ * To disable this behavior we need to remove "title" property from the "prop":
+ *  {
+ *    "title": "schema1",
+ *    "type": "object",
+ *    "properties": {
+ *        "prop": {
+ *             "type": "string"
+ *        }
+ *    }
+ * }
+ *
+ * New result:
+ * interface schema1 {
+ *      prop: string;
+ * }
+ * @returns Clean schema
+ */
+function cleanSchema(schema) {
+    let firstRun = true;
+    return (0, schemaUtils_1.mapObjectDeep)(schema, (object) => {
+        if (typeof object === "object" && (object === null || object === void 0 ? void 0 : object.title) && !firstRun) {
+            firstRun = false;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { title, $schema, ...restObject } = object;
+            return restObject;
+        }
+        firstRun = false;
+    });
+}
+async function compileTS(schemaPath, savePath) {
+    try {
+        await fs_1.default.promises.unlink(savePath);
+    }
+    catch (err) {
+        console.log("File with types not exists");
+    }
+    await (0, filesystem_1.walkDir)(schemaPath, async (filePath) => {
+        const data = await fs_1.default.promises.readFile(filePath, "utf8");
+        const schema = cleanSchema(JSON.parse(data));
+        console.log(`Compiling Typescript: ${filePath}`);
+        // @ts-ignore
+        const compiledSchema = await (0, json_schema_to_typescript_1.compile)(schema, schema.title || "", {
+            unreachableDefinitions: true,
+            additionalProperties: false,
+            bannerComment: `/** Schema ${filePath} */`,
+        });
+        await fs_1.default.promises.appendFile(savePath, `${compiledSchema} \n`, { flag: "a+" });
+    });
+}
+exports.default = compileTS;

package/lib/js/scripts/createEnumsFromYaml.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/js/scripts/createEnumsFromYaml.js

@@ -1,74 +1,28 @@
 "use strict";
-
-var _fs = _interopRequireDefault(require("fs"));
-
-var _jsYaml = _interopRequireDefault(require("js-yaml"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-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; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const filesystem_1 = require("../utils/filesystem");
 /**
  *  We use YAML files to list enum options which need to be reused in other places.
  *  The format also allows for additional context to the often shortened slugs, such as DOIs.
  *  This script converts the enum lists to JSON files for $ref blocks inside schemas.
  */
-var SCHEMA_DIR = "../../../schema/";
-
-function walkDir(dir, callback) {
-  var subDirs = _fs["default"].readdirSync(dir);
-
-  var _iterator = _createForOfIteratorHelper(subDirs),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var subDir = _step.value;
-
-      var itemPath = _path["default"].join(dir, subDir);
-
-      var stat = _fs["default"].statSync(itemPath);
-
-      if (stat.isDirectory()) {
-        walkDir(itemPath, callback);
-      } else {
-        callback(itemPath);
-      }
+const SCHEMA_DIR = "../../../schema/";
+(0, filesystem_1.walkDir)(SCHEMA_DIR, (filePath) => {
+    if (path_1.default.extname(filePath) !== ".yml") {
+        return;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-}
-
-walkDir(SCHEMA_DIR, function (filePath) {
-  if (_path["default"].extname(filePath) !== ".yml") {
-    return;
-  }
-
-  console.log(filePath);
-  var outFilename = "".concat(_path["default"].basename(filePath, ".yml"), ".json");
-
-  var dirname = _path["default"].dirname(filePath);
-
-  var fileContents = _fs["default"].readFileSync(filePath);
-
-  var obj = _jsYaml["default"].load(fileContents);
-
-  var enumObj = _lodash["default"].mapValues(obj, function (value) {
-    return {
-      "enum": value
-    };
-  });
-
-  _fs["default"].writeFileSync("".concat(_path["default"].join(dirname, outFilename)), "".concat(JSON.stringify(enumObj, null, 4), "\n"));
-});
+    console.log(filePath);
+    const outFilename = `${path_1.default.basename(filePath, ".yml")}.json`;
+    const dirname = path_1.default.dirname(filePath);
+    const fileContents = fs_1.default.readFileSync(filePath);
+    const obj = js_yaml_1.default.load(fileContents.toString());
+    const enumObj = lodash_1.default.mapValues(obj, (value) => ({ enum: value }));
+    fs_1.default.writeFileSync(`${path_1.default.join(dirname, outFilename)}`, `${JSON.stringify(enumObj, null, 4)}\n`);
+});

package/lib/js/scripts/setSchemaIds.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper script.
+ * Applies correct $id to all schemas based on the schema path
+ */
+export default function setSchemaIds(schemaDir: string): void;

package/lib/js/scripts/setSchemaIds.js

@@ -1,156 +1,29 @@
 "use strict";
-
-var _promises = _interopRequireDefault(require("fs/promises"));
-
-var _path = _interopRequireDefault(require("path"));
-
-var _excluded = ["$id"];
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-var SCHEMA_DIR = "../../../schema/";
-
-function walkDir(_x, _x2) {
-  return _walkDir.apply(this, arguments);
-}
-
-function _walkDir() {
-  _walkDir = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(dir, callback) {
-    var subDirs, _iterator, _step, subDir, itemPath, stat;
-
-    return regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            _context2.next = 2;
-            return _promises["default"].readdir(dir);
-
-          case 2:
-            subDirs = _context2.sent;
-            _iterator = _createForOfIteratorHelper(subDirs);
-            _context2.prev = 4;
-
-            _iterator.s();
-
-          case 6:
-            if ((_step = _iterator.n()).done) {
-              _context2.next = 21;
-              break;
-            }
-
-            subDir = _step.value;
-            itemPath = _path["default"].join(dir, subDir);
-            _context2.next = 11;
-            return _promises["default"].stat(itemPath);
-
-          case 11:
-            stat = _context2.sent;
-
-            if (!stat.isDirectory()) {
-              _context2.next = 17;
-              break;
-            }
-
-            _context2.next = 15;
-            return walkDir(itemPath, callback);
-
-          case 15:
-            _context2.next = 19;
-            break;
-
-          case 17:
-            _context2.next = 19;
-            return callback(itemPath);
-
-          case 19:
-            _context2.next = 6;
-            break;
-
-          case 21:
-            _context2.next = 26;
-            break;
-
-          case 23:
-            _context2.prev = 23;
-            _context2.t0 = _context2["catch"](4);
-
-            _iterator.e(_context2.t0);
-
-          case 26:
-            _context2.prev = 26;
-
-            _iterator.f();
-
-            return _context2.finish(26);
-
-          case 29:
-          case "end":
-            return _context2.stop();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const filesystem_1 = require("../utils/filesystem");
+/**
+ * Helper script.
+ * Applies correct $id to all schemas based on the schema path
+ */
+function setSchemaIds(schemaDir) {
+    (0, filesystem_1.walkDirSync)(schemaDir, (filePath) => {
+        if (path_1.default.extname(filePath) !== ".json") {
+            return;
         }
-      }
-    }, _callee2, null, [[4, 23, 26, 29]]);
-  }));
-  return _walkDir.apply(this, arguments);
-}
-
-await walkDir(SCHEMA_DIR, /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(filePath) {
-    var fileContents, _JSON$parse, oldSchemaId, schema, schemaId, newContent;
-
-    return regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            if (!(_path["default"].extname(filePath) !== ".json")) {
-              _context.next = 2;
-              break;
-            }
-
-            return _context.abrupt("return");
-
-          case 2:
-            _context.next = 4;
-            return _promises["default"].readFile(filePath);
-
-          case 4:
-            fileContents = _context.sent;
-            _JSON$parse = JSON.parse(fileContents), oldSchemaId = _JSON$parse.$id, schema = _objectWithoutProperties(_JSON$parse, _excluded);
-            schemaId = filePath.replace(SCHEMA_DIR, "").replace(".json", "").replace(/_/g, "-");
-            newContent = JSON.stringify(_objectSpread({
-              $id: schemaId
-            }, schema), null, 4);
-            _context.next = 10;
-            return _promises["default"].writeFile(filePath, "".concat(newContent, "\n"));
-
-          case 10:
-          case "end":
-            return _context.stop();
+        const fileContents = fs_1.default.readFileSync(filePath);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { $id, ...schema } = JSON.parse(fileContents.toString());
+        const schemaId = filePath.replace(schemaDir, "").replace(".json", "").replace(/_/g, "-");
+        if ($id !== schemaId) {
+            console.log(`Set correct $id: ${filePath}`);
+            const newContent = JSON.stringify({ $id: schemaId, ...schema }, null, 4);
+            fs_1.default.writeFileSync(filePath, `${newContent}\n`);
         }
-      }
-    }, _callee);
-  }));
-
-  return function (_x3) {
-    return _ref.apply(this, arguments);
-  };
-}());
+    });
+}
+exports.default = setSchemaIds;

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

@@ -0,0 +1,31 @@
+import { SchemaObject } from "ajv";
+import { AnyValidateFunction } from "ajv/dist/core";
+import { AnyObject } from "../esse/types";
+interface AjvInstanceOptions {
+    clean: boolean;
+    coerceTypes: boolean;
+}
+export declare function getValidator(jsonSchema: SchemaObject, { clean, coerceTypes }: AjvInstanceOptions): AnyValidateFunction;
+/**
+ * Validates a given example against the schema.
+ * @param example example to validate.
+ * @param schema schema to validate the example with.
+ * @returns whether example is valid.
+ */
+export declare function validate(data: AnyObject, jsonSchema: SchemaObject): {
+    isValid: boolean | Promise<any>;
+    errors: import("ajv").ErrorObject<string, Record<string, any>, unknown>[] | null | undefined;
+};
+/**
+ * Validates and clean a given example against the schema
+ * @param example example to validate.
+ * @param schema schema to validate the example with.
+ * @returns whether example is valid.
+ */
+export declare function validateAndClean(data: AnyObject, jsonSchema: SchemaObject, { coerceTypes }: {
+    coerceTypes?: boolean | undefined;
+}): {
+    isValid: boolean | Promise<any>;
+    errors: import("ajv").ErrorObject<string, Record<string, any>, unknown>[] | null | undefined;
+};
+export {};

package/lib/js/utils/ajv.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndClean = exports.validate = exports.getValidator = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const schemaUtils_1 = require("../esse/schemaUtils");
+function addAdditionalPropertiesToSchema(schema, additionalProperties = false) {
+    return (0, schemaUtils_1.mapObjectDeep)(schema, (object) => {
+        const schema = object;
+        if (typeof object === "object" &&
+            (schema === null || schema === void 0 ? void 0 : schema.type) === "object" &&
+            (schema === null || schema === void 0 ? void 0 : schema.properties) &&
+            !("additionalProperties" in schema)) {
+            return {
+                ...schema,
+                additionalProperties,
+                unevaluatedProperties: false,
+            };
+        }
+    });
+}
+const ajvConfig = {
+    strict: false,
+    useDefaults: true,
+    /**
+     * discriminator fixes default values in oneOf
+     * @see https://ajv.js.org/guide/modifying-data.html#assigning-defaults
+     */
+    discriminator: true,
+};
+const ajvValidator = new ajv_1.default({ ...ajvConfig });
+const ajvValidatorAndCleaner = new ajv_1.default({ ...ajvConfig, removeAdditional: true });
+const ajvValidatorAndCleanerWithCoercingTypes = new ajv_1.default({
+    ...ajvConfig,
+    removeAdditional: true,
+    coerceTypes: true,
+});
+function getAjvInstance({ clean, coerceTypes }) {
+    if (clean && coerceTypes) {
+        return ajvValidatorAndCleanerWithCoercingTypes;
+    }
+    if (clean) {
+        return ajvValidatorAndCleaner;
+    }
+    return ajvValidator;
+}
+function getValidator(jsonSchema, { clean, coerceTypes }) {
+    const schemaKey = jsonSchema.$id;
+    const ajv = getAjvInstance({ clean, coerceTypes });
+    let validate = ajv.getSchema(schemaKey);
+    if (!validate) {
+        // properties that were not defined in schema will be ignored when clean = false
+        const patchedSchema = clean ? addAdditionalPropertiesToSchema(jsonSchema) : jsonSchema;
+        ajv.addSchema(patchedSchema, schemaKey);
+        validate = ajv.getSchema(schemaKey);
+    }
+    if (!validate) {
+        throw new Error("JSONSchemasInterface AJV validator error");
+    }
+    return validate;
+}
+exports.getValidator = getValidator;
+/**
+ * Validates a given example against the schema.
+ * @param example example to validate.
+ * @param schema schema to validate the example with.
+ * @returns whether example is valid.
+ */
+function validate(data, jsonSchema) {
+    const validator = getValidator(jsonSchema, { clean: false, coerceTypes: false });
+    const isValid = validator(data);
+    return {
+        isValid,
+        errors: validator.errors,
+    };
+}
+exports.validate = validate;
+/**
+ * Validates and clean a given example against the schema
+ * @param example example to validate.
+ * @param schema schema to validate the example with.
+ * @returns whether example is valid.
+ */
+function validateAndClean(data, jsonSchema, { coerceTypes = false }) {
+    const validator = getValidator(jsonSchema, { clean: true, coerceTypes });
+    const isValid = validator(data);
+    return {
+        isValid,
+        errors: validator.errors,
+    };
+}
+exports.validateAndClean = validateAndClean;

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

@@ -0,0 +1,6 @@
+export declare function isInstanceOf(object: object, type: "Array"): object is object[];
+export declare function isInstanceOf(object: object, type: "Object"): object is object;
+/**
+ * Makes sure that text representing arrays is parsed into Arrays.
+ */
+export declare function safeParseJSON(string: string): any;

package/lib/js/utils/common.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeParseJSON = exports.isInstanceOf = void 0;
+function isInstanceOf(object, type) {
+    return Object.prototype.toString.call(object).slice(8, -1) === type;
+}
+exports.isInstanceOf = isInstanceOf;
+/**
+ * Makes sure that text representing arrays is parsed into Arrays.
+ */
+function safeParseJSON(string) {
+    const obj = JSON.parse(string);
+    return string[0] === "[" ? Object.keys(obj).map((key) => obj[key]) : obj;
+}
+exports.safeParseJSON = safeParseJSON;

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

@@ -0,0 +1,2 @@
+export declare function walkDir(dir: string, callback: (itemPath: string) => void | Promise<void>): Promise<void>;
+export declare function walkDirSync(dir: string, callback: (itemPath: string) => void): void;

package/lib/js/utils/filesystem.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkDirSync = exports.walkDir = void 0;
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function walkDir(dir, callback) {
+    const subDirs = await fs_1.default.promises.readdir(dir);
+    for (const subDir of subDirs) {
+        const itemPath = path_1.default.join(dir, subDir);
+        const stat = await fs_1.default.promises.stat(itemPath);
+        if (stat.isDirectory()) {
+            await walkDir(itemPath, callback);
+        }
+        else {
+            await callback(itemPath);
+        }
+    }
+}
+exports.walkDir = walkDir;
+function walkDirSync(dir, callback) {
+    const subDirs = fs_1.default.readdirSync(dir);
+    for (const subDir of subDirs) {
+        const itemPath = path_1.default.join(dir, subDir);
+        const stat = fs_1.default.statSync(itemPath);
+        if (stat.isDirectory()) {
+            walkDirSync(itemPath, callback);
+        }
+        else {
+            callback(itemPath);
+        }
+    }
+}
+exports.walkDirSync = walkDirSync;

package/modules.d.ts

@@ -0,0 +1,5 @@
+declare module "json-schema-deref-sync" {
+    import { JSONSchema7 } from "json-schema";
+
+    export default function deref(schema: JSONSchema, options: object): JSONSchema7;
+}