@modern-js/utils 1.3.6 → 1.3.7-alpha.prebundle.0

package/dist/is/type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegExp = exports.isPromise = exports.isPlainObject = exports.isObject = exports.isFunction = exports.isArray = exports.isUndefined = exports.isString = void 0;
+function isString(str) {
+    return typeof str === 'string';
+}
+exports.isString = isString;
+function isUndefined(obj) {
+    return typeof obj === 'undefined';
+}
+exports.isUndefined = isUndefined;
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+exports.isArray = isArray;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isFunction(func) {
+    return typeof func === 'function';
+}
+exports.isFunction = isFunction;
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+exports.isObject = isObject;
+function isPlainObject(obj) {
+    return (isObject(obj) && Object.prototype.toString.call(obj) === '[object Object]');
+}
+exports.isPlainObject = isPlainObject;
+function isPromise(obj) {
+    return (Boolean(obj) &&
+        (typeof obj === 'object' || typeof obj === 'function') &&
+        typeof obj.then === 'function');
+}
+exports.isPromise = isPromise;
+function isRegExp(obj) {
+    return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;

package/dist/logger.d.ts

@@ -0,0 +1,63 @@
+import { Color } from '../compiled/chalk';
+declare type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerConfiguration {
+    color?: typeof Color;
+    label?: string;
+    level?: LogLevel;
+}
+interface InstanceConfiguration {
+    displayLabel?: boolean;
+    underlineLabel?: boolean;
+    uppercaseLabel?: boolean;
+}
+interface ConstructorOptions {
+    config?: InstanceConfiguration;
+    types?: Record<string, LoggerConfiguration>;
+}
+declare type LoggerFunction = (message?: number | string | Error, ...args: any[]) => void;
+declare const LOG_TYPES: {
+    error: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    info: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    warn: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    debug: {
+        color: string;
+        label: string;
+        level: string;
+    };
+    log: {
+        level: string;
+    };
+};
+declare class Logger {
+    private readonly logCount;
+    private history;
+    private readonly config;
+    private readonly types;
+    private readonly longestLabel;
+    [key: string]: any;
+    constructor(options?: ConstructorOptions);
+    private retainLog;
+    private _log;
+    private getLongestLabel;
+    private get longestUnderlinedLabel();
+    getRetainedLogs(type: string): string[];
+    clearRetainedLogs(type: string): void;
+}
+declare type LoggerInterface = {
+    [key in keyof typeof LOG_TYPES]: LoggerFunction;
+};
+declare const logger: Logger & LoggerInterface;
+export { logger };
+export type { LoggerInterface };

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/{types/monorepo.d.ts → monorepo.d.ts}

@@ -6,6 +6,6 @@ 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;
-}[];
+    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/{types/nodeEnv.d.ts → nodeEnv.d.ts}

@@ -1,3 +1,3 @@
 export declare function canUseNpm(): Promise<boolean>;
 export declare function canUseYarn(): Promise<boolean>;
-export declare function canUsePnpm(): 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/{types/path.d.ts → path.d.ts}

@@ -1,3 +1,3 @@
 export declare const isRelativePath: (test: string) => boolean;
 export declare const normalizeOutputPath: (s: string) => string;
-export declare const normalizeToPosixPath: (p: 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/{types/prettyInstructions.d.ts → prettyInstructions.d.ts}

@@ -1,6 +1,6 @@
 interface EntryPoint {
-  entryName: string;
+    entryName: string;
 }
 export declare const isSingleEntry: (entrypoints: EntryPoint[]) => boolean;
 export declare const prettyInstructions: (appContext: any, config: any) => string;
-export {};
+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/{types/printBuildError.d.ts → printBuildError.d.ts}

@@ -5,4 +5,4 @@
  * LICENSE file at
  * https://github.com/facebook/create-react-app/blob/master/LICENSE
  */
-export declare function printBuildError(err: Error): void;
+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/{types/readTsConfig.d.ts → readTsConfig.d.ts}

@@ -1,2 +1,2 @@
 export declare const readTsConfig: (root: string) => any;
-export declare const readTsConfigByFile: (filename: 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/{types/removeSlash.d.ts → removeSlash.d.ts}

@@ -1,3 +1,3 @@
 export declare const removeLeadingSlash: (s: string) => string;
 export declare const removeTailSlash: (s: string) => string;
-export declare const removeSlash: (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/{types/runtimeExports.d.ts → runtimeExports.d.ts}

@@ -1,4 +1,4 @@
 export declare const createRuntimeExportsUtils: (pwd: any, namespace: string, ts?: any) => {
-  addExport: (statement: string) => void;
-  getPath: () => string;
-};
+    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/src/FileSizeReporter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ */
+declare function printFileSizesAfterBuild(webpackStats: any, previousSizeMap: {
+    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[]>;
+}>;
+export { measureFileSizesBeforeBuild, printFileSizesAfterBuild };