noflo 1.4.3 → 1.5.1

package/lib/ProcessOutput.d.ts

@@ -6,7 +6,7 @@ export default class ProcessOutput {
     constructor(ports: import("./Ports").OutPorts, context: import("./ProcessContext").default);
     ports: import("./Ports").OutPorts;
     context: import("./ProcessContext").default;
-    nodeInstance: import("./Component").Component;
+    nodeInstance: import("./Component.js").Component;
     ip: IP;
     result: {
         [x: string]: any;
@@ -47,4 +47,4 @@ export default class ProcessOutput {
      */
     done(error?: Error | Array<Error>): void;
 }
-import IP from "./IP";
+import IP from "./IP.js";

package/lib/ProcessOutput.js

@@ -6,8 +6,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-underscore-dangle */
 const debug_1 = require("debug");
-const IP_1 = require("./IP");
-const debugComponent = debug_1.default('noflo:component');
+const IP_js_1 = require("./IP.js");
+const debugComponent = (0, debug_1.default)('noflo:component');
 // Checks if a value is an Error
 /**
  * @param {any} err
@@ -40,11 +40,11 @@ class ProcessOutput {
         if (this.ports.ports.error
             && (this.ports.ports.error.isAttached() || !this.ports.ports.error.isRequired())) {
             if (errs.length > 1) {
-                this.sendIP('error', new IP_1.default('openBracket'));
+                this.sendIP('error', new IP_js_1.default('openBracket'));
             }
             errs.forEach((e) => { this.sendIP('error', e); });
             if (errs.length > 1) {
-                this.sendIP('error', new IP_1.default('closeBracket'));
+                this.sendIP('error', new IP_js_1.default('closeBracket'));
             }
         }
         else {
@@ -58,7 +58,7 @@ class ProcessOutput {
      * @returns {void}
      */
     sendIP(port, packet) {
-        const ip = IP_1.default.isIP(packet) ? packet : new IP_1.default('data', packet);
+        const ip = IP_js_1.default.isIP(packet) ? packet : new IP_js_1.default('data', packet);
         if ((this.scope !== null) && (ip.scope === null)) {
             ip.scope = this.scope;
         }

package/lib/loader/NodeJs.d.ts

@@ -55,7 +55,6 @@ export function register(loader: import("../ComponentLoader").ComponentLoader, c
 export function dynamicLoad(name: string, cPath: string, metadata: any, callback: ModuleLoadingCallback): void;
 export type ErrorableCallback = (error: Error | null) => any;
 export type TranspileCallback = (error: Error | null, source?: string) => void;
-export type EvaluationCallback = (error: Error | null, module?: any | Function) => void;
 export type SourceCallback = (error: Error | null, source?: any, name?: string, library?: string, code?: string, language?: string, tests?: string) => void;
 export type RegistrationCallback = (error: Error | null, modules?: {
     [x: string]: string;

package/lib/loader/NodeJs.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dynamicLoad = exports.register = exports.getLanguages = exports.getSource = exports.setSource = void 0;
 /* eslint-disable
@@ -11,25 +12,29 @@ const path = require("path");
 const fs = require("fs");
 const manifest = require("fbp-manifest");
 const fbpGraph = require("fbp-graph");
-const utils = require("../Utils");
+const util_1 = require("util");
+const utils = require("../Utils.js");
+const writeFile = (0, util_1.promisify)(fs.writeFile);
+const readFile = (0, util_1.promisify)(fs.readFile);
 // Type loading CoffeeScript compiler
 let CoffeeScript;
-try {
-    // eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
-    CoffeeScript = require('coffeescript');
-}
-catch (e) {
+// eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
+Promise.resolve().then(() => require('coffeescript')).then((compiler) => {
+    CoffeeScript = compiler;
+})
+    .catch((e) => {
     // If there is no CoffeeScript compiler installed, we simply don't support compiling
-}
+});
 // Try loading TypeScript compiler
 let typescript;
-try {
-    // eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
-    typescript = require('typescript');
-}
-catch (e) {
+// eslint-disable-next-line import/no-unresolved,import/no-extraneous-dependencies
+Promise.resolve().then(() => require('typescript')).then((compiler) => {
+    // @ts-ignore
+    typescript = compiler.default;
+})
+    .catch((e) => {
     // If there is no TypeScript compiler installed, we simply don't support compiling
-}
+});
 /**
  * @callback ErrorableCallback
  * @param {Error|null} error
@@ -45,15 +50,14 @@ catch (e) {
  * @param {string} name
  * @param {string} source
  * @param {string} language
- * @param {TranspileCallback} callback
- * @returns {void}
+ * @returns {Promise<string>}
  */
-function transpileSource(packageId, name, source, language, callback) {
+function transpileSource(packageId, name, source, language) {
     let src;
     switch (language) {
         case 'coffeescript': {
             if (!CoffeeScript) {
-                callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no CoffeeScript compiler installed`));
+                return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no CoffeeScript compiler installed`));
             }
             try {
                 src = CoffeeScript.compile(source, {
@@ -61,24 +65,22 @@ function transpileSource(packageId, name, source, language, callback) {
                 });
             }
             catch (err) {
-                callback(err);
-                return;
+                return Promise.reject(err);
             }
             break;
         }
         case 'typescript': {
             if (!typescript) {
-                callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no TypeScript compiler installed`));
+                return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}: no TypeScript compiler installed`));
             }
             try {
                 src = typescript.transpile(source, {
                     module: typescript.ModuleKind.CommonJS,
-                    target: typescript.ScriptTarget.ES2015,
+                    target: typescript.ScriptTarget.ES2020,
                 });
             }
             catch (err) {
-                callback(err);
-                return;
+                return Promise.reject(err);
             }
             break;
         }
@@ -90,49 +92,40 @@ function transpileSource(packageId, name, source, language, callback) {
             break;
         }
         default: {
-            callback(new Error(`Unsupported component source language ${language} for ${packageId}/${name}`));
-            return;
+            return Promise.reject(new Error(`Unsupported component source language ${language} for ${packageId}/${name}`));
         }
     }
-    callback(null, src);
+    return Promise.resolve(src);
 }
-/**
- * @callback EvaluationCallback
- * @param {Error|null} error
- * @param {Object|Function} [module]
- * @returns {void}
- */
 /**
  * @param {string} baseDir
  * @param {string} packageId
  * @param {string} name
  * @param {string} source
- * @param {EvaluationCallback} callback
- * @returns {void}
+ * @returns {Promise<Object|Function>}
  */
-function evaluateModule(baseDir, packageId, name, source, callback) {
-    const Module = require('module');
-    let implementation;
-    try {
+function evaluateModule(baseDir, packageId, name, source) {
+    return Promise.resolve().then(() => require('module')).then(({ Module }) => {
+        let implementation;
         // Use the Node.js module API to evaluate in the correct directory context
-        const modulePath = path.resolve(baseDir, `./components/${name}.js`);
-        const moduleImpl = new Module(modulePath, module);
+        let extension = '.js';
+        if (source.indexOf('require(') !== -1) {
+            // CommonJS
+            extension = '.cjs';
+        }
+        const modulePath = path.resolve(baseDir, `./components/${name}${extension}`);
+        const moduleImpl = new Module(modulePath);
         // @ts-ignore
         moduleImpl.paths = Module._nodeModulePaths(path.dirname(modulePath));
         moduleImpl.filename = modulePath;
         // @ts-ignore
         moduleImpl._compile(source, modulePath);
         implementation = moduleImpl.exports;
-    }
-    catch (e) {
-        callback(e);
-        return;
-    }
-    if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
-        callback(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
-        return;
-    }
-    callback(null, implementation);
+        if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
+            return Promise.reject(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
+        }
+        return Promise.resolve(implementation);
+    });
 }
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
@@ -168,28 +161,29 @@ function registerSpecs(loader, packageId, name, specs) {
 }
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
- * @param {Object} module
- * @param {Object} component
+ * @param {import("fbp-manifest/dist/lib/list").FbpManifestModule} module
+ * @param {import("fbp-manifest/dist/lib/list").FbpManifestComponent} component
  * @param {string} source
  * @param {string} language
- * @param {TranspileCallback} callback
- * @returns {void}
+ * @returns {Promise<void>}
  */
-function transpileAndRegisterForModule(loader, module, component, source, language, callback) {
-    transpileSource(module.name, component.name, source, language, (transpileError, src) => {
-        if (transpileError) {
-            callback(transpileError);
-            return;
-        }
+function transpileAndRegisterForModule(loader, module, component, source, language) {
+    return transpileSource(module.name, component.name, source, language)
+        .then((src) => {
         const moduleBase = path.resolve(loader.baseDir, module.base);
-        evaluateModule(moduleBase, module.name, component.name, src, (evalError, implementation) => {
-            if (evalError) {
-                callback(evalError);
-                return;
-            }
-            registerSources(loader, module.name, component.name, source, language);
-            registerSpecs(loader, module.name, component.name, component.tests);
-            loader.registerComponent(module.name, component.name, implementation, callback);
+        return evaluateModule(moduleBase, module.name, component.name, src);
+    })
+        .then((implementation) => {
+        registerSources(loader, module.name, component.name, source, language);
+        registerSpecs(loader, module.name, component.name, component.tests || '');
+        return new Promise((resolve, reject) => {
+            loader.registerComponent(module.name, component.name, implementation, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
         });
     });
 }
@@ -206,9 +200,14 @@ function setSource(loader, packageId, name, source, language, callback) {
     transpileAndRegisterForModule(loader, {
         name: packageId,
         base: '',
+        components: [],
+        runtime: 'noflo',
     }, {
         name,
-    }, source, language, callback);
+    }, source, language)
+        .then(() => {
+        callback(null);
+    }, callback);
 }
 exports.setSource = setSource;
 /**
@@ -366,9 +365,14 @@ exports.getLanguages = getLanguages;
  */
 function registerCustomLoaders(loader, componentLoaders, callback) {
     componentLoaders.reduce((chain, componentLoader) => chain
-        .then(() => new Promise((resolve, reject) => {
-        const customLoader = require(componentLoader);
-        loader.registerLoader(customLoader, (err) => {
+        .then(() => { var _a; return _a = componentLoader, Promise.resolve().then(() => require(_a)); })
+        .then((customLoader) => new Promise((resolve, reject) => {
+        let loaderFunc = customLoader;
+        if (typeof customLoader === 'object' && customLoader.default) {
+            // CommonJS loader
+            loaderFunc = customLoader.default;
+        }
+        loader.registerLoader(loaderFunc, (err) => {
             if (err) {
                 reject(err);
                 return;
@@ -382,17 +386,18 @@ function registerCustomLoaders(loader, componentLoaders, callback) {
 }
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
- * @param {Array<Object>} modules
+ * @param {Array<import("fbp-manifest/dist/lib/list").FbpManifestModule>} modules
  * @param {ErrorableCallback} callback
  */
 function registerModules(loader, modules, callback) {
     const compatible = modules.filter((m) => ['noflo', 'noflo-nodejs'].includes(m.runtime));
+    /** @type {string[]} */
     const componentLoaders = [];
     Promise.all(compatible.map((m) => {
         if (m.icon) {
             loader.setLibraryIcon(m.name, m.icon);
         }
-        if (m.noflo != null ? m.noflo.loader : undefined) {
+        if (m.noflo && m.noflo.loader) {
             const loaderPath = path.resolve(loader.baseDir, m.base, m.noflo.loader);
             componentLoaders.push(loaderPath);
         }
@@ -400,19 +405,9 @@ function registerModules(loader, modules, callback) {
             const language = utils.guessLanguageFromFilename(c.path);
             if (language === 'typescript' || language === 'coffeescript') {
                 // We can't require a module that requires transpilation, go the setSource route
-                fs.readFile(path.resolve(loader.baseDir, c.path), 'utf-8', (fsErr, source) => {
-                    if (fsErr) {
-                        reject(fsErr);
-                        return;
-                    }
-                    transpileAndRegisterForModule(loader, m, c, source, language, (err) => {
-                        if (err) {
-                            reject(err);
-                            return;
-                        }
-                        resolve();
-                    });
-                });
+                readFile(path.resolve(loader.baseDir, c.path), 'utf-8')
+                    .then((source) => transpileAndRegisterForModule(loader, m, c, source, language))
+                    .then(resolve, reject);
                 return;
             }
             registerSpecs(loader, m.name, c.name, c.tests);
@@ -432,51 +427,59 @@ function registerModules(loader, modules, callback) {
 const dynamicLoader = {
     /**
      * @param {import("../ComponentLoader").ComponentLoader} loader
-     * @param {Object} manifestOptions
+     * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} manifestOptions
      * @param {Function} callback
      */
     listComponents(loader, manifestOptions, callback) {
         const opts = manifestOptions;
         opts.discover = true;
-        manifest.list.list(loader.baseDir, opts, (err, modules) => {
-            if (err) {
-                callback(err);
-                return;
-            }
-            registerModules(loader, modules, (err2) => {
-                if (err2) {
-                    callback(err2);
+        manifest.list.list(loader.baseDir, opts)
+            .then((modules) => new Promise((resolve, reject) => {
+            registerModules(loader, modules, (err) => {
+                if (err) {
+                    reject(err);
                     return;
                 }
-                callback(null, modules);
+                resolve(modules);
             });
+        }))
+            .then((modules) => {
+            callback(null, modules);
+        }, (err) => {
+            callback(err);
         });
     },
 };
 const manifestLoader = {
     /**
      * @param {import("../ComponentLoader").ComponentLoader} loader
-     * @param {Object} options
+     * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} options
      * @param {Object} manifestContents
-     * @param {ErrorableCallback} callback
+     * @param {import("fbp-manifest/src/lib/list").FbpManifestDocument} manifestContents
+     * @returns {Promise<import("fbp-manifest/dist/lib/list").FbpManifestDocument>}
      */
-    writeCache(loader, options, manifestContents, callback) {
-        const filePath = path.resolve(loader.baseDir, options.manifest);
-        fs.writeFile(filePath, JSON.stringify(manifestContents, null, 2), { encoding: 'utf-8' }, callback);
+    writeCache(loader, options, manifestContents) {
+        const manifestName = options.manifest || 'fbp.json';
+        const filePath = path.resolve(loader.baseDir, manifestName);
+        return writeFile(filePath, JSON.stringify(manifestContents, null, 2), {
+            encoding: 'utf-8',
+        })
+            .then(() => manifestContents);
     },
     /**
      * @param {import("../ComponentLoader").ComponentLoader} loader
-     * @param {Object} options
-     * @param {Function} callback
+     * @param {import("fbp-manifest/dist/lib/list").FbpManifestOptions} options
+     * @returns {Promise<import("fbp-manifest/dist/lib/list").FbpManifestDocument>}
      */
-    readCache(loader, options, callback) {
-        const opts = options;
-        opts.discover = false;
-        manifest.load.load(loader.baseDir, opts, callback);
+    readCache(loader, options) {
+        return manifest.load.load(loader.baseDir, {
+            ...options,
+            discover: false,
+        });
     },
     /**
      * @param {import("../ComponentLoader").ComponentLoader} loader
-     * @returns {Object}
+     * @returns {import("fbp-manifest/dist/lib/list").FbpManifestOptions}
      */
     prepareManifestOptions(loader) {
         const l = loader;
@@ -498,37 +501,41 @@ const manifestLoader = {
      * @param {Function} callback
      */
     listComponents(loader, manifestOptions, callback) {
-        this.readCache(loader, manifestOptions, (err, manifestContents) => {
-            if (err) {
-                if (!loader.options.discover) {
-                    callback(err);
-                    return;
-                }
+        this.readCache(loader, manifestOptions)
+            .catch((err) => {
+            if (!loader.options.discover) {
+                return Promise.reject(err);
+            }
+            return new Promise((resolve, reject) => {
                 dynamicLoader.listComponents(loader, manifestOptions, (err2, modules) => {
                     if (err2) {
-                        callback(err2);
+                        reject(err2);
                         return;
                     }
-                    this.writeCache(loader, manifestOptions, {
-                        version: 1,
-                        modules,
-                    }, (err3) => {
-                        if (err3) {
-                            callback(err3);
-                            return;
-                        }
-                        callback(null, modules);
-                    });
+                    resolve(modules);
                 });
-                return;
-            }
-            registerModules(loader, manifestContents.modules, (err2) => {
-                if (err2) {
-                    callback(err2);
+            })
+                .then((modules) => {
+                const manifestContents = {
+                    version: 1,
+                    modules,
+                };
+                return this
+                    .writeCache(loader, manifestOptions, manifestContents)
+                    .then(() => manifestContents);
+            });
+        })
+            .then((manifestContents) => {
+            registerModules(loader, manifestContents.modules, (err) => {
+                if (err) {
+                    callback(err);
                     return;
                 }
                 callback(null, manifestContents.modules);
             });
+        })
+            .catch((err) => {
+            callback(err);
         });
     },
 };
@@ -585,40 +592,24 @@ exports.register = register;
  * @param {ModuleLoadingCallback} callback
  */
 function dynamicLoad(name, cPath, metadata, callback) {
-    let implementation;
-    let instance;
-    try {
-        implementation = require(cPath);
-    }
-    catch (err) {
-        callback(err);
-        return;
-    }
-    if (typeof implementation.getComponent === 'function') {
-        try {
+    (_a = cPath, Promise.resolve().then(() => require(_a))).then((implementation) => {
+        let instance;
+        if (typeof implementation.getComponent === 'function') {
             instance = implementation.getComponent(metadata);
         }
-        catch (err) {
-            callback(err);
-            return;
-        }
-    }
-    else if (typeof implementation === 'function') {
-        try {
+        else if (typeof implementation === 'function') {
             instance = implementation(metadata);
         }
-        catch (err) {
-            callback(err);
-            return;
+        else {
+            throw new Error(`Unable to instantiate ${cPath}`);
         }
-    }
-    else {
-        callback(new Error(`Unable to instantiate ${cPath}`));
-        return;
-    }
-    if (typeof name === 'string') {
-        instance.componentName = name;
-    }
-    callback(null, instance);
+        if (typeof name === 'string') {
+            instance.componentName = name;
+        }
+        callback(null, instance);
+    })
+        .catch((e) => {
+        callback(e);
+    });
 }
 exports.dynamicLoad = dynamicLoad;

package/lib/loader/register.d.ts

@@ -1 +1 @@
-export * from "./NodeJs";
+export * from "./NodeJs.js";

package/lib/loader/register.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -13,8 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable
     global-require,
 */
-const Platform_1 = require("../Platform");
-if (Platform_1.isBrowser()) {
+const Platform_js_1 = require("../Platform.js");
+if ((0, Platform_js_1.isBrowser)()) {
     throw new Error('Generate NoFlo component loader for browsers with noflo-component-loader');
 }
-__exportStar(require("./NodeJs"), exports);
+__exportStar(require("./NodeJs.js"), exports);