@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/NodesLoader/constants.d.ts

@@ -0,0 +1,5 @@
+import type { INodeProperties } from "@fsai-flow/workflow";
+export declare const CUSTOM_NODES_CATEGORY = "Custom Nodes";
+export declare const commonPollingParameters: INodeProperties[];
+export declare const commonCORSParameters: INodeProperties[];
+export declare const commonDeclarativeNodeOptionParameters: INodeProperties;

package/dist/lib/NodesLoader/constants.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonDeclarativeNodeOptionParameters = exports.commonCORSParameters = exports.commonPollingParameters = exports.CUSTOM_NODES_CATEGORY = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+exports.CUSTOM_NODES_CATEGORY = "Custom Nodes";
+exports.commonPollingParameters = [
+    {
+        displayName: "Poll Times",
+        name: "pollTimes",
+        type: "fixedCollection",
+        typeOptions: {
+            multipleValues: true,
+            multipleValueButtonText: "Add Poll Time",
+        },
+        default: { item: [{ mode: "everyMinute" }] },
+        description: "Time at which polling should occur",
+        placeholder: "Add Poll Time",
+        options: workflow_1.cronNodeOptions,
+    },
+];
+exports.commonCORSParameters = [
+    {
+        displayName: "Allowed Origins (CORS)",
+        name: "allowedOrigins",
+        type: "string",
+        default: "*",
+        description: "Comma-separated list of URLs allowed for cross-origin non-preflight requests. Use * (default) to allow all origins.",
+    },
+];
+exports.commonDeclarativeNodeOptionParameters = {
+    displayName: "Request Options",
+    name: "requestOptions",
+    type: "collection",
+    isNodeSetting: true,
+    placeholder: "Add Option",
+    default: {},
+    options: [
+        {
+            displayName: "Batching",
+            name: "batching",
+            placeholder: "Add Batching",
+            type: "fixedCollection",
+            typeOptions: {
+                multipleValues: false,
+            },
+            default: {
+                batch: {},
+            },
+            options: [
+                {
+                    displayName: "Batching",
+                    name: "batch",
+                    values: [
+                        {
+                            displayName: "Items per Batch",
+                            name: "batchSize",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -1,
+                            },
+                            default: 50,
+                            description: "Input will be split in batches to throttle requests. -1 for disabled. 0 will be treated as 1.",
+                        },
+                        {
+                            displayName: "Batch Interval (ms)",
+                            name: "batchInterval",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                            },
+                            default: 1000,
+                            description: "Time (in milliseconds) between each batch of requests. 0 for disabled.",
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            displayName: "Ignore SSL Issues (Insecure)",
+            name: "allowUnauthorizedCerts",
+            type: "boolean",
+            noDataExpression: true,
+            default: false,
+            description: "Whether to accept the response even if SSL certificate validation is not possible",
+        },
+        {
+            displayName: "Proxy",
+            name: "proxy",
+            type: "string",
+            default: "",
+            placeholder: "e.g. http://myproxy:3128",
+            description: "HTTP proxy to use. If authentication is required it can be defined as follow: http://username:password@myproxy:3128",
+        },
+        {
+            displayName: "Timeout",
+            name: "timeout",
+            type: "number",
+            typeOptions: {
+                minValue: 1,
+            },
+            default: 10000,
+            description: "Time in ms to wait for the server to send response headers (and start the response body) before aborting the request",
+        },
+    ],
+};

package/dist/lib/NodesLoader/custom-directory-loader.d.ts

@@ -0,0 +1,9 @@
+import { DirectoryLoader } from "./directory-loader";
+/**
+ * Loader for source files of nodes and credentials located in a custom dir,
+ * e.g. `~/.n8n/custom`
+ */
+export declare class CustomDirectoryLoader extends DirectoryLoader {
+    packageName: string;
+    loadAll(): Promise<void>;
+}

package/dist/lib/NodesLoader/custom-directory-loader.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDirectoryLoader = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const directory_loader_1 = require("./directory-loader");
+/**
+ * Loader for source files of nodes and credentials located in a custom dir,
+ * e.g. `~/.n8n/custom`
+ */
+class CustomDirectoryLoader extends directory_loader_1.DirectoryLoader {
+    constructor() {
+        super(...arguments);
+        this.packageName = "CUSTOM";
+    }
+    async loadAll() {
+        const nodes = await (0, fast_glob_1.default)("**/*.node.js", {
+            cwd: this.directory,
+            absolute: true,
+        });
+        for (const nodePath of nodes) {
+            this.loadNodeFromFile(nodePath);
+        }
+        const credentials = await (0, fast_glob_1.default)("**/*.credentials.js", {
+            cwd: this.directory,
+            absolute: true,
+        });
+        for (const credentialPath of credentials) {
+            this.loadCredentialFromFile(credentialPath);
+        }
+    }
+}
+exports.CustomDirectoryLoader = CustomDirectoryLoader;

package/dist/lib/NodesLoader/directory-loader.d.ts

@@ -0,0 +1,66 @@
+import type { ICredentialType, ICredentialTypeData, INodeCredentialDescription, INodeType, INodeTypeBaseDescription, INodeTypeData, INodeTypeNameVersion, IVersionedNodeType, KnownNodesAndCredentials } from "@fsai-flow/workflow";
+export type Types = {
+    nodes: INodeTypeBaseDescription[];
+    credentials: ICredentialType[];
+};
+/**
+ * Base class for loading n8n nodes and credentials from a directory.
+ * Handles the common functionality for resolving paths, loading classes, and managing node and credential types.
+ */
+export declare abstract class DirectoryLoader {
+    readonly directory: string;
+    protected excludeNodes: string[];
+    protected includeNodes: string[];
+    isLazyLoaded: boolean;
+    loadedNodes: INodeTypeNameVersion[];
+    nodeTypes: INodeTypeData;
+    credentialTypes: ICredentialTypeData;
+    known: KnownNodesAndCredentials;
+    types: Types;
+    readonly nodesByCredential: Record<string, string[]>;
+    constructor(directory: string, excludeNodes?: string[], includeNodes?: string[]);
+    abstract packageName: string;
+    abstract loadAll(): Promise<void>;
+    reset(): void;
+    protected resolvePath(file: string): string;
+    private loadClass;
+    /** Loads a nodes class from a file, fixes icons, and augments the codex */
+    loadNodeFromFile(filePath: string): void;
+    getNode(nodeType: string): {
+        type: INodeType | import("@fsai-flow/workflow").INodeVersionedType;
+        sourcePath: string;
+    };
+    /** Loads a credential class from a file, and fixes icons */
+    loadCredentialFromFile(filePath: string): void;
+    getCredential(credentialType: string): {
+        type: ICredentialType;
+        sourcePath: string;
+    };
+    /**
+     * Returns an array of credential descriptions that are supported by a node.
+     * For versioned nodes, combines and deduplicates credentials from all versions.
+     */
+    getCredentialsForNode(object: IVersionedNodeType | INodeType): INodeCredentialDescription[];
+    /**
+     * Returns an array of all versions of a node type.
+     * For non-versioned nodes, returns an array with just that node.
+     * For versioned nodes, returns all available versions.
+     */
+    getVersionedNodeTypeAll(object: IVersionedNodeType | INodeType): INodeType[];
+    /**
+     * Retrieves `categories`, `subcategories` and alias (if defined)
+     * from the codex data for the node at the given file path.
+     */
+    private getCodex;
+    /**
+     * Adds a node codex `categories` and `subcategories` (if defined)
+     * to a node description `codex` property.
+     */
+    private addCodex;
+    private addLoadOptionsMethods;
+    private applySpecialNodeParameters;
+    private getIconPath;
+    private fixIconPaths;
+    /** Augments additional `Request Options` property on declarative node-type */
+    static applyDeclarativeNodeOptionParameters(nodeType: INodeType): void;
+}

package/dist/lib/NodesLoader/directory-loader.js

@@ -0,0 +1,367 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectoryLoader = void 0;
+const path = __importStar(require("node:path"));
+const workflow_1 = require("@fsai-flow/workflow");
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const constants_1 = require("./constants");
+const load_class_in_isolation_1 = require("./load-class-in-isolation");
+function toJSON() {
+    return {
+        ...this,
+        authenticate: typeof this.authenticate === "function" ? {} : this.authenticate,
+    };
+}
+/**
+ * Base class for loading n8n nodes and credentials from a directory.
+ * Handles the common functionality for resolving paths, loading classes, and managing node and credential types.
+ */
+class DirectoryLoader {
+    constructor(directory, excludeNodes = [], includeNodes = []) {
+        this.directory = directory;
+        this.excludeNodes = excludeNodes;
+        this.includeNodes = includeNodes;
+        this.isLazyLoaded = false;
+        // Another way of keeping track of the names and versions of a node. This
+        // seems to only be used by the installedPackages repository
+        this.loadedNodes = [];
+        // Stores the loaded descriptions and sourcepaths
+        this.nodeTypes = {};
+        this.credentialTypes = {};
+        // Stores the location and classnames of the nodes and credentials that are
+        // loaded; used to actually load the files in lazy-loading scenario.
+        this.known = { nodes: {}, credentials: {} };
+        // Stores the different versions with their individual descriptions
+        this.types = { nodes: [], credentials: [] };
+        this.nodesByCredential = {};
+    }
+    reset() {
+        this.loadedNodes = [];
+        this.nodeTypes = {};
+        this.credentialTypes = {};
+        this.known = { nodes: {}, credentials: {} };
+        this.types = { nodes: [], credentials: [] };
+    }
+    resolvePath(file) {
+        return path.resolve(this.directory, file);
+    }
+    loadClass(sourcePath) {
+        const filePath = this.resolvePath(sourcePath);
+        const [className] = path.parse(sourcePath).name.split(".");
+        try {
+            return (0, load_class_in_isolation_1.loadClassInIsolation)(filePath, className);
+        }
+        catch (error) {
+            throw error instanceof TypeError
+                ? new Error("Class could not be found. Please check if the class is named correctly.")
+                : error;
+        }
+    }
+    /** Loads a nodes class from a file, fixes icons, and augments the codex */
+    loadNodeFromFile(filePath) {
+        const tempNode = this.loadClass(filePath);
+        this.addCodex(tempNode, filePath);
+        const nodeType = tempNode.description.name;
+        if (this.includeNodes.length && !this.includeNodes.includes(nodeType)) {
+            return;
+        }
+        if (this.excludeNodes.includes(nodeType)) {
+            return;
+        }
+        this.fixIconPaths(tempNode.description, filePath);
+        let nodeVersion = 1;
+        if ("nodeVersions" in tempNode) {
+            for (const versionNode of Object.values(tempNode.nodeVersions)) {
+                this.fixIconPaths(versionNode.description, filePath);
+            }
+            for (const version of Object.values(tempNode.nodeVersions)) {
+                this.addLoadOptionsMethods(version);
+                this.applySpecialNodeParameters(version);
+            }
+            const currentVersionNode = tempNode.nodeVersions[tempNode.currentVersion];
+            this.addCodex(currentVersionNode, filePath);
+            nodeVersion = tempNode.currentVersion;
+            if (Object.hasOwn(currentVersionNode, "executeSingle")) {
+                throw new Error('"executeSingle" has been removed. Please update the code of this node to use "execute" instead.');
+            }
+        }
+        else {
+            this.addLoadOptionsMethods(tempNode);
+            this.applySpecialNodeParameters(tempNode);
+            // Short renaming to avoid type issues
+            nodeVersion = Array.isArray(tempNode.description.version)
+                ? tempNode.description.version.slice(-1)[0]
+                : tempNode.description.version;
+        }
+        this.known.nodes[nodeType] = {
+            className: tempNode.constructor.name,
+            sourcePath: filePath,
+        };
+        this.nodeTypes[nodeType] = {
+            type: tempNode,
+            sourcePath: filePath,
+        };
+        this.loadedNodes.push({
+            name: nodeType,
+            version: nodeVersion,
+        });
+        for (const { description } of this.getVersionedNodeTypeAll(tempNode)) {
+            this.types.nodes.push(description);
+        }
+        for (const credential of this.getCredentialsForNode(tempNode)) {
+            if (!this.nodesByCredential[credential.name]) {
+                this.nodesByCredential[credential.name] = [];
+            }
+            this.nodesByCredential[credential.name].push(nodeType);
+        }
+    }
+    getNode(nodeType) {
+        const { nodeTypes, known: { nodes: knownNodes }, } = this;
+        if (!(nodeType in nodeTypes) && nodeType in knownNodes) {
+            const { sourcePath } = knownNodes[nodeType];
+            this.loadNodeFromFile(sourcePath);
+        }
+        if (nodeType in nodeTypes) {
+            return nodeTypes[nodeType];
+        }
+        throw new Error(`Unrecognized node type: ${nodeType}`);
+    }
+    /** Loads a credential class from a file, and fixes icons */
+    loadCredentialFromFile(filePath) {
+        const tempCredential = this.loadClass(filePath);
+        // Add serializer method "toJSON" to the class so that authenticate method (if defined)
+        // gets mapped to the authenticate attribute before it is sent to the client.
+        // The authenticate property is used by the client to decide whether or not to
+        // include the credential type in the predefined credentials (HTTP node)
+        Object.assign(tempCredential, { toJSON });
+        this.fixIconPaths(tempCredential, filePath);
+        const credentialType = tempCredential.name;
+        this.known.credentials[credentialType] = {
+            className: tempCredential.constructor.name,
+            sourcePath: filePath,
+            extends: tempCredential.extends,
+            supportedNodes: this.nodesByCredential[credentialType],
+        };
+        this.credentialTypes[credentialType] = {
+            type: tempCredential,
+            sourcePath: filePath,
+        };
+        this.types.credentials.push(tempCredential);
+    }
+    getCredential(credentialType) {
+        const { credentialTypes, known: { credentials: knownCredentials }, } = this;
+        if (!(credentialType in credentialTypes) &&
+            credentialType in knownCredentials) {
+            const { sourcePath } = knownCredentials[credentialType];
+            this.loadCredentialFromFile(sourcePath);
+        }
+        if (credentialType in credentialTypes) {
+            return credentialTypes[credentialType];
+        }
+        throw new Error(`Unrecognized credential type: ${credentialType}`);
+    }
+    /**
+     * Returns an array of credential descriptions that are supported by a node.
+     * For versioned nodes, combines and deduplicates credentials from all versions.
+     */
+    getCredentialsForNode(object) {
+        if ("nodeVersions" in object) {
+            const credentials = Object.values(object.nodeVersions).flatMap(({ description }) => description.credentials ?? []);
+            return (0, uniqBy_1.default)(credentials, "name");
+        }
+        return object.description.credentials ?? [];
+    }
+    /**
+     * Returns an array of all versions of a node type.
+     * For non-versioned nodes, returns an array with just that node.
+     * For versioned nodes, returns all available versions.
+     */
+    getVersionedNodeTypeAll(object) {
+        if ("nodeVersions" in object) {
+            const nodeVersions = Object.values(object.nodeVersions).map((element) => {
+                element.description.name = object.description.name;
+                element.description.codex = object.description.codex;
+                return element;
+            });
+            return (0, uniqBy_1.default)(nodeVersions.reverse(), (node) => {
+                const { version } = node.description;
+                return Array.isArray(version) ? version.join(",") : version.toString();
+            });
+        }
+        return [object];
+    }
+    /**
+     * Retrieves `categories`, `subcategories` and alias (if defined)
+     * from the codex data for the node at the given file path.
+     */
+    getCodex(filePath) {
+        const codexFilePath = this.resolvePath(`${filePath}on`); // .js to .json
+        const { categories, subcategories, resources: { primaryDocumentation, credentialDocumentation }, alias, } = module.require(codexFilePath);
+        return {
+            ...(categories && { categories }),
+            ...(subcategories && { subcategories }),
+            ...(alias && { alias }),
+            resources: {
+                primaryDocumentation,
+                credentialDocumentation,
+            },
+        };
+    }
+    /**
+     * Adds a node codex `categories` and `subcategories` (if defined)
+     * to a node description `codex` property.
+     */
+    addCodex(node, filePath) {
+        const isCustom = this.packageName === "CUSTOM";
+        try {
+            let codex;
+            if (!isCustom) {
+                codex = node.description.codex;
+            }
+            if (codex === undefined) {
+                codex = this.getCodex(filePath);
+            }
+            if (isCustom) {
+                codex.categories = codex.categories
+                    ? codex.categories.concat(constants_1.CUSTOM_NODES_CATEGORY)
+                    : [constants_1.CUSTOM_NODES_CATEGORY];
+            }
+            node.description.codex = codex;
+        }
+        catch {
+            console.debug(`No codex available for: ${node.description.name}`);
+            if (isCustom) {
+                node.description.codex = {
+                    categories: [constants_1.CUSTOM_NODES_CATEGORY],
+                };
+            }
+        }
+    }
+    addLoadOptionsMethods(node) {
+        if (node?.methods?.loadOptions) {
+            node.description.__loadOptionsMethods = Object.keys(node.methods.loadOptions);
+        }
+    }
+    applySpecialNodeParameters(nodeType) {
+        const { properties, polling, supportsCORS } = nodeType.description;
+        if (polling) {
+            properties.unshift(...constants_1.commonPollingParameters);
+        }
+        if (nodeType.webhook && supportsCORS) {
+            const optionsProperty = properties.find(({ name }) => name === "options");
+            if (optionsProperty)
+                optionsProperty.options = [
+                    ...constants_1.commonCORSParameters,
+                    ...optionsProperty.options,
+                ];
+            else
+                properties.push(...constants_1.commonCORSParameters);
+        }
+        DirectoryLoader.applyDeclarativeNodeOptionParameters(nodeType);
+    }
+    getIconPath(icon, filePath) {
+        const iconPath = path.join(path.dirname(filePath), icon.replace("file:", ""));
+        return `icons/${this.packageName}/${iconPath}`;
+    }
+    fixIconPaths(obj, filePath) {
+        const { icon } = obj;
+        if (!icon)
+            return;
+        if (typeof icon === "string") {
+            if (icon.startsWith("file:")) {
+                obj.iconUrl = this.getIconPath(icon, filePath);
+                obj.icon = undefined;
+            }
+        }
+        else if (icon.light.startsWith("file:") &&
+            icon.dark.startsWith("file:")) {
+            obj.iconUrl = {
+                light: this.getIconPath(icon.light, filePath),
+                dark: this.getIconPath(icon.dark, filePath),
+            };
+            obj.icon = undefined;
+        }
+    }
+    /** Augments additional `Request Options` property on declarative node-type */
+    static applyDeclarativeNodeOptionParameters(nodeType) {
+        if (!!nodeType.execute ||
+            !!nodeType.trigger ||
+            !!nodeType.webhook ||
+            !!nodeType.description.polling ||
+            (0, workflow_1.isSubNodeType)(nodeType.description)) {
+            return;
+        }
+        const parameters = nodeType.description.properties;
+        if (!parameters) {
+            return;
+        }
+        // Was originally under "options" instead of "requestOptions" so the chance
+        // that that existed was quite high. With this name the chance is actually
+        // very low that it already exists but lets leave it in anyway to be sure.
+        const existingRequestOptionsIndex = parameters.findIndex((parameter) => parameter.name === "requestOptions");
+        if (existingRequestOptionsIndex !== -1) {
+            parameters[existingRequestOptionsIndex] = {
+                ...constants_1.commonDeclarativeNodeOptionParameters,
+                options: [
+                    ...(constants_1.commonDeclarativeNodeOptionParameters.options ?? []),
+                    ...(parameters[existingRequestOptionsIndex]?.options ?? []),
+                ],
+            };
+            const options = parameters[existingRequestOptionsIndex]?.options;
+            if (options) {
+                options.sort((a, b) => {
+                    if ("displayName" in a && "displayName" in b) {
+                        if (a.displayName < b.displayName) {
+                            return -1;
+                        }
+                        if (a.displayName > b.displayName) {
+                            return 1;
+                        }
+                    }
+                    return 0;
+                });
+            }
+        }
+        else {
+            parameters.push(constants_1.commonDeclarativeNodeOptionParameters);
+        }
+        return;
+    }
+}
+exports.DirectoryLoader = DirectoryLoader;

package/dist/lib/NodesLoader/index.d.ts

@@ -0,0 +1,5 @@
+export { CustomDirectoryLoader } from "./custom-directory-loader";
+export { DirectoryLoader, type Types } from "./directory-loader";
+export { LazyPackageDirectoryLoader } from "./lazy-package-directory-loader";
+export { PackageDirectoryLoader } from "./package-directory-loader";
+export type { n8n } from "./types";

package/dist/lib/NodesLoader/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageDirectoryLoader = exports.LazyPackageDirectoryLoader = exports.DirectoryLoader = exports.CustomDirectoryLoader = void 0;
+var custom_directory_loader_1 = require("./custom-directory-loader");
+Object.defineProperty(exports, "CustomDirectoryLoader", { enumerable: true, get: function () { return custom_directory_loader_1.CustomDirectoryLoader; } });
+var directory_loader_1 = require("./directory-loader");
+Object.defineProperty(exports, "DirectoryLoader", { enumerable: true, get: function () { return directory_loader_1.DirectoryLoader; } });
+var lazy_package_directory_loader_1 = require("./lazy-package-directory-loader");
+Object.defineProperty(exports, "LazyPackageDirectoryLoader", { enumerable: true, get: function () { return lazy_package_directory_loader_1.LazyPackageDirectoryLoader; } });
+var package_directory_loader_1 = require("./package-directory-loader");
+Object.defineProperty(exports, "PackageDirectoryLoader", { enumerable: true, get: function () { return package_directory_loader_1.PackageDirectoryLoader; } });

package/dist/lib/NodesLoader/lazy-package-directory-loader.d.ts

@@ -0,0 +1,7 @@
+import { PackageDirectoryLoader } from "./package-directory-loader";
+/**
+ * This loader extends PackageDirectoryLoader to load node and credentials lazily, if possible
+ */
+export declare class LazyPackageDirectoryLoader extends PackageDirectoryLoader {
+    loadAll(): Promise<void>;
+}

package/dist/lib/NodesLoader/lazy-package-directory-loader.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyPackageDirectoryLoader = void 0;
+const package_directory_loader_1 = require("./package-directory-loader");
+/**
+ * This loader extends PackageDirectoryLoader to load node and credentials lazily, if possible
+ */
+class LazyPackageDirectoryLoader extends package_directory_loader_1.PackageDirectoryLoader {
+    async loadAll() {
+        try {
+            this.known.nodes = await this.readJSON("dist/known/nodes.json");
+            this.known.credentials = await this.readJSON("dist/known/credentials.json");
+            this.types.nodes = await this.readJSON("dist/types/nodes.json");
+            this.types.credentials = await this.readJSON("dist/types/credentials.json");
+            if (this.includeNodes.length) {
+                const allowedNodes = {};
+                for (const nodeType of this.includeNodes) {
+                    if (nodeType in this.known.nodes) {
+                        allowedNodes[nodeType] = this.known.nodes[nodeType];
+                    }
+                }
+                this.known.nodes = allowedNodes;
+                this.types.nodes = this.types.nodes.filter((nodeType) => this.includeNodes.includes(nodeType.name));
+            }
+            if (this.excludeNodes.length) {
+                for (const nodeType of this.excludeNodes) {
+                    delete this.known.nodes[nodeType];
+                }
+                this.types.nodes = this.types.nodes.filter((nodeType) => !this.excludeNodes.includes(nodeType.name));
+            }
+            console.debug(`Lazy-loading nodes and credentials from ${this.packageJson.name}`, {
+                nodes: this.types.nodes?.length ?? 0,
+                credentials: this.types.credentials?.length ?? 0,
+            });
+            this.isLazyLoaded = true;
+            return; // We can load nodes and credentials lazily now
+        }
+        catch {
+            console.debug("Can't enable lazy-loading");
+            await super.loadAll();
+        }
+    }
+}
+exports.LazyPackageDirectoryLoader = LazyPackageDirectoryLoader;

package/dist/lib/NodesLoader/load-class-in-isolation.d.ts

@@ -0,0 +1 @@
+export declare const loadClassInIsolation: <T>(filePath: string, className: string) => T;