oc 0.49.7 → 0.49.8

package/dist/cli/facade/dev.js

@@ -22,12 +22,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const async_1 = __importDefault(require("async"));
 const safe_1 = __importDefault(require("colors/safe"));
 const getport_1 = __importDefault(require("getport"));
 const livereload_1 = __importDefault(require("livereload"));
 const path_1 = __importDefault(require("path"));
-const lodash_1 = __importDefault(require("lodash"));
+const util_1 = require("util");
+const universalify_1 = require("universalify");
 const get_mocked_plugins_1 = __importDefault(require("../domain/get-mocked-plugins"));
 const handle_dependencies_1 = __importDefault(require("../domain/handle-dependencies"));
 const oc = __importStar(require("../../index"));
@@ -35,7 +35,9 @@ const index_1 = __importDefault(require("../../resources/index"));
 const watch_1 = __importDefault(require("../domain/watch"));
 const cliMessages = index_1.default.messages.cli;
 const cliErrors = index_1.default.errors.cli;
-const dev = ({ local, logger }) => (opts, callback) => {
+const delay = (time = 0) => new Promise(res => setTimeout(res, time));
+const getPort = (0, util_1.promisify)(getport_1.default);
+const dev = ({ local, logger }) => (0, universalify_1.fromPromise)(async (opts) => {
     const componentsDir = opts.dirPath;
     const port = opts.port || 3000;
     const baseUrl = opts.baseUrl || `http://localhost:${port}/`;
@@ -62,13 +64,11 @@ const dev = ({ local, logger }) => (opts, callback) => {
             }
         });
     };
-    const packageComponents = (componentsDirs, optCb) => {
-        const cb = typeof optCb === 'function' ? optCb : lodash_1.default.noop;
-        let i = 0;
+    const packageComponents = async (componentsDirs) => {
         if (!packaging) {
             packaging = true;
             logger.warn(cliMessages.PACKAGING_COMPONENTS, false);
-            async_1.default.eachSeries(componentsDirs, (dir, cb) => {
+            for (const dir of componentsDirs) {
                 logger.warn(cliMessages.PACKAGING(dir), false);
                 const packageOptions = {
                     componentPath: dir,
@@ -76,29 +76,22 @@ const dev = ({ local, logger }) => (opts, callback) => {
                     verbose: opts.verbose,
                     production: opts.production
                 };
-                local.package(packageOptions, err => {
-                    if (!err)
-                        i++;
-                    cb(err);
-                });
-            }, error => {
-                if (error) {
+                try {
+                    await local.package(packageOptions);
+                    packaging = false;
+                    logger.ok('OK');
+                }
+                catch (error) {
                     const errorDescription = error instanceof SyntaxError || !!error.message
                         ? error.message
                         : error;
-                    logger.err(cliErrors.PACKAGING_FAIL(componentsDirs[i], String(errorDescription)));
+                    logger.err(cliErrors.PACKAGING_FAIL(dir, String(errorDescription)));
                     logger.warn(cliMessages.RETRYING_10_SECONDS);
-                    setTimeout(() => {
-                        packaging = false;
-                        packageComponents(componentsDirs);
-                    }, 10000);
-                }
-                else {
+                    await delay(10000);
                     packaging = false;
-                    logger.ok('OK');
-                    cb();
+                    packageComponents(componentsDirs);
                 }
-            });
+            }
         }
     };
     const registerPlugins = (registry) => {
@@ -106,85 +99,78 @@ const dev = ({ local, logger }) => (opts, callback) => {
         mockedPlugins.forEach(p => registry.register(p));
         registry.on('request', data => {
             if (data.errorCode === 'PLUGIN_MISSING_FROM_REGISTRY') {
-                logger.err(cliErrors.PLUGIN_MISSING_FROM_REGISTRY(data.errorDetails, safe_1.default.blue(index_1.default.commands.cli.MOCK_PLUGIN)));
+                logger.err(cliErrors.PLUGIN_MISSING_FROM_REGISTRY(String(data.errorDetails), safe_1.default.blue(index_1.default.commands.cli.MOCK_PLUGIN)));
             }
         });
     };
     logger.warn(cliMessages.SCANNING_COMPONENTS, true);
-    local.getComponentsByDir(componentsDir, opts.components, (err, components) => {
-        if (lodash_1.default.isEmpty(components)) {
-            err = cliErrors.DEV_FAIL(cliErrors.COMPONENTS_NOT_FOUND);
-            callback(err, undefined);
-            return logger.err(String(err));
-        }
-        logger.ok('OK');
-        lodash_1.default.forEach(components, component => logger.log(safe_1.default.green('├── ') + component));
-        (0, handle_dependencies_1.default)({ components, logger }, (err, dependencies) => {
-            if (err) {
-                logger.err(err);
-                return callback(err, undefined);
-            }
-            packageComponents(components, () => {
-                async_1.default.waterfall([
-                    (next) => {
-                        if (hotReloading) {
-                            (0, getport_1.default)(port + 1, (error, otherPort) => {
-                                if (error) {
-                                    return next(error);
-                                }
-                                const liveReloadServer = livereload_1.default.createServer({
-                                    port: otherPort
-                                });
-                                const refresher = () => liveReloadServer.refresh('/');
-                                next(null, { refresher, port: otherPort });
-                            });
-                        }
-                        else {
-                            next(null, { refresher: lodash_1.default.noop, port: null });
-                        }
-                    }
-                ], (err, liveReload) => {
-                    if (err) {
-                        logger.err(String(err));
-                        return callback(err, undefined);
-                    }
-                    const registry = oc.Registry({
-                        baseUrl,
-                        prefix: opts.prefix || '',
-                        dependencies: dependencies.modules,
-                        discovery: true,
-                        env: { name: 'local' },
-                        fallbackRegistryUrl,
-                        hotReloading,
-                        liveReloadPort: liveReload.port,
-                        local: true,
-                        components: opts.components,
-                        path: path_1.default.resolve(componentsDir),
-                        port,
-                        templates: dependencies.templates,
-                        verbosity: 1
-                    });
-                    registerPlugins(registry);
-                    logger.warn(cliMessages.REGISTRY_STARTING(baseUrl));
-                    if (liveReload.port) {
-                        logger.warn(cliMessages.REGISTRY_LIVERELOAD_STARTING(liveReload.port));
-                    }
-                    registry.start(err => {
-                        if (err) {
-                            if (err.code === 'EADDRINUSE') {
-                                err = cliErrors.PORT_IS_BUSY(port);
-                            }
-                            logger.err(String(err));
-                            return callback(err, undefined);
-                        }
-                        if (optWatch) {
-                            watchForChanges({ components, refreshLiveReload: liveReload.refresher }, packageComponents);
-                        }
-                        callback(null, registry);
-                    });
-                });
-            });
+    const components = await local.getComponentsByDir(componentsDir, opts.components);
+    if (!components.length) {
+        const err = cliErrors.DEV_FAIL(cliErrors.COMPONENTS_NOT_FOUND);
+        logger.err(err);
+        throw err;
+    }
+    logger.ok('OK');
+    components.forEach(component => logger.log(safe_1.default.green('├── ') + component));
+    const dependencies = await (0, handle_dependencies_1.default)({
+        components,
+        logger
+    }).catch(err => {
+        logger.err(err);
+        return Promise.reject(err);
+    });
+    await packageComponents(components);
+    let liveReload = {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        refresher: () => { },
+        port: undefined
+    };
+    if (hotReloading) {
+        const otherPort = await getPort(port + 1).catch(err => {
+            logger.err(String(err));
+            return Promise.reject(err);
+        });
+        const liveReloadServer = livereload_1.default.createServer({
+            port: otherPort
         });
+        const refresher = () => liveReloadServer.refresh('/');
+        liveReload = { refresher, port: otherPort };
+    }
+    const registry = oc.Registry({
+        baseUrl,
+        prefix: opts.prefix || '',
+        dependencies: dependencies.modules,
+        discovery: true,
+        env: { name: 'local' },
+        fallbackRegistryUrl,
+        hotReloading,
+        liveReloadPort: liveReload.port,
+        local: true,
+        components: opts.components,
+        path: path_1.default.resolve(componentsDir),
+        port,
+        templates: dependencies.templates,
+        verbosity: 1
     });
-};
+    registerPlugins(registry);
+    logger.warn(cliMessages.REGISTRY_STARTING(baseUrl));
+    if (liveReload.port) {
+        logger.warn(cliMessages.REGISTRY_LIVERELOAD_STARTING(String(liveReload.port)));
+    }
+    try {
+        await (0, util_1.promisify)(registry.start);
+        if (optWatch) {
+            watchForChanges({ components, refreshLiveReload: liveReload.refresher }, packageComponents);
+        }
+        return registry;
+    }
+    catch (err) {
+        if (err.code === 'EADDRINUSE') {
+            // eslint-disable-next-line no-ex-assign
+            err = cliErrors.PORT_IS_BUSY(port);
+        }
+        logger.err(String(err));
+        throw err;
+    }
+});
 exports.default = dev;

package/dist/cli/facade/init.d.ts

@@ -3,9 +3,16 @@ import { Logger } from '../logger';
 declare const init: ({ local, logger }: {
     local: Local;
     logger: Logger;
-}) => (opts: {
-    componentName: string;
-    componentPath: string;
-    templateType: string;
-}, callback: (err: Error | null, data: string) => void) => void;
+}) => {
+    (opts: {
+        componentName: string;
+        componentPath: string;
+        templateType: string;
+    }): Promise<string>;
+    (arguments__0: {
+        componentName: string;
+        componentPath: string;
+        templateType: string;
+    }, arguments__1: (error: unknown, value: string) => void): void;
+};
 export default init;

package/dist/cli/facade/init.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
+const universalify_1 = require("universalify");
 const index_1 = __importDefault(require("../../resources/index"));
-const init = ({ local, logger }) => (opts, callback) => {
+const init = ({ local, logger }) => (0, universalify_1.fromPromise)(async (opts) => {
     const templateType = typeof opts.templateType === 'undefined'
         ? 'oc-template-es6'
         : opts.templateType;
@@ -13,25 +14,26 @@ const init = ({ local, logger }) => (opts, callback) => {
     const messages = index_1.default.messages.cli;
     const componentPath = path_1.default.join(process.cwd(), opts.componentPath);
     const componentName = path_1.default.basename(componentPath);
-    local.init({
-        componentName,
-        componentPath,
-        templateType,
-        logger
-    }, err => {
-        if (err) {
-            if (err === 'name not valid') {
-                err = errors.NAME_NOT_VALID;
-            }
-            if (err === 'template type not valid') {
-                err = errors.TEMPLATE_TYPE_NOT_VALID(templateType);
-            }
-            logger.err(errors.INIT_FAIL(err));
+    try {
+        await local.init({
+            componentName,
+            componentPath,
+            templateType,
+            logger
+        });
+        logger.log(messages.initSuccess(componentName, componentPath));
+        return componentName;
+    }
+    catch (err) {
+        let errMsg = String(err);
+        if (err === 'name not valid') {
+            errMsg = errors.NAME_NOT_VALID;
         }
-        else {
-            logger.log(messages.initSuccess(componentName, componentPath));
+        else if (err === 'template type not valid') {
+            errMsg = errors.TEMPLATE_TYPE_NOT_VALID(templateType);
         }
-        callback(err, componentName);
-    });
-};
+        logger.err(errors.INIT_FAIL(errMsg));
+        throw err;
+    }
+});
 exports.default = init;

package/dist/cli/facade/mock.d.ts

@@ -3,9 +3,16 @@ import { Logger } from '../logger';
 declare const mock: ({ local, logger }: {
     local: Local;
     logger: Logger;
-}) => (opts: {
-    targetType: string;
-    targetValue: string;
-    targetName: string;
-}, callback: (err: unknown) => void) => void;
+}) => {
+    (opts: {
+        targetType: string;
+        targetValue: string;
+        targetName: string;
+    }): Promise<void>;
+    (arguments__0: {
+        targetType: string;
+        targetValue: string;
+        targetName: string;
+    }, arguments__1: (error: unknown, value: void) => void): void;
+};
 export default mock;

package/dist/cli/facade/mock.js

@@ -3,11 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const universalify_1 = require("universalify");
 const index_1 = __importDefault(require("../../resources/index"));
-const mock = ({ local, logger }) => (opts, callback) => {
-    local.mock(opts, err => {
-        logger.ok(index_1.default.messages.cli.MOCKED_PLUGIN(opts.targetName, opts.targetValue));
-        callback(err);
-    });
-};
+const mock = ({ local, logger }) => (0, universalify_1.fromPromise)(async (opts) => {
+    await local.mock(opts);
+    logger.ok(index_1.default.messages.cli.MOCKED_PLUGIN(opts.targetName, opts.targetValue));
+});
 exports.default = mock;

package/dist/cli/facade/package.d.ts

@@ -3,9 +3,16 @@ import { Component, Local } from '../../types';
 declare const cliPackage: ({ local, logger }: {
     local: Local;
     logger: Logger;
-}) => (opts: {
-    componentPath: string;
-    useComponentDependencies?: boolean;
-    compress?: boolean;
-}, callback: (err: string | null, data: Component) => void) => void;
+}) => {
+    (opts: {
+        componentPath: string;
+        useComponentDependencies?: boolean | undefined;
+        compress?: boolean | undefined;
+    }): Promise<Component>;
+    (arguments__0: {
+        componentPath: string;
+        useComponentDependencies?: boolean | undefined;
+        compress?: boolean | undefined;
+    }, arguments__1: (error: unknown, value: Component) => void): void;
+};
 export default cliPackage;

package/dist/cli/facade/package.js

@@ -5,47 +5,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = __importDefault(require("../../resources/index"));
 const path_1 = __importDefault(require("path"));
+const universalify_1 = require("universalify");
 const handle_dependencies_1 = __importDefault(require("../domain/handle-dependencies"));
-const cliPackage = ({ local, logger }) => (opts, callback) => {
+const cliPackage = ({ local, logger }) => (0, universalify_1.fromPromise)(async (opts) => {
     const componentPath = opts.componentPath;
     const useComponentDependencies = opts.useComponentDependencies;
     const packageDir = path_1.default.resolve(componentPath, '_package');
     const compressedPackagePath = path_1.default.resolve(componentPath, 'package.tar.gz');
     logger.warn(index_1.default.messages.cli.PACKAGING(packageDir));
-    (0, handle_dependencies_1.default)({
-        components: [path_1.default.resolve(componentPath)],
-        logger,
-        useComponentDependencies
-    }, err => {
-        if (err) {
-            logger.err(err);
-            return callback(err, undefined);
-        }
+    try {
+        await (0, handle_dependencies_1.default)({
+            components: [path_1.default.resolve(componentPath)],
+            logger,
+            useComponentDependencies
+        });
         const packageOptions = {
             production: true,
             componentPath: path_1.default.resolve(componentPath)
         };
-        local.package(packageOptions, (err, component) => {
-            if (err) {
-                logger.err(index_1.default.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
-                return callback(err, undefined);
-            }
-            logger.ok(index_1.default.messages.cli.PACKAGED(packageDir));
-            if (opts.compress) {
-                logger.warn(index_1.default.messages.cli.COMPRESSING(compressedPackagePath));
-                local.compress(packageDir, compressedPackagePath, err => {
-                    if (err) {
-                        logger.err(index_1.default.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
-                        return callback(err, undefined);
-                    }
-                    logger.ok(index_1.default.messages.cli.COMPRESSED(compressedPackagePath));
-                    callback(null, component);
-                });
-            }
-            else {
-                callback(null, component);
-            }
+        const component = await local.package(packageOptions).catch(err => {
+            logger.err(index_1.default.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
+            return Promise.reject(err);
         });
-    });
-};
+        logger.ok(index_1.default.messages.cli.PACKAGED(packageDir));
+        if (opts.compress) {
+            logger.warn(index_1.default.messages.cli.COMPRESSING(compressedPackagePath));
+            await local.compress(packageDir, compressedPackagePath).catch(err => {
+                logger.err(index_1.default.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
+                return Promise.reject(err);
+            });
+            logger.ok(index_1.default.messages.cli.COMPRESSED(compressedPackagePath));
+            return component;
+        }
+        else {
+            return component;
+        }
+    }
+    catch (err) {
+        logger.err(String(err));
+        throw err;
+    }
+});
 exports.default = cliPackage;

package/dist/cli/facade/preview.d.ts

@@ -3,7 +3,12 @@ import { Logger } from '../logger';
 declare const preview: ({ logger, registry }: {
     logger: Logger;
     registry: RegistryCli;
-}) => (opts: {
-    componentHref: string;
-}, callback: (err: string | null, data: string) => void) => void;
+}) => {
+    (opts: {
+        componentHref: string;
+    }): Promise<string>;
+    (arguments__0: {
+        componentHref: string;
+    }, arguments__1: (error: unknown, value: string) => void): void;
+};
 export default preview;

package/dist/cli/facade/preview.js

@@ -4,15 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const open_1 = __importDefault(require("open"));
+const universalify_1 = require("universalify");
 const index_1 = __importDefault(require("../../resources/index"));
-const preview = ({ logger, registry }) => (opts, callback) => {
-    registry.getComponentPreviewUrlByUrl(opts.componentHref, (err, href) => {
-        if (err) {
-            logger.err(index_1.default.errors.cli.COMPONENT_HREF_NOT_FOUND);
-            return callback(index_1.default.errors.cli.COMPONENT_HREF_NOT_FOUND, undefined);
-        }
-        (0, open_1.default)(href);
-        callback(null, href);
-    });
-};
+const preview = ({ logger, registry }) => (0, universalify_1.fromPromise)(async (opts) => {
+    try {
+        const href = await registry.getComponentPreviewUrlByUrl(opts.componentHref);
+        await (0, open_1.default)(href);
+        return href;
+    }
+    catch (err) {
+        logger.err(index_1.default.errors.cli.COMPONENT_HREF_NOT_FOUND);
+        throw index_1.default.errors.cli.COMPONENT_HREF_NOT_FOUND;
+    }
+});
 exports.default = preview;

package/dist/cli/facade/publish.d.ts

@@ -4,11 +4,20 @@ declare const publish: ({ logger, registry, local }: {
     logger: Logger;
     registry: RegistryCli;
     local: Local;
-}) => (opts: {
-    componentPath: string;
-    skipPackage?: boolean;
-    username?: string;
-    password?: string;
-    registries?: string[];
-}, callback: (err?: string | Error | undefined) => void) => void;
+}) => {
+    (opts: {
+        componentPath: string;
+        skipPackage?: boolean | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        registries?: string[] | undefined;
+    }): Promise<void>;
+    (arguments__0: {
+        componentPath: string;
+        skipPackage?: boolean | undefined;
+        username?: string | undefined;
+        password?: string | undefined;
+        registries?: string[] | undefined;
+    }, arguments__1: (error: unknown, value: void) => void): void;
+};
 export default publish;