@modern-js/utils 1.3.6 → 1.3.8-canary.0

package/dist/logger.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const chalk_1 = __importDefault(require("../compiled/chalk"));
+const { grey, underline } = chalk_1.default;
+const LOG_TYPES = {
+    error: {
+        color: 'red',
+        label: 'error',
+        level: 'error',
+    },
+    info: {
+        color: 'blue',
+        label: 'info',
+        level: 'info',
+    },
+    warn: {
+        color: 'yellow',
+        label: 'warning',
+        level: 'warn',
+    },
+    debug: {
+        color: 'red',
+        label: 'debug',
+        level: 'debug',
+    },
+    log: { level: 'info' },
+};
+const DEFAULT_CONFIG = {
+    displayLabel: true,
+    underlineLabel: true,
+    uppercaseLabel: false,
+};
+class Logger {
+    constructor(options = {}) {
+        this.logCount = 200;
+        this.history = {};
+        this.config = Object.assign(Object.assign({}, DEFAULT_CONFIG), (options.config || {}));
+        this.types = Object.assign(Object.assign({}, LOG_TYPES), (options.types || {}));
+        this.longestLabel = this.getLongestLabel();
+        Object.keys(this.types).forEach(type => {
+            this[type] = this._log.bind(this, type);
+        });
+    }
+    retainLog(type, message) {
+        if (!this.history[type]) {
+            this.history[type] = [];
+        }
+        this.history[type].push(message);
+        while (this.history[type].length > this.logCount) {
+            this.history[type].shift();
+        }
+    }
+    _log(type, message) {
+        if (message === undefined) {
+            // eslint-disable-next-line no-console
+            console.log();
+            return;
+        }
+        let label = '';
+        let text = '';
+        const logType = this.types[type];
+        if (this.config.displayLabel && logType.label) {
+            label = this.config.uppercaseLabel
+                ? logType.label.toUpperCase()
+                : logType.label;
+            if (this.config.underlineLabel) {
+                label = underline(label).padEnd(this.longestUnderlinedLabel.length + 1);
+            }
+            else {
+                label = label.padEnd(this.longestLabel.length + 1);
+            }
+            label = logType.color ? chalk_1.default[logType.color](label) : label;
+        }
+        if (message instanceof Error) {
+            if (message.stack) {
+                const [name, ...rest] = message.stack.split('\n');
+                text = `${name}\n${grey(rest.join('\n'))}`;
+            }
+            else {
+                text = message.message;
+            }
+        }
+        else {
+            text = `${message}`;
+        }
+        // only retain logs of warn/error level
+        if (logType.level === 'warn' || logType.level === 'error') {
+            // retain log text without label
+            this.retainLog(type, text);
+        }
+        const log = label.length > 0 ? `${label}  ${text}` : text;
+        // eslint-disable-next-line no-console
+        console.log(log);
+    }
+    getLongestLabel() {
+        let longestLabel = '';
+        Object.keys(this.types).forEach(type => {
+            const { label = '' } = this.types[type];
+            if (label.length > longestLabel.length) {
+                longestLabel = label;
+            }
+        });
+        return longestLabel;
+    }
+    get longestUnderlinedLabel() {
+        return underline(this.longestLabel);
+    }
+    getRetainedLogs(type) {
+        return this.history[type] || [];
+    }
+    clearRetainedLogs(type) {
+        if (type) {
+            if (this.history[type]) {
+                this.history[type] = [];
+            }
+        }
+        else {
+            this.history = {};
+        }
+    }
+}
+const logger = new Logger();
+exports.logger = logger;
+logger.Logger = Logger;

package/dist/monorepo.d.ts

@@ -0,0 +1,11 @@
+import path from 'path';
+export declare const isLerna: (root: string) => boolean;
+export declare const isYarnWorkspaces: (root: string) => boolean;
+export declare const isPnpmWorkspaces: (root: string) => boolean;
+export declare const isMonorepo: (root: string) => boolean;
+export declare const isModernjsMonorepo: (root: string) => boolean;
+export declare const findMonorepoRoot: (appDirectory: string, maxDepth?: number) => string | undefined;
+export declare const getMonorepoPackages: (root: string) => {
+    name: string;
+    path: string;
+}[];

package/dist/monorepo.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonorepoPackages = exports.findMonorepoRoot = exports.isModernjsMonorepo = exports.isMonorepo = exports.isPnpmWorkspaces = exports.isYarnWorkspaces = exports.isLerna = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const PACKAGE_MAX_DEPTH = 5;
+const WOKRSPACES_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspaces.yaml',
+    LERNA: 'lerna.json',
+};
+const isLerna = (root) => fs_1.default.existsSync(path_1.default.join(root, WOKRSPACES_FILES.LERNA));
+exports.isLerna = isLerna;
+const isYarnWorkspaces = (root) => {
+    var _a;
+    const pkg = path_1.default.join(root, WOKRSPACES_FILES.YARN);
+    if (!fs_1.default.existsSync(pkg)) {
+        return false;
+    }
+    const json = JSON.parse(fs_1.default.readFileSync(pkg, 'utf8'));
+    return Boolean((_a = json.workspaces) === null || _a === void 0 ? void 0 : _a.packages);
+};
+exports.isYarnWorkspaces = isYarnWorkspaces;
+const isPnpmWorkspaces = (root) => fs_1.default.existsSync(path_1.default.join(root, WOKRSPACES_FILES.PNPM));
+exports.isPnpmWorkspaces = isPnpmWorkspaces;
+const isMonorepo = (root) => (0, exports.isLerna)(root) || (0, exports.isYarnWorkspaces)(root) || (0, exports.isPnpmWorkspaces)(root);
+exports.isMonorepo = isMonorepo;
+const isModernjsMonorepo = (root) => {
+    const json = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'package.json'), 'utf8'));
+    const deps = Object.assign(Object.assign({}, (json.dependencies || {})), (json.devDependencies || {}));
+    return Boolean(deps['@modern-js/monorepo-tools']);
+};
+exports.isModernjsMonorepo = isModernjsMonorepo;
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) => {
+    let inMonorepo = false;
+    for (let depth = 0; depth < maxDepth; depth++) {
+        if ((0, exports.isMonorepo)(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        // eslint-disable-next-line no-param-reassign
+        appDirectory = path_1.default.dirname(appDirectory);
+    }
+    return inMonorepo ? appDirectory : undefined;
+};
+exports.findMonorepoRoot = findMonorepoRoot;
+const getMonorepoPackages = (root) => {
+    let packages = [];
+    if ((0, exports.isYarnWorkspaces)(root)) {
+        const json = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    }
+    else if ((0, exports.isLerna)(root)) {
+        const json = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    }
+    else {
+        ({ packages } = compiled_1.yaml.load(fs_1.default.readFileSync(path_1.default.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
+    }
+    if (packages) {
+        return packages
+            .map(name => 
+        // The trailing / ensures only dirs are picked up
+        compiled_1.glob.sync(path_1.default.join(root, `${name}/`), {
+            ignore: ['**/node_modules/**'],
+        }))
+            .reduce((acc, val) => acc.concat(val), [])
+            .filter(filepath => fs_1.default.existsSync(path_1.default.resolve(filepath, 'package.json')))
+            .map(filepath => ({
+            path: filepath,
+            name: JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(filepath, 'package.json'), 'utf8')).name,
+        }));
+    }
+    return [];
+};
+exports.getMonorepoPackages = getMonorepoPackages;

package/dist/nodeEnv.d.ts

@@ -0,0 +1,3 @@
+export declare function canUseNpm(): Promise<boolean>;
+export declare function canUseYarn(): Promise<boolean>;
+export declare function canUsePnpm(): Promise<boolean>;

package/dist/nodeEnv.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUsePnpm = exports.canUseYarn = exports.canUseNpm = void 0;
+const compiled_1 = require("./compiled");
+function canUseNpm() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('npm', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUseNpm = canUseNpm;
+function canUseYarn() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('yarn', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUseYarn = canUseYarn;
+function canUsePnpm() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('pnpm', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUsePnpm = canUsePnpm;

package/dist/path.d.ts

@@ -0,0 +1,3 @@
+export declare const isRelativePath: (test: string) => boolean;
+export declare const normalizeOutputPath: (s: string) => string;
+export declare const normalizeToPosixPath: (p: string) => string;

package/dist/path.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToPosixPath = exports.normalizeOutputPath = exports.isRelativePath = void 0;
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const isRelativePath = (test) => /^\.\.?($|[\\/])/.test(test);
+exports.isRelativePath = isRelativePath;
+const normalizeOutputPath = (s) => s.replace(/\\/g, '\\\\');
+exports.normalizeOutputPath = normalizeOutputPath;
+const normalizeToPosixPath = (p) => compiled_1.upath.normalizeSafe(path_1.default.normalize(p));
+exports.normalizeToPosixPath = normalizeToPosixPath;

package/dist/{types/pkgUp.d.ts → pkgUp.d.ts}

@@ -1,2 +1,2 @@
 import pkgUp from 'pkg-up';
-export { pkgUp };
+export { pkgUp };

package/dist/pkgUp.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pkgUp = void 0;
+const pkg_up_1 = __importDefault(require("pkg-up"));
+exports.pkgUp = pkg_up_1.default;

package/dist/prettyInstructions.d.ts

@@ -0,0 +1,6 @@
+interface EntryPoint {
+    entryName: string;
+}
+export declare const isSingleEntry: (entrypoints: EntryPoint[]) => boolean;
+export declare const prettyInstructions: (appContext: any, config: any) => string;
+export {};

package/dist/prettyInstructions.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyInstructions = exports.isSingleEntry = void 0;
+const os_1 = __importDefault(require("os"));
+const compiled_1 = require("./compiled");
+const is_1 = require("./is");
+// TODO: remove hard code 'main'
+const isSingleEntry = (entrypoints) => entrypoints.length === 1 && entrypoints[0].entryName === 'main';
+exports.isSingleEntry = isSingleEntry;
+const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, '$1');
+const getAddressUrls = (protocol = 'http', port) => {
+    const interfaces = os_1.default.networkInterfaces();
+    const ipv4Interfaces = [];
+    Object.keys(interfaces).forEach(key => {
+        interfaces[key].forEach(detail => {
+            if (detail.family === 'IPv4') {
+                ipv4Interfaces.push(detail);
+            }
+        });
+    });
+    return ipv4Interfaces.reduce((memo, detail) => {
+        let type = 'Network:  ';
+        let url = `${protocol}://${detail.address}:${port}`;
+        if (detail.address.includes(`localhost`)) {
+            type = 'Local:  ';
+            url = `${protocol}://localhost:${port}`;
+        }
+        memo.push({ type, url });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config) => {
+    const { entrypoints, serverRoutes, port, existSrc, checkedEntries } = appContext;
+    const urls = getAddressUrls(config.dev.https && (0, is_1.isDev)() ? 'https' : 'http', port);
+    const routes = existSrc
+        ? serverRoutes.filter(route => route.entryName)
+        : serverRoutes;
+    let message = 'App running at:\n\n';
+    if ((0, exports.isSingleEntry)(entrypoints) || !existSrc) {
+        message += urls
+            .map(({ type, url }) => `  ${compiled_1.chalk.bold(`> ${type.padEnd(10)}`)}${compiled_1.chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}\n`)
+            .join('');
+    }
+    else {
+        const maxNameLength = Math.max(...routes.map(r => r.entryName.length));
+        urls.forEach(({ type, url }) => {
+            message += `  ${compiled_1.chalk.bold(`> ${type}`)}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR }) => {
+                if (!checkedEntries.includes(entryName)) {
+                    return;
+                }
+                message += `    ${compiled_1.chalk.yellowBright(isSSR ? 'λ' : '○')}  ${compiled_1.chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${compiled_1.chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
+            });
+        });
+        message += '\n';
+        message += compiled_1.chalk.cyanBright('  λ (Server) server-side renders at runtime\n');
+        message += compiled_1.chalk.cyanBright('  ○ (Static) client-side rendered as static HTML\n');
+    }
+    return message;
+};
+exports.prettyInstructions = prettyInstructions;

package/dist/printBuildError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+export declare function printBuildError(err: Error): void;

package/dist/printBuildError.js

@@ -0,0 +1,43 @@
+"use strict";
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBuildError = void 0;
+// Modified by Chao Xu (xuchaobei)
+const compiled_1 = require("./compiled");
+const logger_1 = require("./logger");
+function printBuildError(err) {
+    const message = err != null && err.message;
+    const stack = err != null && err.stack;
+    // Add more helpful message for Terser error
+    if (stack &&
+        typeof message === 'string' &&
+        message.indexOf('from Terser') !== -1) {
+        try {
+            const matched = /(.+)\[(.+):(.+),(.+)\]\[.+\]/.exec(stack);
+            if (!matched) {
+                throw new Error('Using errors for control flow is bad.');
+            }
+            const problemPath = matched[2];
+            const line = matched[3];
+            const column = matched[4];
+            logger_1.logger.error(`Failed to minify the code from this file: \n\n ${compiled_1.chalk.yellow(`\t${problemPath}:${line}${column !== '0' ? ':' + column : ''}`)}\n`);
+        }
+        catch (ignored) {
+            logger_1.logger.error(`Failed to minify the bundle. ${err}\n`);
+        }
+    }
+    else {
+        logger_1.logger.error((message || err) + '\n');
+    }
+    logger_1.logger.log();
+}
+exports.printBuildError = printBuildError;
+/* eslint-enable */

package/dist/readTsConfig.d.ts

@@ -0,0 +1,2 @@
+export declare const readTsConfig: (root: string) => any;
+export declare const readTsConfigByFile: (filename: string) => any;

package/dist/readTsConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTsConfigByFile = exports.readTsConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const readTsConfig = (root) => {
+    // import typescript from 'typescript' cause eslint fromat error.
+    const typescript = require('typescript');
+    return typescript.readConfigFile(path_1.default.resolve(root, './tsconfig.json'), typescript.sys.readFile).config;
+};
+exports.readTsConfig = readTsConfig;
+const readTsConfigByFile = (filename) => {
+    // import typescript from 'typescript' cause eslint fromat error.
+    const typescript = require('typescript');
+    return typescript.readConfigFile(path_1.default.resolve(filename), typescript.sys.readFile).config;
+};
+exports.readTsConfigByFile = readTsConfigByFile;

package/dist/removeSlash.d.ts

@@ -0,0 +1,3 @@
+export declare const removeLeadingSlash: (s: string) => string;
+export declare const removeTailSlash: (s: string) => string;
+export declare const removeSlash: (s: string) => string;

package/dist/removeSlash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSlash = exports.removeTailSlash = exports.removeLeadingSlash = void 0;
+const removeLeadingSlash = (s) => s.replace(/^\/+/, '');
+exports.removeLeadingSlash = removeLeadingSlash;
+const removeTailSlash = (s) => s.replace(/\/+$/, '');
+exports.removeTailSlash = removeTailSlash;
+const removeSlash = (s) => (0, exports.removeLeadingSlash)((0, exports.removeTailSlash)(s));
+exports.removeSlash = removeSlash;

package/dist/runtimeExports.d.ts

@@ -0,0 +1,4 @@
+export declare const createRuntimeExportsUtils: (pwd: any, namespace: string, ts?: any) => {
+    addExport: (statement: string) => void;
+    getPath: () => string;
+};

package/dist/runtimeExports.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeExportsUtils = void 0;
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const path_2 = require("./path");
+const memo = (fn) => {
+    const cache = new Map();
+    return (...params) => {
+        const stringifiedParams = JSON.stringify(params);
+        const cachedResult = cache.get(stringifiedParams);
+        if (cachedResult) {
+            return cachedResult;
+        }
+        const res = fn(...params);
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+exports.createRuntimeExportsUtils = memo((pwd = '', namespace, ts = false) => {
+    const entryExportFile = path_1.default.join(pwd, `.runtime-exports/${namespace ? `${namespace}.js` : 'index.js'}`);
+    const entryExportTsFile = path_1.default.join(pwd, `.runtime-exports/${namespace ? `${namespace}.d.ts` : 'index.d.ts'}`);
+    // const ensure = () => {
+    //   if (!fs.existsSync(entryExportFile)) {
+    //     fs.outputFileSync(entryExportFile, '');
+    //   }
+    //   fs.ensureFileSync(entryExportFile);
+    // };
+    const addExport = (statement) => {
+        // eslint-disable-next-line no-param-reassign
+        statement = (0, path_2.normalizeOutputPath)(statement);
+        try {
+            compiled_1.fs.ensureFileSync(entryExportFile);
+            compiled_1.fs.ensureFileSync(entryExportTsFile);
+            if (!compiled_1.fs.readFileSync(entryExportFile, 'utf8').includes(statement)) {
+                compiled_1.fs.appendFileSync(entryExportFile, `${statement}\n`);
+                ts &&
+                    compiled_1.fs.appendFileSync(entryExportTsFile, `${statement.replace('.js', '.d')}\n`);
+            }
+        }
+        catch (_a) {
+            // FIXME:
+        }
+    };
+    const getPath = () => entryExportFile;
+    return {
+        addExport,
+        getPath,
+    };
+});

package/dist/ssrHelpers.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'http';
+declare const run: <O>(context: IncomingHttpHeaders, cb: () => O | Promise<O>) => Promise<O>, useHeaders: () => IncomingHttpHeaders;
+export { run, useHeaders };

package/dist/ssrHelpers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHeaders = exports.run = void 0;
+const storage_1 = require("./storage");
+const { run, useContext: useHeaders } = (0, storage_1.createStorage)();
+exports.run = run;
+exports.useHeaders = useHeaders;

package/dist/storage.d.ts

@@ -0,0 +1,5 @@
+declare const createStorage: <T>() => {
+    run: <O>(context: T, cb: () => O | Promise<O>) => Promise<O>;
+    useContext: () => T;
+};
+export { createStorage };

package/dist/storage.js

@@ -0,0 +1,61 @@
+"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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorage = void 0;
+const ah = __importStar(require("async_hooks"));
+const createStorage = () => {
+    let storage;
+    if (typeof ah.AsyncLocalStorage !== 'undefined') {
+        storage = new ah.AsyncLocalStorage();
+    }
+    const run = (context, cb) => {
+        if (!storage) {
+            throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        }
+        return new Promise((resolve, reject) => {
+            storage.run(context, () => {
+                try {
+                    return resolve(cb());
+                }
+                catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = () => {
+        if (!storage) {
+            throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        }
+        const context = storage.getStore();
+        if (!context) {
+            throw new Error(`Can't call useContext out of scope, it should be placed on top of the function`);
+        }
+        return context;
+    };
+    return {
+        run,
+        useContext,
+    };
+};
+exports.createStorage = createStorage;

package/dist/types/FileSizeReporter.d.ts

@@ -6,11 +6,11 @@
  * https://github.com/facebook/create-react-app/blob/master/LICENSE
  */
 declare function printFileSizesAfterBuild(webpackStats: any, previousSizeMap: {
-  root: string;
-  sizes: Record<string, number[]>;
+    root: string;
+    sizes: Record<string, number[]>;
 }, buildFolder: string, maxBundleGzipSize: number, maxChunkGzipSize: number): void;
 declare function measureFileSizesBeforeBuild(buildFolder: string): Promise<{
-  root: string;
-  sizes: Record<string, number[]>;
+    root: string;
+    sizes: Record<string, number[]>;
 }>;
-export { measureFileSizesBeforeBuild, printFileSizesAfterBuild };
+export { measureFileSizesBeforeBuild, printFileSizesAfterBuild };