@mat3ra/esse 2026.8.18-0 → 2026.8.18-2

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

@@ -0,0 +1,21 @@
+import { JSONSchemaWithPath } from "./server/utils";
+import type { JSONSchema } 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/dist/js/esse/JSONSchemasGenerator.js

@@ -0,0 +1,72 @@
+"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 utils_1 = require("./server/utils");
+const settings_1 = require("./settings");
+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) => {
+            console.log(`Resolving schema: ${schema.$id}`);
+            const mergedSchema = skipMergeAllOff ? schema : (0, json_schema_merge_allof_1.default)(schema, mergeAllOfConfig);
+            let idAsPath = mergedSchema.$id;
+            if (!idAsPath) {
+                throw new Error(`Schema ID is missing:
+                ${JSON.stringify(mergedSchema)}`);
+            }
+            const schemaHasDash = idAsPath.includes("-");
+            if (schemaHasDash) {
+                // replace dashes with underscores
+                idAsPath = idAsPath.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/dist/js/esse/JSONSchemasInterface.d.ts

@@ -0,0 +1,48 @@
+import { type 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;
+    /**
+     * Like {@link getSchemaById}, but throws if the schema is not registered.
+     */
+    static getRequiredSchemaById(schemaId: string): JSONSchema;
+    /**
+     * @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;
+    /**
+     * Get a patched copy of a schema without modifying the cached version
+     * @param schemaId - The ID of the schema to patch
+     * @param propertyPatches - Object with property names as keys and patch objects as values
+     * @returns A new schema with patched properties
+     *
+     * @example
+     * JSONSchemasInterface.getPatchedSchema("boundary-conditions-provider", {
+     *   type: { default: "pbc" },
+     *   offset: { default: 0 }
+     * });
+     */
+    static getPatchedSchemaById(schemaId: string, patchConfig: Record<string, unknown>): JSONSchema | undefined;
+}

package/dist/js/esse/JSONSchemasInterface.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+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);
+    }
+    /**
+     * Like {@link getSchemaById}, but throws if the schema is not registered.
+     */
+    static getRequiredSchemaById(schemaId) {
+        const schema = this.getSchemaById(schemaId);
+        if (!schema) {
+            throw new Error(`ESSE schema not found: ${schemaId}`);
+        }
+        return schema;
+    }
+    /**
+     * @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);
+            });
+        });
+    }
+    /**
+     * Get a patched copy of a schema without modifying the cached version
+     * @param schemaId - The ID of the schema to patch
+     * @param propertyPatches - Object with property names as keys and patch objects as values
+     * @returns A new schema with patched properties
+     *
+     * @example
+     * JSONSchemasInterface.getPatchedSchema("boundary-conditions-provider", {
+     *   type: { default: "pbc" },
+     *   offset: { default: 0 }
+     * });
+     */
+    static getPatchedSchemaById(schemaId, patchConfig) {
+        const baseSchema = this.getSchemaById(schemaId);
+        if (!baseSchema) {
+            return undefined;
+        }
+        const patchedSchema = JSON.parse(JSON.stringify(baseSchema));
+        (0, utils_1.applyPatchTree)(patchedSchema, patchConfig, []);
+        return patchedSchema;
+    }
+}
+JSONSchemasInterface.schemasCache = new Map();
+exports.default = JSONSchemasInterface;

package/dist/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/dist/js/esse/JSONSchemasInterfaceServer.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSchemaFolderSync = readSchemaFolderSync;
+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;
+}
+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);
+    }
+}
+JSONSchemasInterfaceServer.schemaFolder = path_1.default.resolve(__dirname, "./../schema");
+exports.default = JSONSchemasInterfaceServer;

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

@@ -0,0 +1,4 @@
+import type { 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/dist/js/esse/schemaUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapObjectDeep = mapObjectDeep;
+function mapObjectDeep(object, 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)];
+    });
+    return Object.fromEntries(entries);
+}

package/dist/js/esse/server/utils.d.ts

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

package/dist/js/esse/server/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncludeReferenceStatements = parseIncludeReferenceStatements;
+exports.parseIncludeReferenceStatementsByDir = parseIncludeReferenceStatementsByDir;
+/**
+ * Server-side schema parsing utilities.
+ *
+ * Use this module only in Node/server contexts where the filesystem is available.
+ * It walks directories and reads JSON schema files from disk; do not import it in
+ * browser bundles.
+ */
+// @ts-ignore
+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) {
+    const jsonResolver = new json_include_1.JSONInclude();
+    const parsed = jsonResolver.parseIncludeStatements(filePath);
+    const dirPath = path_1.default.dirname(filePath);
+    // Store the original $id before dereferencing
+    const originalId = parsed.$id;
+    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;
+    }
+    // Restore the original $id after dereferencing
+    if (originalId) {
+        dereferenced.$id = originalId;
+    }
+    return dereferenced;
+}
+/**
+ * Resolves `include` and `$ref` statements for all the JSON files inside a given directory.
+ * @param dirPath directory to parse.
+ */
+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 wrapInDataAndPath ? schemasWithPath : schemas;
+}

package/dist/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/dist/js/esse/settings.js

@@ -0,0 +1,10 @@
+"use strict";
+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/dist/js/esse/types.d.ts

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

package/dist/js/esse/types.js

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

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

@@ -0,0 +1,5 @@
+import { JSONSchema7, JSONSchema7Definition } from "json-schema";
+export type JSONSchema = JSONSchema7;
+export type JSONSchemaDefinition = JSONSchema7Definition;
+export declare function applyPatchWithDotNotation(target: Record<string, unknown>, path: string, patchValue: unknown): void;
+export declare function applyPatchTree(schema: Record<string, unknown>, patchNode: Record<string, unknown>, pathPrefix: string[]): void;

package/dist/js/esse/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPatchWithDotNotation = applyPatchWithDotNotation;
+exports.applyPatchTree = applyPatchTree;
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function applyPatchWithDotNotation(target, path, patchValue) {
+    const keys = path.split(".");
+    let current = target;
+    // Navigate to parent of final key
+    for (let index = 0; index < keys.length - 1; index += 1) {
+        const key = keys[index];
+        if (!isPlainObject(current[key])) {
+            // Path does not exist or is not an object → skip patch
+            return;
+        }
+        current = current[key];
+    }
+    const finalKey = keys[keys.length - 1];
+    const existingValue = current[finalKey];
+    if (isPlainObject(existingValue) && isPlainObject(patchValue)) {
+        // Merge object into existing object
+        Object.assign(existingValue, patchValue);
+    }
+    else if (existingValue !== undefined) {
+        // Overwrite leaf value
+        current[finalKey] = patchValue;
+    }
+    // If existingValue is undefined, we skip;
+}
+function applyPatchTree(schema, patchNode, pathPrefix) {
+    Object.entries(patchNode).forEach(([key, value]) => {
+        if (key.includes(".")) {
+            // Dot notation relative to current prefix
+            const fullPathSegments = [...pathPrefix, ...key.split(".")];
+            const fullPath = fullPathSegments.join(".");
+            applyPatchWithDotNotation(schema, fullPath, value);
+        }
+        else if (isPlainObject(value)) {
+            // Nested subtree → recurse with extended prefix
+            applyPatchTree(schema, value, [...pathPrefix, key]);
+        }
+        else {
+            // Leaf patch (primitive / array) → treat as direct field patch
+            const fullPathSegments = [...pathPrefix, key];
+            const fullPath = fullPathSegments.join(".");
+            applyPatchWithDotNotation(schema, fullPath, value);
+        }
+    });
+}

package/dist/js/json_include/index.d.ts

@@ -0,0 +1,22 @@
+export interface CacheObject {
+    [key: string]: CacheObject | CacheObject[];
+}
+export declare class JSONInclude {
+    JSON_INCLUDE_CACHE: CacheObject;
+    /**
+     * Extracts file name(path) from the include statement.
+     * @param value string to extract the file name from.
+     */
+    _getIncludeFileName: (value: unknown) => string | null | undefined;
+    /**
+     * Walks a nested object to resolve include statements.
+     * @param obj Object to traverse.
+     * @param dirpath directory from which `obj` is obtained. Include statements are relative to `obj` path.
+     */
+    _walkObjectToInclude(obj: CacheObject | CacheObject[], dirpath: string): void;
+    /**
+     * Resolves `include` statements.
+     * @param filePath file to parse.
+     */
+    parseIncludeStatements(filePath: string): CacheObject[];
+}

package/dist/js/json_include/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONInclude = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("../utils/common");
+const settings_1 = require("./settings");
+class JSONInclude {
+    constructor() {
+        this.JSON_INCLUDE_CACHE = {};
+        /**
+         * Extracts file name(path) from the include statement.
+         * @param value string to extract the file name from.
+         */
+        this._getIncludeFileName = (value) => {
+            if (typeof value === "string" && value.search(settings_1.INCLUDE_VALUE_REGEX) !== -1) {
+                const matched = value.match(settings_1.INCLUDE_VALUE_REGEX);
+                return matched && matched[1];
+            }
+        };
+    }
+    /**
+     * Walks a nested object to resolve include statements.
+     * @param obj Object to traverse.
+     * @param dirpath directory from which `obj` is obtained. Include statements are relative to `obj` path.
+     */
+    _walkObjectToInclude(obj, dirpath) {
+        if ((0, common_1.isInstanceOf)(obj, "Array")) {
+            for (let i = 0; i < obj.length; i++) {
+                if ((0, common_1.isInstanceOf)(obj[i], "Object") || (0, common_1.isInstanceOf)(obj[i], "Array")) {
+                    this._walkObjectToInclude(obj[i], dirpath);
+                }
+            }
+        }
+        else if ((0, common_1.isInstanceOf)(obj, "Object")) {
+            if (settings_1.INCLUDE_KEY in obj) {
+                const includeName = this._getIncludeFileName(obj[settings_1.INCLUDE_KEY]);
+                if (includeName) {
+                    delete obj[settings_1.INCLUDE_KEY];
+                    if (!(includeName in this.JSON_INCLUDE_CACHE)) {
+                        const filePath = path_1.default.join(dirpath, includeName);
+                        this.JSON_INCLUDE_CACHE[includeName] =
+                            this.parseIncludeStatements(filePath);
+                    }
+                    Object.keys(this.JSON_INCLUDE_CACHE[includeName]).forEach((attr) => {
+                        // @ts-ignore
+                        obj[attr] = this.JSON_INCLUDE_CACHE[includeName][attr];
+                    });
+                }
+            }
+            Object.keys(obj).forEach((key) => {
+                if ((0, common_1.isInstanceOf)(obj[key], "Object") || (0, common_1.isInstanceOf)(obj[key], "Array")) {
+                    this._walkObjectToInclude(obj[key], dirpath);
+                }
+            });
+        }
+    }
+    /**
+     * Resolves `include` statements.
+     * @param filePath file to parse.
+     */
+    parseIncludeStatements(filePath) {
+        const data = (0, common_1.safeParseJSON)(fs_1.default.readFileSync(filePath, "utf8"));
+        console.log("Parsing file: ", filePath);
+        if (settings_1.OBJECT_ONLY && !(0, common_1.isInstanceOf)(data, "Object")) {
+            throw new Error("The JSON file being included should always be a dict rather than a list");
+        }
+        this._walkObjectToInclude(data, path_1.default.dirname(filePath));
+        return data;
+    }
+}
+exports.JSONInclude = JSONInclude;

package/dist/js/json_include/settings.d.ts

@@ -0,0 +1,3 @@
+export declare const INCLUDE_KEY = "...";
+export declare const INCLUDE_VALUE_REGEX: RegExp;
+export declare const OBJECT_ONLY = false;

package/dist/js/json_include/settings.js

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

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

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

package/dist/js/scripts/compileTs.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = compileTS;
+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,
+            enableConstEnums: false,
+            bannerComment: `/** Schema ${filePath} */`,
+        });
+        await fs_1.default.promises.appendFile(savePath, `${compiledSchema} \n`, { flag: "a+" });
+    });
+}