@omnific/react-scripts 0.1.0 → 0.1.2

package/dist/build-CoW3Nti_.js

@@ -0,0 +1,195 @@
+import { t as paths_default } from "./paths-DdPGCuT5.js";
+import { styleText } from "node:util";
+import fs from "node:fs/promises";
+import { exit } from "node:process";
+import { rspack } from "@rspack/core";
+import pth from "node:path";
+import fs$1 from "node:fs";
+import prettyBytes from "pretty-bytes";
+import zlib from "node:zlib";
+//#region utils/fs-extra.ts
+async function emptyDirectory(directory) {
+	await fs.rm(directory, {
+		recursive: true,
+		force: true
+	});
+	await fs.mkdir(directory, { recursive: true });
+}
+/**
+* 读取文件夹下的所有文件
+* @param path
+* @returns
+*/
+async function readdir(path) {
+	let fileList = [];
+	const files = await fs.readdir(path);
+	if (files.length === 0) return [];
+	for (const file of files) {
+		const filePath = pth.join(path, file);
+		if ((await fs.stat(filePath)).isDirectory()) fileList = [...fileList, ...await readdir(filePath)];
+		else fileList.push(filePath);
+	}
+	return fileList;
+}
+//#endregion
+//#region utils/gzip-size.ts
+function getOptions(options) {
+	return {
+		level: 9,
+		...options
+	};
+}
+function gzipSync(input, options) {
+	return zlib.gzipSync(input, getOptions(options)).length;
+}
+//#endregion
+//#region utils/strip-ansi.ts
+function ansiRegex(options = {}) {
+	const { onlyFirst } = options;
+	const pattern = [String.raw`[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?\u0007)`, String.raw`(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))`].join("|");
+	return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+function stripAnsi(string) {
+	const regex = ansiRegex();
+	return string.replace(regex, "");
+}
+//#endregion
+//#region utils/file-size-reporter.ts
+const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
+const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
+/**
+* 是不是可以读取的资源
+* @param asset
+* @returns
+*/
+function canReadAsset(asset) {
+	return /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[\da-f]+\.js/.test(asset);
+}
+function removeFileNameHash(buildFolder, fileName) {
+	return fileName.replace(buildFolder, "").replaceAll("\\", "/").replace(/\/?(.*)(\.[\da-f]+)(\.chunk)?(\.js|\.css)/, (match, p1, p2, p3, p4) => p1 + p4);
+}
+async function measureFileSizesBeforeBuild(buildFolder) {
+	const result = {
+		root: buildFolder,
+		sizes: {}
+	};
+	try {
+		const files = await readdir(buildFolder);
+		if (Array.isArray(files) && files.length > 0) {
+			const canReadAssetFiles = files.filter((item) => canReadAsset(item));
+			for (const fileName of canReadAssetFiles) {
+				const stats = fs$1.statSync(fileName);
+				const fileKey = removeFileNameHash(buildFolder, fileName);
+				result.sizes[fileKey] = stats.size;
+			}
+		}
+	} catch {
+		return result;
+	}
+	return result;
+}
+function getDifferenceLabel(currentSize, previousSize) {
+	const FIFTY_KILOBYTES = 1024 * 50;
+	const difference = currentSize - previousSize;
+	const fileSize = Number.isNaN(difference) ? "0" : prettyBytes(difference);
+	if (difference >= FIFTY_KILOBYTES) return styleText("red", "+" + fileSize);
+	else if (difference < FIFTY_KILOBYTES && difference > 0) return styleText("yellow", "+" + fileSize);
+	else if (difference < 0) return styleText("green", fileSize);
+	else return "";
+}
+function printFileSizesAfterBuild(stats, previousSizeMap) {
+	let suggestBundleSplitting = false;
+	const root = previousSizeMap.root;
+	const sizes = previousSizeMap.sizes;
+	const statCompilation = stats.toJson({
+		all: false,
+		assets: true
+	});
+	if (statCompilation.assets) {
+		const assets = [];
+		const gzipLabelLengthList = [];
+		const sizeLabelLengthList = [];
+		for (const asset of statCompilation.assets) {
+			if (!canReadAsset(asset.name)) continue;
+			const fileContents = fs$1.readFileSync(pth.join(root, asset.name));
+			const previousSize = sizes[removeFileNameHash(root, asset.name)];
+			const difference = getDifferenceLabel(asset.size, previousSize);
+			const sizeLabel = prettyBytes(asset.size) + (difference ? " (" + difference + ")" : "");
+			const gzipLabel = "gzip : " + prettyBytes(gzipSync(fileContents));
+			const sizeLabelLength = stripAnsi(sizeLabel).length;
+			const gzipLabelLength = stripAnsi(gzipLabel).length;
+			assets.push({
+				folder: pth.join(pth.basename(paths_default.appBuild), pth.dirname(asset.name)),
+				name: pth.basename(asset.name),
+				size: asset.size,
+				sizeLabel,
+				gzipLabel,
+				sizeLabelLength,
+				gzipLabelLength
+			});
+			gzipLabelLengthList.push(gzipLabelLength);
+			sizeLabelLengthList.push(sizeLabelLength);
+		}
+		assets.sort((a, b) => b.size - a.size);
+		const longestSizeLabelLength = Math.max.apply(void 0, sizeLabelLengthList);
+		const longestGzipSizeLabelLength = Math.max.apply(void 0, gzipLabelLengthList);
+		for (const asset of assets) {
+			let sizeLabel = asset.sizeLabel;
+			let gzipLabel = asset.gzipLabel;
+			const sizeLabelLength = asset.sizeLabelLength;
+			const gzipLabelLength = asset.gzipLabelLength;
+			if (sizeLabelLength < longestSizeLabelLength) sizeLabel += " ".repeat(longestSizeLabelLength - sizeLabelLength);
+			if (gzipLabelLength < longestGzipSizeLabelLength) gzipLabel += " ".repeat(longestGzipSizeLabelLength - gzipLabelLength);
+			const maxRecommendedSize = asset.name.indexOf("main.") === 0 ? WARN_AFTER_BUNDLE_GZIP_SIZE : WARN_AFTER_CHUNK_GZIP_SIZE;
+			const isLarge = maxRecommendedSize && asset.size > maxRecommendedSize;
+			if (isLarge && pth.extname(asset.name) === ".js") suggestBundleSplitting = true;
+			console.log("  " + (isLarge ? styleText("yellow", sizeLabel) : sizeLabel) + "   " + gzipLabel, "  " + styleText("dim", asset.folder + pth.sep) + styleText("cyan", asset.name));
+		}
+	}
+	if (suggestBundleSplitting) {
+		console.log();
+		console.log(styleText("yellow", "The bundle size is significantly larger than recommended."));
+		console.log(styleText("yellow", "You can also analyze the project dependencies: https://goo.gl/LeUzfb"));
+	}
+}
+//#endregion
+//#region scripts/build.ts
+async function startBuild(context) {
+	const { rspackConfig } = context;
+	try {
+		const previousFileSizes = await measureFileSizesBeforeBuild(paths_default.appBuild);
+		await emptyDirectory(paths_default.appBuild);
+		await copyPublicFolder();
+		const stats = await build(rspackConfig);
+		console.log(styleText("green", "Compiled successfully.\n"));
+		console.log("File sizes after gzip:\n");
+		if (stats) printFileSizesAfterBuild(stats, previousFileSizes);
+		console.log();
+	} catch (error) {
+		console.log(styleText("red", "Failed to compile.\n"));
+		if (error && error.message) console.log(error.message);
+		exit(1);
+	}
+}
+function copyPublicFolder() {
+	return fs.cp(paths_default.appPublic, paths_default.appBuild, {
+		recursive: true,
+		filter: (source) => source !== paths_default.appHtml
+	});
+}
+/**
+* Create the production build and print the deployment instructions.
+* @returns
+*/
+async function build(rspackConfig) {
+	console.log("Creating an optimized production build...");
+	const compiler = rspack(rspackConfig);
+	return new Promise((resolve, reject) => {
+		compiler.run((error, stats) => {
+			if (error) return reject(error);
+			return resolve(stats);
+		});
+	});
+}
+//#endregion
+export { startBuild as t };

package/dist/dev-D0bbZds7.js

@@ -0,0 +1,298 @@
+import { t as paths_default } from "./paths-DdPGCuT5.js";
+import { createRequire } from "node:module";
+import { styleText } from "node:util";
+import { exit } from "node:process";
+import { rspack } from "@rspack/core";
+import pth from "node:path";
+import { RspackDevServer } from "@rspack/dev-server";
+import url from "node:url";
+import prompts from "prompts";
+import getPort from "get-port";
+import os from "node:os";
+//#region utils/address.ts
+function getDefaultInterfaceName() {
+	let value = "eth";
+	const platform = os.platform();
+	if (platform === "darwin") value = "en";
+	else if (platform === "win32") value = void 0;
+	return value;
+}
+function matchName(actualFamily, expectedFamily) {
+	if (expectedFamily === "IPv4") return actualFamily === "IPv4" || actualFamily === 4;
+	if (expectedFamily === "IPv6") return actualFamily === "IPv6" || actualFamily === 6;
+	return actualFamily === expectedFamily;
+}
+function findAddressFromInterface(items, expectedFamily, ignoreLoAddress = false) {
+	let firstMatchItem;
+	for (const item of items) if (matchName(item.family, expectedFamily)) {
+		if (ignoreLoAddress && item.address.startsWith("127.")) continue;
+		if (expectedFamily === "IPv6") {
+			if (item.scopeid === 0) return item;
+			if (!firstMatchItem) firstMatchItem = item;
+		} else return item;
+	}
+	return firstMatchItem;
+}
+function getInterfaceAddress(family, name) {
+	const interfaces = os.networkInterfaces();
+	const noName = !name;
+	name = name || getDefaultInterfaceName();
+	family = family || "IPv4";
+	if (name) for (let index = -1; index < 8; index++) {
+		const items = interfaces[name + (index >= 0 ? index : "")];
+		if (items) {
+			const item = findAddressFromInterface(items, family);
+			if (item) return item;
+		}
+	}
+	if (noName) for (const k in interfaces) {
+		const items = interfaces[k];
+		if (items) {
+			const item = findAddressFromInterface(items, family, true);
+			if (item) return item;
+		}
+	}
+}
+/**
+* Get current machine IPv4
+*
+* interfaceName: interface name, default is 'eth' on linux, 'en' on mac os.
+*/
+function ip(interfaceName) {
+	return getInterfaceAddress("IPv4", interfaceName)?.address;
+}
+//#endregion
+//#region utils/is-root.ts
+/**
+* 检查进程是否以 root 用户身份运行
+*/
+function isRoot() {
+	return process.getuid && process.getuid() === 0;
+}
+//#endregion
+//#region utils/clear-console.ts
+/**
+* 清除控制台的信息
+*/
+function clearConsole() {
+	process.stdout.write(process.platform === "win32" ? "\x1B[2J\x1B[0f" : "\x1B[2J\x1B[3J\x1B[H");
+}
+//#endregion
+//#region utils/dev-server-utils.ts
+const isInteractive$1 = process.stdout.isTTY;
+function printInstructions(appName, urls) {
+	console.log();
+	console.log(`You can now view ${styleText("bold", appName)} in the browser.`);
+	console.log();
+	if (urls.lanUrlForTerminal) {
+		console.log(`  ${styleText("bold", "Local:")}            ${urls.localUrlForTerminal}`);
+		console.log(`  ${styleText("bold", "On Your Network:")}  ${urls.lanUrlForTerminal}`);
+	} else console.log(`  ${urls.localUrlForTerminal}`);
+	console.log();
+	console.log("Note that the development build is not optimized.");
+}
+/**
+* 准备Url 数据
+*/
+function prepareUrls(options) {
+	const { protocol, host, port, pathname = "/" } = options;
+	function formatUrl(hostname) {
+		return url.format({
+			protocol,
+			hostname,
+			port,
+			pathname
+		});
+	}
+	function prettyPrintUrl(hostname) {
+		return url.format({
+			protocol,
+			hostname,
+			port: styleText("bold", String(port)),
+			pathname
+		});
+	}
+	const isUnspecifiedHost = host === "0.0.0.0" || host === "::";
+	let prettyHost;
+	let lanUrlForConfig;
+	let lanUrlForTerminal;
+	if (isUnspecifiedHost) {
+		prettyHost = "localhost";
+		try {
+			lanUrlForConfig = ip();
+			if (lanUrlForConfig) if (/^10\.|^172\.(1[6-9]|2\d|3[01])\.|^192\.168\./.test(lanUrlForConfig)) lanUrlForTerminal = prettyPrintUrl(lanUrlForConfig);
+			else lanUrlForConfig = void 0;
+		} catch {}
+	} else prettyHost = host;
+	const localUrlForTerminal = prettyPrintUrl(prettyHost);
+	const localUrlForBrowser = formatUrl(prettyHost);
+	return {
+		lanUrlForConfig,
+		lanUrlForTerminal,
+		localUrlForTerminal,
+		localUrlForBrowser
+	};
+}
+/**
+* 选择端口
+* @param defaultPort 默认端口
+* @param host 域名
+*/
+async function choosePort(options) {
+	try {
+		const port = await getPort(options);
+		if (port === options.port) return port;
+		const message = process.platform !== "win32" && port < 1024 && !isRoot() ? `Admin permissions are required to run a server on a port below 1024.` : `Something is already running on port ${port}.`;
+		if (isInteractive$1) {
+			clearConsole();
+			return (await prompts({
+				type: "confirm",
+				name: "shouldChangePort",
+				message: styleText("yellow", message) + "\n\nWould you like to run the app on another port instead",
+				initial: true
+			})).shouldChangePort ? port : void 0;
+		} else {
+			console.log(styleText("red", message));
+			return;
+		}
+	} catch (error) {
+		throw new Error(styleText("red", `Could not find an open port at ${styleText("bold", options.host)}.`) + "\n" + ("Network error message: " + error.message || error) + "\n");
+	}
+}
+/**
+* 编辑webpack配置
+*/
+function createCompiler(options) {
+	const { appName, config, urls } = options;
+	let compiler;
+	try {
+		compiler = rspack(config);
+	} catch (error) {
+		console.log(styleText("red", "Failed to compile."));
+		console.log();
+		console.log(error.message || error);
+		console.log();
+		exit(1);
+	}
+	compiler.hooks.invalid.tap("invalid", () => {
+		if (isInteractive$1) clearConsole();
+		console.log("Compiling...");
+	});
+	let isFirstCompile = true;
+	compiler.hooks.done.tap("done", async (stats) => {
+		if (isInteractive$1) clearConsole();
+		const statsData = stats.toJson({
+			all: false,
+			warnings: true,
+			errors: true
+		});
+		const errors = statsData.errors ?? [];
+		const warnings = statsData.warnings ?? [];
+		const isSuccessful = errors.length === 0 && warnings.length === 0;
+		if (isSuccessful) console.log(styleText("green", "Compiled successfully!"));
+		if (isSuccessful && (isInteractive$1 || isFirstCompile)) printInstructions(appName, urls);
+		isFirstCompile = false;
+		if (errors.length > 0) {
+			if (errors.length > 1) errors.length = 1;
+			console.log(styleText("red", "Failed to compile.\n"));
+			console.log(errors.join("\n\n"));
+			return;
+		}
+		if (warnings.length > 0) {
+			console.log(styleText("yellow", "Compiled with warnings.\n"));
+			console.log(warnings.join("\n\n"));
+			console.log("\nSearch for the " + styleText("underline", styleText("yellow", "keywords")) + " to learn more about each warning.");
+			console.log("To ignore, add " + styleText("cyan", "// eslint-disable-next-line") + " to the line before.\n");
+		}
+	});
+	return compiler;
+}
+//#endregion
+//#region utils/escape-string-regexp.ts
+function escapeStringRegexp(string) {
+	return string.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`).replaceAll("-", String.raw`\x2d`);
+}
+//#endregion
+//#region utils/ignored-files.ts
+function ignoredFiles(appSource) {
+	return new RegExp(`^(?!${escapeStringRegexp(pth.normalize(appSource + "/").replaceAll(/\\+/g, "/"))}).+/node_modules/`, "g");
+}
+//#endregion
+//#region rspack-dev-server.ts
+function createDevelopmentServerConfig() {
+	return {
+		allowedHosts: "all",
+		client: { overlay: true },
+		headers: {
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
+		},
+		compress: true,
+		static: {
+			directory: paths_default.appPublic,
+			publicPath: [paths_default.publicUrlOrPath],
+			watch: { ignored: ignoredFiles(paths_default.appSrc) }
+		},
+		devMiddleware: { publicPath: paths_default.publicUrlOrPath.slice(0, -1) },
+		historyApiFallback: {
+			disableDotRule: true,
+			index: paths_default.publicUrlOrPath
+		}
+	};
+}
+//#endregion
+//#region scripts/dev.ts
+const require = createRequire(import.meta.url);
+const isInteractive = process.stdout.isTTY;
+const developmentServerConfig = {
+	PORT: 3e3,
+	HOST: "0.0.0.0",
+	PROTOCOL: "http"
+};
+async function startDev(context) {
+	const { rspackConfig } = context;
+	try {
+		const port = await choosePort({ port: developmentServerConfig.PORT });
+		if (port === void 0) return;
+		const appName = require(paths_default.appPackageJson).name;
+		const urls = prepareUrls({
+			protocol: developmentServerConfig.PROTOCOL,
+			host: developmentServerConfig.HOST,
+			port,
+			pathname: paths_default.publicUrlOrPath.slice(0, -1)
+		});
+		const localUrlForBrowser = new URL(urls.localUrlForBrowser);
+		const compiler = createCompiler({
+			appName,
+			config: rspackConfig,
+			urls
+		});
+		const developmentServer = new RspackDevServer({
+			...createDevelopmentServerConfig(),
+			host: localUrlForBrowser.hostname,
+			port: localUrlForBrowser.port,
+			open: true
+		}, compiler);
+		developmentServer.startCallback((error) => {
+			if (isInteractive) clearConsole();
+			console.log(styleText("cyan", "Starting the development server...\n"));
+		});
+		developmentServer.stopCallback((error) => {
+			if (error) console.log("Server stopped.", error);
+		});
+		for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+			developmentServer.stop();
+			process.exit();
+		});
+		if (process.env.CI !== "true") process.stdin.on("end", function() {
+			developmentServer.stop();
+			exit();
+		});
+	} catch (error) {
+		if (error?.message) console.log(error.message);
+		exit(1);
+	}
+}
+//#endregion
+export { startDev as t };