noflo 1.4.2 → 1.5.0

package/lib/ProcessInput.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //     NoFlo may be freely distributed under the MIT license
 /* eslint-disable no-underscore-dangle */
 const debug_1 = require("debug");
-const debugComponent = debug_1.default('noflo:component');
+const IP_js_1 = require("./IP.js"); // eslint-disable-line no-unused-vars
+const debugComponent = (0, debug_1.default)('noflo:component');
 class ProcessInput {
     /**
      * @param {import("./Ports").InPorts} ports - Component inports
@@ -71,13 +72,9 @@ class ProcessInput {
     // Returns true if a port (or ports joined by logical AND) has a new IP
     // Passing a validation callback as a last argument allows more selective
     // checking of packets.
-    /**
-     * @callback HasValidationCallback
-     * @param {IP} ip
-     * @returns {boolean}
-     */
     /**
      * @typedef {string|Array<string|number>} GetArgument
+     * @typedef {import("./InPort").HasValidationCallback} HasValidationCallback
      */
     /**
      * @typedef {GetArgument|HasValidationCallback} HasArgument
@@ -86,13 +83,14 @@ class ProcessInput {
      * @param {...HasArgument} params
      */
     has(...params) {
+        /** @type {HasValidationCallback} */
         let validate;
         let args = params.filter((p) => typeof p !== 'function');
         if (!args.length) {
             args = ['in'];
         }
         if (typeof params[params.length - 1] === 'function') {
-            validate = params[params.length - 1];
+            validate = /** @type {HasValidationCallback} */ (params[params.length - 1]);
         }
         else {
             validate = () => true;
@@ -107,7 +105,8 @@ class ProcessInput {
                 if (!portImpl.isAddressable()) {
                     throw new Error(`Non-addressable ports, access must be with string ${port[0]}`);
                 }
-                if (!portImpl.has(this.scope, port[1], validate)) {
+                const portIdx = (typeof port[1] === 'string') ? parseInt(port[1], 10) : port[1];
+                if (!portImpl.has(this.scope, portIdx, validate)) {
                     return false;
                 }
             }
@@ -248,7 +247,7 @@ class ProcessInput {
             }
             else {
                 const portImpl = /** @type {import("./InPort").default} */ (this.ports.ports[name]);
-                ip = portImpl.get(this.scope, idx);
+                ip = portImpl.get(this.scope, idxName);
                 res.push(ip);
             }
         }

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

@@ -11,7 +11,10 @@ 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 {
@@ -45,15 +48,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,14 +63,13 @@ 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, {
@@ -77,8 +78,7 @@ function transpileSource(packageId, name, source, language, callback) {
                 });
             }
             catch (err) {
-                callback(err);
-                return;
+                return Promise.reject(err);
             }
             break;
         }
@@ -90,27 +90,19 @@ 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) {
+function evaluateModule(baseDir, packageId, name, source) {
     const Module = require('module');
     let implementation;
     try {
@@ -125,14 +117,12 @@ function evaluateModule(baseDir, packageId, name, source, callback) {
         implementation = moduleImpl.exports;
     }
     catch (e) {
-        callback(e);
-        return;
+        return Promise.reject(e);
     }
     if ((typeof implementation !== 'function') && (typeof implementation.getComponent !== 'function')) {
-        callback(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
-        return;
+        return Promise.reject(new Error(`Provided source for ${packageId}/${name} failed to create a runnable component`));
     }
-    callback(null, implementation);
+    return Promise.resolve(implementation);
 }
 /**
  * @param {import("../ComponentLoader").ComponentLoader} loader
@@ -168,28 +158,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 +197,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;
 /**
@@ -382,17 +378,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 +397,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 +419,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 +493,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);
         });
     },
 };

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);

package/package.json

@@ -8,7 +8,7 @@
     "noflo"
   ],
   "author": "Henri Bergius <henri.bergius@iki.fi>",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "license": "MIT",
   "engines": {
     "node": ">= 6"
@@ -17,7 +17,7 @@
     "debug": "^4.0.1",
     "fbp": "^1.5.0",
     "fbp-graph": "^0.7.0",
-    "fbp-manifest": "^0.2.7",
+    "fbp-manifest": "^0.3.1",
     "get-function-params": "^2.0.6"
   },
   "devDependencies": {
@@ -25,13 +25,13 @@
     "@types/node": "^14.14.2",
     "chai": "^4.0.0",
     "coffeescript": "^2.2.1",
-    "coveralls": "^3.0.0",
-    "eslint": "^7.7.0",
-    "eslint-config-airbnb-base": "^14.2.0",
+    "coveralls": "^2.7.1",
+    "eslint": "^8.2.0",
+    "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.22.0",
     "events": "^3.2.0",
     "flowtrace": "^0.1.8",
-    "karma": "^5.1.1",
+    "karma": "^6.0.0",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-mocha": "^2.0.1",
@@ -48,6 +48,7 @@
     "webpack-cli": "^4.0.0"
   },
   "main": "./lib/NoFlo",
+  "module": "./src/lib/NoFlo.js",
   "types": "./lib/NoFlo.d.ts",
   "bin": {
     "noflo": "./bin/noflo",
@@ -60,14 +61,18 @@
   },
   "scripts": {
     "lint": "eslint .",
-    "build:node": "tsc",
-    "build:browser": "webpack",
+    "dirname:to": "sed -i -e 's/import\\.meta\\.dirname/__dirname/g' src/lib/loader/NodeJs.js",
+    "build:node": "npm run dirname:to && tsc && npm run dirname:from",
+    "dirname:from": "sed -i -e 's/__dirname/import\\.meta\\.dirname/g' src/lib/loader/NodeJs.js",
+    "build:browser": "webpack --config webpack.config.cjs",
     "build": "npm run build:node && npm run build:browser",
     "postbuild": "replace 'node/events' 'events' lib -r",
     "pretest": "npm run lint && npm run build",
-    "test:node": "nyc mocha --require spec/utils/inject.js spec",
-    "test:browser": "karma start karma.config.js",
-    "test": "npm run test:node && npm run test:browser"
+    "test:esmodules": "node --test spec/*.mjs",
+    "test:commonjs": "node --test spec/*.cjs",
+    "test:node": "nyc mocha --require spec/utils/inject.js spec/*.js",
+    "test:browser": "karma start karma.config.cjs",
+    "test": "npm run test:esmodules && npm run test:commonjs && npm run test:node && npm run test:browser"
   },
   "docco_husky": {
     "output_dir": "docs",

package/spec/.eslintrc

@@ -7,6 +7,7 @@
         "global-require": 0,
         "import/no-extraneous-dependencies": 0,
         "import/no-unresolved": 0,
+        "import/extensions": 0,
         "no-console": 0,
         "no-param-reassign": 0,
         "no-plusplus": 0,
@@ -15,6 +16,8 @@
         "no-shadow": 0,
         "no-undef": 0,
         "no-unused-expressions": 0,
-        "prefer-destructuring": 0
+        "prefer-destructuring": 0,
+        "function-paren-newline": 0,
+        "function-call-argument-newline": 0
     }
-}
+}

package/spec/AsCallback.js

@@ -70,20 +70,16 @@ describe('asCallback interface', () => {
     return c;
   };
 
-  before((done) => {
+  before(() => {
     loader = new noflo.ComponentLoader(baseDir);
-    loader.listComponents((err) => {
-      if (err) {
-        done(err);
-        return;
-      }
-      loader.registerComponent('process', 'Async', processAsync);
-      loader.registerComponent('process', 'Error', processError);
-      loader.registerComponent('process', 'Values', processValues);
-      loader.registerComponent('process', 'NeverSend', neverSend);
-      loader.registerComponent('process', 'Streamify', streamify);
-      done();
-    });
+    return loader.listComponents()
+      .then(() => {
+        loader.registerComponent('process', 'Async', processAsync);
+        loader.registerComponent('process', 'Error', processError);
+        loader.registerComponent('process', 'Values', processValues);
+        loader.registerComponent('process', 'NeverSend', neverSend);
+        loader.registerComponent('process', 'Streamify', streamify);
+      });
   });
   describe('with a non-existing component', () => {
     let wrapped = null;

package/spec/AsComponent.js

@@ -202,8 +202,11 @@ describe('asComponent interface', () => {
       before(function () {
         if (isBrowser && (typeof window.Promise === 'undefined')) { return this.skip(); }
       });
-      const func = (hello) => new Promise((resolve) => setTimeout(() => resolve(`Hello ${hello}`),
-        5));
+      const func = (hello) => new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(`Hello ${hello}`);
+        }, 5);
+      });
       it('should be possible to componentize', (done) => {
         const component = () => noflo.asComponent(func);
         loader.registerComponent('ascomponent', 'promise-one', component, done);
@@ -227,8 +230,11 @@ describe('asComponent interface', () => {
           this.skip();
         }
       });
-      const func = (hello) => new Promise((resolve, reject) => setTimeout(() => reject(new Error(`Hello ${hello}`)),
-        5));
+      const func = (hello) => new Promise((resolve, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Hello ${hello}`));
+        }, 5);
+      });
       it('should be possible to componentize', (done) => {
         const component = () => noflo.asComponent(func);
         loader.registerComponent('ascomponent', 'sync-throw', component, done);