oc 0.49.7 → 0.49.8

package/dist/cli/domain/init-template/scaffold.js

@@ -6,25 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const resources_1 = __importDefault(require("../../../resources"));
-function scaffold(options, callback) {
+async function scaffold(options) {
     const { compiler, compilerPath, componentName, componentPath, templateType } = options;
     const baseComponentPath = path_1.default.join(compilerPath, 'scaffold');
     const baseComponentFiles = path_1.default.join(baseComponentPath, 'src');
-    const compilerPackage = fs_extra_1.default.readJsonSync(path_1.default.join(compilerPath, 'package.json'));
+    const compilerPackage = await fs_extra_1.default.readJson(path_1.default.join(compilerPath, 'package.json'));
     try {
-        fs_extra_1.default.copySync(baseComponentFiles, componentPath);
-        const componentPackage = fs_extra_1.default.readJsonSync(path_1.default.join(componentPath, 'package.json'));
+        await fs_extra_1.default.copy(baseComponentFiles, componentPath);
+        const componentPackage = await fs_extra_1.default.readJson(path_1.default.join(componentPath, 'package.json'));
         componentPackage.name = componentName;
         componentPackage.devDependencies[compiler] = compilerPackage.version;
-        fs_extra_1.default.writeJsonSync(componentPath + '/package.json', componentPackage, {
+        await fs_extra_1.default.writeJson(componentPath + '/package.json', componentPackage, {
             spaces: 2
         });
-        return callback(null, { ok: true });
+        return { ok: true };
     }
     catch (error) {
         const url = (compilerPackage.bugs && compilerPackage.bugs.url) ||
             `the ${templateType} repo`;
-        return callback(resources_1.default.errors.cli.scaffoldError(url, String(error)));
+        throw resources_1.default.errors.cli.scaffoldError(url, String(error));
     }
 }
 exports.default = scaffold;

package/dist/cli/domain/local.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const targz_1 = __importDefault(require("targz"));
+const util_1 = require("util");
 const clean = __importStar(require("./clean"));
 const get_components_by_dir_1 = __importDefault(require("./get-components-by-dir"));
 const init_template_1 = __importDefault(require("./init-template"));
@@ -35,11 +36,11 @@ const validator = __importStar(require("../../registry/domain/validators"));
 function local() {
     return {
         clean,
-        cleanup(compressedPackagePath, callback) {
-            return fs_extra_1.default.unlink(compressedPackagePath, callback);
+        cleanup(compressedPackagePath) {
+            return fs_extra_1.default.unlink(compressedPackagePath);
         },
-        compress(input, output, callback) {
-            return targz_1.default.compress({
+        compress(input, output) {
+            return (0, util_1.promisify)(targz_1.default.compress)({
                 src: input,
                 dest: output,
                 tar: {
@@ -49,14 +50,14 @@ function local() {
                         });
                     }
                 }
-            }, callback);
+            });
         },
         getComponentsByDir: (0, get_components_by_dir_1.default)(),
-        init(options, callback) {
+        async init(options) {
             const { componentName, logger } = options;
             let { templateType } = options;
             if (!validator.validateComponentName(componentName)) {
-                return callback('name not valid', undefined);
+                throw 'name not valid';
             }
             // LEGACY TEMPLATES WARNING
             if ((0, is_template_legacy_1.default)(templateType)) {
@@ -65,13 +66,13 @@ function local() {
                 logger.warn(resources_1.default.messages.cli.legacyTemplateDeprecationWarning(legacyName, templateType));
             }
             try {
-                (0, init_template_1.default)(Object.assign(options, {
+                await (0, init_template_1.default)(Object.assign(options, {
                     templateType,
                     compiler: `${templateType}-compiler`
-                }), callback);
+                }));
             }
             catch (e) {
-                return callback('template type not valid', undefined);
+                throw 'template type not valid';
             }
         },
         mock: (0, mock_1.default)(),

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

@@ -2,4 +2,4 @@ export default function mock(): (params: {
     targetType: string;
     targetValue: string;
     targetName: string;
-}, callback: (err: Error) => void) => void;
+}) => Promise<void>;

package/dist/cli/domain/mock.js

@@ -7,27 +7,27 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const settings_1 = __importDefault(require("../../resources/settings"));
 function mock() {
-    return function (params, callback) {
-        fs_extra_1.default.readJson(settings_1.default.configFile.src, (_err, localConfig) => {
-            localConfig = localConfig || {};
-            const mockType = params.targetType + 's';
-            if (!localConfig.mocks) {
-                localConfig.mocks = {};
-            }
-            if (!localConfig.mocks[mockType]) {
-                localConfig.mocks[mockType] = {};
-            }
-            let pluginType = 'static';
-            if (fs_extra_1.default.existsSync(path_1.default.resolve(params.targetValue.toString()))) {
-                pluginType = 'dynamic';
-            }
-            if (!localConfig.mocks[mockType][pluginType]) {
-                localConfig.mocks[mockType][pluginType] = {};
-            }
-            localConfig.mocks[mockType][pluginType][params.targetName] =
-                params.targetValue;
-            return fs_extra_1.default.writeJson(settings_1.default.configFile.src, localConfig, { spaces: 2 }, callback);
-        });
+    return async function (params) {
+        const localConfig = await fs_extra_1.default
+            .readJson(settings_1.default.configFile.src)
+            .catch(() => ({}));
+        const mockType = params.targetType + 's';
+        if (!localConfig.mocks) {
+            localConfig.mocks = {};
+        }
+        if (!localConfig.mocks[mockType]) {
+            localConfig.mocks[mockType] = {};
+        }
+        let pluginType = 'static';
+        if (fs_extra_1.default.existsSync(path_1.default.resolve(params.targetValue.toString()))) {
+            pluginType = 'dynamic';
+        }
+        if (!localConfig.mocks[mockType][pluginType]) {
+            localConfig.mocks[mockType][pluginType] = {};
+        }
+        localConfig.mocks[mockType][pluginType][params.targetName] =
+            params.targetValue;
+        return fs_extra_1.default.writeJson(settings_1.default.configFile.src, localConfig, { spaces: 2 });
     };
 }
 exports.default = mock;

package/dist/cli/domain/package-components.d.ts

@@ -5,5 +5,5 @@ interface PackageOptions {
     verbose?: boolean;
     production?: boolean;
 }
-declare const packageComponents: () => (options: PackageOptions, callback: (err: Error | null, data: Component) => void) => void;
+declare const packageComponents: () => (options: PackageOptions) => Promise<Component>;
 export default packageComponents;

package/dist/cli/domain/package-components.js

@@ -23,10 +23,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const util_1 = require("util");
 const path_1 = __importDefault(require("path"));
 const require_template_1 = __importDefault(require("./handle-dependencies/require-template"));
 const validator = __importStar(require("../../registry/domain/validators"));
-const packageComponents = () => (options, callback) => {
+const packageComponents = () => async (options) => {
     const production = options.production;
     const componentPath = options.componentPath;
     const minify = options.minify === true;
@@ -35,16 +36,16 @@ const packageComponents = () => (options, callback) => {
     const componentPackagePath = path_1.default.join(componentPath, 'package.json');
     const ocPackagePath = path_1.default.join(__dirname, '../../../package.json');
     if (!fs_extra_1.default.existsSync(componentPackagePath)) {
-        return callback(new Error('component does not contain package.json'), undefined);
+        throw new Error('component does not contain package.json');
     }
     else if (!fs_extra_1.default.existsSync(ocPackagePath)) {
-        return callback(new Error('error resolving oc internal dependencies'), undefined);
+        throw new Error('error resolving oc internal dependencies');
     }
-    fs_extra_1.default.emptyDirSync(publishPath);
-    const componentPackage = fs_extra_1.default.readJsonSync(componentPackagePath);
-    const ocPackage = fs_extra_1.default.readJsonSync(ocPackagePath);
+    await fs_extra_1.default.emptyDir(publishPath);
+    const componentPackage = await fs_extra_1.default.readJson(componentPackagePath);
+    const ocPackage = await fs_extra_1.default.readJson(ocPackagePath);
     if (!validator.validateComponentName(componentPackage.name)) {
-        return callback(new Error('name not valid'), undefined);
+        throw new Error('name not valid');
     }
     const type = componentPackage.oc.files.template.type;
     const compileOptions = {
@@ -56,15 +57,11 @@ const packageComponents = () => (options, callback) => {
         verbose,
         production
     };
-    try {
-        const ocTemplate = (0, require_template_1.default)(type, {
-            compiler: true,
-            componentPath
-        });
-        ocTemplate.compile(compileOptions, callback);
-    }
-    catch (err) {
-        return callback(err, undefined);
-    }
+    const ocTemplate = (0, require_template_1.default)(type, {
+        compiler: true,
+        componentPath
+    });
+    const compile = (0, util_1.promisify)(ocTemplate.compile);
+    return compile(compileOptions);
 };
 exports.default = packageComponents;

package/dist/cli/domain/registry.js

@@ -24,7 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
-const minimal_request_1 = __importDefault(require("minimal-request"));
+const got_1 = __importDefault(require("got"));
 const lodash_1 = __importDefault(require("lodash"));
 const put_1 = __importDefault(require("../../utils/put"));
 const settings_1 = __importDefault(require("../../resources/settings"));
@@ -40,109 +40,96 @@ function registry(opts = {}) {
         'user-agent': `oc-cli-${getOcVersion()}/${process.version}-${process.platform}-${process.arch}`
     };
     return {
-        add(registry, callback) {
+        async add(registry) {
             if (registry.slice(registry.length - 1) !== '/') {
                 registry += '/';
             }
-            (0, minimal_request_1.default)({
-                url: registry,
-                headers: requestsHeaders,
-                json: true
-            }, (err, apiResponse) => {
-                if (err || !apiResponse) {
-                    return callback('oc registry not available', null);
+            try {
+                const apiResponse = await (0, got_1.default)(registry, {
+                    headers: requestsHeaders
+                }).json();
+                if (!apiResponse)
+                    throw 'oc registry not available';
+                if (apiResponse.type !== 'oc-registry')
+                    throw 'not a valid oc registry';
+                const res = await fs_extra_1.default
+                    .readJson(settings_1.default.configFile.src)
+                    .catch(() => ({}));
+                if (!res.registries) {
+                    res.registries = [];
                 }
-                else if (apiResponse.type !== 'oc-registry') {
-                    return callback('not a valid oc registry', null);
+                if (!lodash_1.default.includes(res.registries, registry)) {
+                    res.registries.push(registry);
                 }
-                fs_extra_1.default.readJson(settings_1.default.configFile.src, (err, res) => {
-                    if (err) {
-                        res = {};
-                    }
-                    if (!res.registries) {
-                        res.registries = [];
-                    }
-                    if (!lodash_1.default.includes(res.registries, registry)) {
-                        res.registries.push(registry);
-                    }
-                    fs_extra_1.default.writeJson(settings_1.default.configFile.src, res, callback);
-                });
-            });
+                return fs_extra_1.default.writeJson(settings_1.default.configFile.src, res);
+            }
+            catch (err) {
+                throw 'oc registry not available';
+            }
         },
-        get(callback) {
+        async get() {
             if (opts.registry) {
-                return callback(null, [opts.registry]);
+                return [opts.registry];
+            }
+            try {
+                const res = await fs_extra_1.default.readJson(settings_1.default.configFile.src);
+                if (!res.registries || res.registries.length === 0)
+                    throw 'No oc registries';
+                return res.registries;
+            }
+            catch (err) {
+                throw 'No oc registries';
             }
-            fs_extra_1.default.readJson(settings_1.default.configFile.src, (err, res) => {
-                if (err || !res.registries || res.registries.length === 0) {
-                    return callback('No oc registries', undefined);
-                }
-                return callback(null, res.registries);
-            });
         },
-        getApiComponentByHref(href, callback) {
-            (0, minimal_request_1.default)({
-                url: href + settings_1.default.registry.componentInfoPath,
-                headers: requestsHeaders,
-                json: true
-            }, callback);
+        getApiComponentByHref(href) {
+            return (0, got_1.default)(href + settings_1.default.registry.componentInfoPath, {
+                headers: requestsHeaders
+            }).json();
         },
-        getComponentPreviewUrlByUrl(componentHref, callback) {
-            (0, minimal_request_1.default)({
-                url: componentHref,
-                headers: requestsHeaders,
-                json: true
-            }, (err, res) => {
-                if (err) {
-                    return callback(err, undefined);
-                }
-                const parsed = urlParser.parse(res);
-                callback(null, urlBuilder.componentPreview(parsed, parsed.registryUrl));
-            });
+        async getComponentPreviewUrlByUrl(componentHref) {
+            const res = await (0, got_1.default)(componentHref, { headers: requestsHeaders }).json();
+            const parsed = urlParser.parse(res);
+            return urlBuilder.componentPreview(parsed, parsed.registryUrl);
         },
-        putComponent(options, callback) {
+        async putComponent(options) {
             if (!!options.username && !!options.password) {
                 requestsHeaders = Object.assign(requestsHeaders, {
                     Authorization: 'Basic ' +
                         Buffer.from(options.username + ':' + options.password).toString('base64')
                 });
             }
-            (0, put_1.default)(options.route, options.path, requestsHeaders, (err, res) => {
-                if (err) {
-                    if (!lodash_1.default.isObject(err)) {
-                        try {
-                            err = JSON.parse(String(err));
-                        }
-                        catch (er) { }
-                    }
-                    const parsedError = err;
-                    if (!!parsedError.code && parsedError.code === 'ECONNREFUSED') {
-                        err = 'Connection to registry has not been established';
-                    }
-                    else if (parsedError.code !== 'cli_version_not_valid' &&
-                        parsedError.code !== 'node_version_not_valid' &&
-                        !!parsedError.error) {
-                        err = parsedError.error;
+            try {
+                await (0, put_1.default)(options.route, options.path, requestsHeaders);
+            }
+            catch (err) {
+                let parsedError = err;
+                let errMsg = '';
+                if (!lodash_1.default.isObject(err)) {
+                    try {
+                        parsedError = JSON.parse(String(err));
                     }
-                    return callback(err, undefined);
+                    catch (er) { }
+                }
+                if (!!parsedError.code && parsedError.code === 'ECONNREFUSED') {
+                    errMsg = 'Connection to registry has not been established';
+                }
+                else if (parsedError.code !== 'cli_version_not_valid' &&
+                    parsedError.code !== 'node_version_not_valid' &&
+                    !!parsedError.error) {
+                    errMsg = parsedError.error;
                 }
-                callback(err, res);
-            });
+                throw errMsg;
+            }
         },
-        remove(registry, callback) {
+        async remove(registry) {
             if (registry.slice(registry.length - 1) !== '/') {
                 registry += '/';
             }
-            fs_extra_1.default.readJson(settings_1.default.configFile.src, (err, res) => {
-                if (err) {
-                    res = {};
-                }
-                if (!res.registries) {
-                    res.registries = [];
-                }
-                res.registries = lodash_1.default.without(res.registries, registry);
-                fs_extra_1.default.writeJson(settings_1.default.configFile.src, res, callback);
-            });
+            const res = await fs_extra_1.default
+                .readJson(settings_1.default.configFile.src)
+                .catch(() => ({ registries: [] }));
+            res.registries = lodash_1.default.without(res.registries, registry);
+            await fs_extra_1.default.writeJson(settings_1.default.configFile.src, res);
         }
     };
 }

package/dist/cli/domain/watch.js

@@ -11,7 +11,7 @@ function watch(dirs, baseDir, changed) {
         ignored: settings_1.default.filesToIgnoreOnDevWatch,
         persistent: true,
         ignoreInitial: true,
-        usePolling: false
+        usePolling: true
     });
     const onChange = (fileName) => {
         const componentDir = dirs.find(dir => Boolean(fileName.match(escapeRegularExpression(dir + path_1.default.sep))));

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

@@ -3,8 +3,14 @@ import { Logger } from '../logger';
 declare const clean: ({ local: { clean: { fetchList, remove } }, logger }: {
     local: Local;
     logger: Logger;
-}) => (opts: {
-    dirPath: string;
-    yes: boolean;
-}, callback: (err?: unknown) => void) => void;
+}) => {
+    (opts: {
+        dirPath: string;
+        yes: boolean;
+    }): Promise<void>;
+    (arguments__0: {
+        dirPath: string;
+        yes: boolean;
+    }, arguments__1: (error: unknown, value: void) => void): void;
+};
 export default clean;

package/dist/cli/facade/clean.js

@@ -4,45 +4,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const read_1 = __importDefault(require("read"));
+const universalify_1 = require("universalify");
+const util_1 = require("util");
 const index_1 = __importDefault(require("../../resources/index"));
+const read = (0, util_1.promisify)(read_1.default);
 const clean = ({ local: { clean: { fetchList, remove } }, logger }) => {
     const { cleanAlreadyClean, cleanList, cleanPrompt, cleanPromptDefault, cleanSuccess } = index_1.default.messages.cli;
-    const prompt = (cb) => (0, read_1.default)({ prompt: cleanPrompt, default: cleanPromptDefault }, (err, result) => {
-        if (err)
-            return cb(false);
-        const lowered = result.toLowerCase().trim();
-        const proceed = lowered === 'y' || lowered === 'yes';
-        cb(proceed);
-    });
-    const removeFolders = (list, cb) => remove(list, err => {
-        if (err) {
+    const prompt = async () => {
+        try {
+            const result = await read({
+                prompt: cleanPrompt,
+                default: cleanPromptDefault
+            });
+            const lowered = result.toLowerCase().trim();
+            return lowered === 'y' || lowered === 'yes';
+        }
+        catch (err) {
+            return false;
+        }
+    };
+    const removeFolders = async (list) => {
+        try {
+            await remove(list);
+            logger.ok(cleanSuccess);
+        }
+        catch (err) {
             logger.err(index_1.default.errors.cli.cleanRemoveError(String(err)));
-            return cb(err);
+            throw err;
         }
-        logger.ok(cleanSuccess);
-        cb();
-    });
-    return (opts, callback) => {
-        fetchList(opts.dirPath, (err, list) => {
-            if (err) {
-                logger.err(index_1.default.errors.generic(String(err)));
-                return callback(err);
-            }
+    };
+    return (0, universalify_1.fromPromise)(async (opts) => {
+        try {
+            const list = await fetchList(opts.dirPath);
             if (list.length === 0) {
                 logger.ok(cleanAlreadyClean);
-                return callback();
+                return;
             }
             logger.warn(cleanList(list));
             const shouldConfirm = !opts.yes;
             if (shouldConfirm) {
-                return prompt(confirmed => {
-                    if (!confirmed)
-                        return callback();
-                    return removeFolders(list, callback);
-                });
+                const confirmed = await prompt();
+                if (!confirmed)
+                    return;
             }
-            removeFolders(list, callback);
-        });
-    };
+            await removeFolders(list);
+        }
+        catch (err) {
+            logger.err(index_1.default.errors.generic(String(err)));
+            throw err;
+        }
+    });
 };
 exports.default = clean;

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

@@ -1,21 +1,114 @@
-import * as oc from '../../index';
-import watch from '../domain/watch';
+/// <reference types="node" />
+/// <reference types="express" />
+/// <reference types="node/http" />
+/// <reference types="got/dist/source/core/utils/timed-out" />
 import { Logger } from '../logger';
 import { Local } from '../../types';
-declare type Registry = ReturnType<typeof oc.Registry>;
 declare const dev: ({ local, logger }: {
     logger: Logger;
     local: Local;
-}) => (opts: {
-    prefix: string;
-    dirPath: string;
-    port?: number;
-    baseUrl: string;
-    fallbackRegistryUrl: string;
-    hotReloading?: boolean;
-    components: string[];
-    watch?: boolean;
-    verbose?: boolean;
-    production?: boolean;
-}, callback: (err: Error | string | null, data: Registry) => void) => void;
+}) => {
+    (opts: {
+        prefix: string;
+        dirPath: string;
+        port?: number | undefined;
+        baseUrl: string;
+        fallbackRegistryUrl: string;
+        hotReloading?: boolean | undefined;
+        components?: string[] | undefined;
+        watch?: boolean | undefined;
+        verbose?: boolean | undefined;
+        production?: boolean | undefined;
+    }): Promise<{
+        close: (callback: (err?: string | Error | undefined) => void) => void | import("http").Server;
+        on: <T extends keyof {
+            error: {
+                code: string;
+                message: string;
+            };
+            start: unknown;
+            'cache-poll': number;
+            request: import("../../registry/domain/events-handler").RequestData;
+            'component-retrieved': {
+                headers: import("http").IncomingHttpHeaders;
+                name: string;
+                parameters: import("http").IncomingHttpHeaders;
+                requestVersion: string;
+                duration: number;
+            };
+        }>(eventName: T, listener: (data: {
+            error: {
+                code: string;
+                message: string;
+            };
+            start: unknown;
+            'cache-poll': number;
+            request: import("../../registry/domain/events-handler").RequestData;
+            'component-retrieved': {
+                headers: import("http").IncomingHttpHeaders;
+                name: string;
+                parameters: import("http").IncomingHttpHeaders;
+                requestVersion: string;
+                duration: number;
+            };
+        }[T]) => void) => void;
+        register: (plugin: Omit<import("../../types").Plugin, "callback">, callback?: ((...args: any[]) => void) | undefined) => void;
+        start: (callback: (err: unknown, data: {
+            app: import("express").Express;
+            server: import("http").Server;
+        }) => void) => Promise<void>;
+        app: import("express").Express;
+    }>;
+    (arguments__0: {
+        prefix: string;
+        dirPath: string;
+        port?: number | undefined;
+        baseUrl: string;
+        fallbackRegistryUrl: string;
+        hotReloading?: boolean | undefined;
+        components?: string[] | undefined;
+        watch?: boolean | undefined;
+        verbose?: boolean | undefined;
+        production?: boolean | undefined;
+    }, arguments__1: (error: unknown, value: {
+        close: (callback: (err?: string | Error | undefined) => void) => void | import("http").Server;
+        on: <T extends keyof {
+            error: {
+                code: string;
+                message: string;
+            };
+            start: unknown;
+            'cache-poll': number;
+            request: import("../../registry/domain/events-handler").RequestData;
+            'component-retrieved': {
+                headers: import("http").IncomingHttpHeaders;
+                name: string;
+                parameters: import("http").IncomingHttpHeaders;
+                requestVersion: string;
+                duration: number;
+            };
+        }>(eventName: T, listener: (data: {
+            error: {
+                code: string;
+                message: string;
+            };
+            start: unknown;
+            'cache-poll': number;
+            request: import("../../registry/domain/events-handler").RequestData;
+            'component-retrieved': {
+                headers: import("http").IncomingHttpHeaders;
+                name: string;
+                parameters: import("http").IncomingHttpHeaders;
+                requestVersion: string;
+                duration: number;
+            };
+        }[T]) => void) => void;
+        register: (plugin: Omit<import("../../types").Plugin, "callback">, callback?: ((...args: any[]) => void) | undefined) => void;
+        start: (callback: (err: unknown, data: {
+            app: import("express").Express;
+            server: import("http").Server;
+        }) => void) => Promise<void>;
+        app: import("express").Express;
+    }) => void): void;
+};
 export default dev;