@mat3ra/esse 2023.12.25-2

package/lib/js/esse/schemaUtils.js

@@ -0,0 +1,78 @@
+"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); }
+
+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);
+    });
+  }
+
+  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))
+  };
+}
+
+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);
+  });
+}

package/lib/js/esse/settings.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCHEMAS_DIR = 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;

package/lib/js/esse/utils.js

@@ -0,0 +1,74 @@
+"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 }; }
+
+/**
+ * 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;
+}
+/**
+ * Resolves `include` and `$ref` statements for all the JSON files inside a given directory.
+ * @param dirPath {String} 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);
+        }
+      }
+    });
+  });
+
+  return data;
+}

package/lib/js/json_include/index.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSONInclude = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _settings = require("./settings");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+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; }
+
+var JSONInclude = /*#__PURE__*/function () {
+  function JSONInclude() {
+    _classCallCheck(this, JSONInclude);
+
+    _defineProperty(this, "_getIncludeFileName", function (value) {
+      if ((0, _utils.isInstanceOf)(value, "String") && value.search(_settings.INCLUDE_VALUE_REGEX) !== -1) {
+        return value.match(_settings.INCLUDE_VALUE_REGEX)[1];
+      }
+    });
+
+    this.JSON_INCLUDE_CACHE = {};
+  }
+  /**
+   * Extracts file name(path) from the include statement.
+   * @param value {String} string to extract the file name from.
+   */
+
+
+  _createClass(JSONInclude, [{
+    key: "_walkObjectToInclude",
+    value:
+    /**
+     * Walks a nested object to resolve include statements.
+     * @param obj {Object} Object to traverse.
+     * @param dirpath {String} directory from which `obj` is obtained. Include statements are relative to `obj` path.
+     */
+    function _walkObjectToInclude(obj, dirpath) {
+      var _this = this;
+
+      if ((0, _utils.isInstanceOf)(obj, "Object")) {
+        if (_settings.INCLUDE_KEY in obj) {
+          var includeName = this._getIncludeFileName(obj[_settings.INCLUDE_KEY]);
+
+          if (includeName) {
+            delete obj[_settings.INCLUDE_KEY];
+
+            if (!(includeName in this.JSON_INCLUDE_CACHE)) {
+              var filePath = _path["default"].join(dirpath, includeName);
+
+              this.JSON_INCLUDE_CACHE[includeName] = this.parseIncludeStatements(filePath);
+            }
+
+            Object.keys(this.JSON_INCLUDE_CACHE[includeName]).forEach(function (attr) {
+              obj[attr] = _this.JSON_INCLUDE_CACHE[includeName][attr];
+            });
+          }
+        }
+
+        Object.keys(obj).forEach(function (key) {
+          if ((0, _utils.isInstanceOf)(obj[key], "Object") || (0, _utils.isInstanceOf)(obj[key], "Array")) {
+            _this._walkObjectToInclude(obj[key], dirpath);
+          }
+        });
+      } else if ((0, _utils.isInstanceOf)(obj, "Array")) {
+        for (var i = 0; i < obj.length; i++) {
+          if ((0, _utils.isInstanceOf)(obj[i], "Object") || (0, _utils.isInstanceOf)(obj[i], "Array")) {
+            this._walkObjectToInclude(obj[i], dirpath);
+          }
+        }
+      }
+    }
+    /**
+     * Resolves `include` statements.
+     * @param filePath {String} file to parse.
+     */
+
+  }, {
+    key: "parseIncludeStatements",
+    value: function parseIncludeStatements(filePath) {
+      var data = (0, _utils.safeParseJSON)(_fs["default"].readFileSync(filePath, "utf8"));
+
+      if (_settings.OBJECT_ONLY && !(0, _utils.isInstanceOf)(data, "Object")) {
+        throw new Error("The JSON file being included should always be a dict rather than a list");
+      }
+
+      this._walkObjectToInclude(data, _path["default"].dirname(filePath));
+
+      return data;
+    }
+  }]);
+
+  return JSONInclude;
+}();
+
+exports.JSONInclude = JSONInclude;

package/lib/js/json_include/settings.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OBJECT_ONLY = exports.INCLUDE_VALUE_REGEX = exports.INCLUDE_KEY = void 0;
+var INCLUDE_KEY = "...";
+exports.INCLUDE_KEY = INCLUDE_KEY;
+var INCLUDE_VALUE_REGEX = /^include\((.+)\)$/;
+exports.INCLUDE_VALUE_REGEX = INCLUDE_VALUE_REGEX;
+var OBJECT_ONLY = false; // whether to only include Object, and not Array.
+
+exports.OBJECT_ONLY = OBJECT_ONLY;

package/lib/js/json_include/utils.js

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

package/lib/js/scripts/createEnumsFromYaml.js

@@ -0,0 +1,74 @@
+"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; }
+
+/**
+ *  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);
+      }
+    }
+  } 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"));
+});

package/lib/js/scripts/setSchemaIds.js

@@ -0,0 +1,156 @@
+"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();
+        }
+      }
+    }, _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();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x3) {
+    return _ref.apply(this, arguments);
+  };
+}());

package/npmignore

@@ -0,0 +1,6 @@
+src/py/
+tests/
+pyproject.toml
+/manifest/
+.github
+.husky

package/package.json

@@ -0,0 +1,75 @@
+{
+    "name": "@mat3ra/esse",
+    "version": "2023.12.25-2",
+    "description": "Mat3ra's Excellent Source of Schemas and Examples (ESSE) for Digital Materials R&D",
+    "scripts": {
+        "prepublishOnly": "rm -rf lib; npm run transpile",
+        "transpile": "mkdir -p lib; babel src/js --out-dir lib/js; node build_schemas.js",
+        "transpile-and-build-assets": "mkdir -p lib; babel src/js --out-dir lib/js; BUILD_ASSETS=true BUILD_PATH='./lib/js' node build_schemas.js",
+        "build:assets": "node build_schemas.js",
+        "build:assets-with-docs": "BUILD_ASSETS=true node build_schemas.js",
+        "test": "nyc --reporter=text mocha --bail --require @babel/register tests/js/",
+        "lint": "eslint src/js && prettier --write src/js",
+        "lint:fix": "eslint --fix --cache src/js && prettier --write src/js",
+        "prettier": "prettier --check src/js",
+        "postinstall": "npm run transpile-and-build-assets",
+        "prepare": "husky install || exit 0",
+        "setSchemaIds": "cd src/js/scripts && node setSchemaIds.mjs"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Exabyte-io/esse.git"
+    },
+    "main": "lib/js/esse/index.js",
+    "author": "Mat3ra.com",
+    "email": "info@mat3ra.com",
+    "bugs": {
+        "url": "https://github.com/Exabyte-io/exabyte-esse/issues"
+    },
+    "homepage": "https://github.com/Exabyte-io/esse",
+    "devDependencies": {
+        "@exabyte-io/eslint-config": "^2022.11.17-0",
+        "chai": "4.3.4",
+        "eslint": "^7.32.0",
+        "eslint-config-airbnb": "^19.0.2",
+        "eslint-config-prettier": "^8.3.0",
+        "eslint-plugin-import": "^2.25.3",
+        "eslint-plugin-jsdoc": "^37.1.0",
+        "eslint-plugin-jsx-a11y": "^6.5.1",
+        "eslint-plugin-prettier": "^4.0.0",
+        "eslint-plugin-react": "^7.27.1",
+        "eslint-plugin-react-hooks": "^4.3.0",
+        "eslint-plugin-simple-import-sort": "^7.0.0",
+        "husky": "^7.0.4",
+        "lint-staged": "^12.1.2",
+        "mocha": "^9.2.0",
+        "nyc": "15.1.0",
+        "prettier": "^2.5.1",
+        "prettyjson": "^1.1.3"
+    },
+    "license": "Apache-2.0",
+    "dependencies": {
+        "@babel/cli": "7.16.0",
+        "@babel/core": "7.16.0",
+        "@babel/eslint-parser": "7.16.3",
+        "@babel/preset-env": "7.16.4",
+        "@babel/register": "7.16.0",
+        "ajv": "^4.1.7",
+        "file": "^0.2.2",
+        "js-yaml": "^4.1.0",
+        "json-schema-deref-sync": "0.14.0",
+        "json-schema-merge-allof": "^0.8.1",
+        "lodash": "4.17.21"
+    },
+    "engines": {
+        "node": ">=12.0.0"
+    },
+    "lint-staged": {
+        "*.js": "eslint --cache --fix",
+        "*.{js,css}": "prettier --write"
+    },
+    "exports": {
+        "./schema": "./schema.js",
+        "./lib/js/esse/schemaUtils": "./lib/js/esse/schemaUtils.js"
+    }
+}