@rsdoctor/cli 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# Rsdoctor Cli
+
+This is the cli package of Rsdoctor, you can use the capabilities of this package to open the analysis page without building.
+
+```
+
+npx @rsdoctor/cli analyze --profile [.rsdoctor/manifest.json filepath]
+
+```
+
+## features
+
+- Rsdoctor is a one-stop tool for diagnosing and analyzing the build process and build artifacts.
+- Rsdoctor is a tool that supports Webpack and Rspack build analysis.
+- Rsdoctor is an analysis tool that can display the time-consuming and behavioral details of the compilation.
+- Rsdoctor is a tool that provides bundle Diff and other anti-degradation capabilities simultaneously.
+
+## Documentation
+
+https://rsdoctor.dev/
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsdoctor/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsdoctor is [MIT licensed](https://github.com/web-infra-dev/rsdoctor/blob/main/LICENSE).

package/bin/rsdoctor

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { execute } = require('../dist/index.js');
+
+execute();

package/dist/commands/analyze.d.ts

@@ -0,0 +1,12 @@
+import { SDK } from '@rsdoctor/types';
+import { RsdoctorWebpackSDK } from '@rsdoctor/sdk';
+import { Command } from '../types';
+import { Commands } from '../constants';
+interface Options {
+    profile: string;
+    open?: boolean;
+    port?: number;
+    type?: SDK.ToDataType;
+}
+export declare const analyze: Command<Commands.Analyze, Options, RsdoctorWebpackSDK>;
+export {};

package/dist/commands/analyze.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var analyze_exports = {};
+__export(analyze_exports, {
+  analyze: () => analyze
+});
+module.exports = __toCommonJS(analyze_exports);
+var import_common = require("@rsdoctor/utils/common");
+var import_types = require("@rsdoctor/types");
+var import_sdk = require("@rsdoctor/sdk");
+var import_ora = __toESM(require("ora"));
+var import_chalk = require("chalk");
+var import_utils = require("../utils");
+var import_constants = require("../constants");
+const analyze = (0, import_utils.enhanceCommand)(({ cwd, name, bin }) => ({
+  command: import_constants.Commands.Analyze,
+  description: `
+use ${name} to open "${import_types.Constants.RsdoctorOutputManifestPath}" in browser for analysis.
+
+example: ${bin} ${import_constants.Commands.Analyze} --profile "${import_types.Constants.RsdoctorOutputManifestPath}"
+
+`.trim(),
+  options(yargs) {
+    yargs.option("profile", {
+      type: "string",
+      description: "profile for Rsdoctor server",
+      demandOption: true
+    }).option("open", {
+      type: "boolean",
+      description: "turn off it if you need not open browser automatically",
+      default: true
+    }).option("port", {
+      type: "number",
+      description: "port for Rsdoctor Server"
+    }).option("type", {
+      type: "boolean",
+      description: "if need lite bundle mode"
+    });
+  },
+  async action({ profile, open = true, port, type = import_types.SDK.ToDataType.Normal }) {
+    const spinner = (0, import_ora.default)({ prefixText: (0, import_chalk.cyan)(`[${name}]`) }).start(
+      `start to loading "${profile}"`
+    );
+    const json = await (0, import_utils.loadJSON)(
+      profile,
+      cwd
+    );
+    spinner.text = `start to loading data...`;
+    let dataValue;
+    try {
+      dataValue = await import_common.Manifest.fetchShardingFiles(
+        json.data,
+        (url) => (0, import_utils.loadShardingFileWithSpinner)(url, cwd, spinner)
+      );
+    } catch (error) {
+      spinner.fail((0, import_chalk.red)(error.message));
+      throw error;
+    }
+    spinner.text = `start server`;
+    const sdk = new import_sdk.RsdoctorWebpackSDK({ name, root: cwd, port, type });
+    await sdk.bootstrap();
+    sdk.getStoreData = () => dataValue;
+    sdk.getManifestData = () => json;
+    const manifestBuffer = Buffer.from(
+      JSON.stringify({ ...json, __LOCAL__SERVER__: true })
+    );
+    sdk.server.proxy(import_types.SDK.ServerAPI.API.Manifest, "GET", () => manifestBuffer);
+    if (open) {
+      spinner.text = `open browser automatically`;
+      await sdk.server.openClientPage("homepage");
+    }
+    spinner.succeed(
+      `the local url: ${(0, import_chalk.cyan)(sdk.server.getClientUrl("homepage"))}`
+    );
+    return sdk;
+  }
+}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyze
+});

package/dist/commands/index.d.ts

@@ -0,0 +1 @@
+export * from './analyze';

package/dist/commands/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var commands_exports = {};
+module.exports = __toCommonJS(commands_exports);
+__reExport(commands_exports, require("./analyze"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./analyze")
+});

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum Commands {
+    Analyze = "analyze"
+}
+export declare const pkg: {
+    name: string;
+    version: string;
+    bin: Record<string, string>;
+};
+export declare const bin: string;

package/dist/constants.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  Commands: () => Commands,
+  bin: () => bin,
+  pkg: () => pkg
+});
+module.exports = __toCommonJS(constants_exports);
+var Commands = /* @__PURE__ */ ((Commands2) => {
+  Commands2["Analyze"] = "analyze";
+  return Commands2;
+})(Commands || {});
+const pkg = require("../package.json");
+const bin = Object.keys(pkg.bin)[0];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Commands,
+  bin,
+  pkg
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { analyze } from './commands';
+import { GetCommandArgumentsType } from './types';
+import { Commands } from './constants';
+export declare function execute<T extends GetCommandArgumentsType<typeof analyze>>(command: Commands.Analyze | `${Commands.Analyze}`, options: T['options']): Promise<T['result']>;
+export declare function execute(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  execute: () => execute
+});
+module.exports = __toCommonJS(src_exports);
+var import_yargs = __toESM(require("yargs/yargs"));
+var import_helpers = require("yargs/helpers");
+var import_chalk = __toESM(require("chalk"));
+var import_commands = require("./commands");
+var import_constants = require("./constants");
+async function execute(command, options) {
+  const cwd = process.cwd();
+  const { name, version } = import_constants.pkg;
+  const ctx = { bin: import_constants.bin, cwd, name };
+  if (command === import_constants.Commands.Analyze) {
+    const { action } = (0, import_commands.analyze)(ctx);
+    return action(
+      options
+    );
+  }
+  const argv = (0, import_helpers.hideBin)(process.argv);
+  const args = (0, import_yargs.default)(argv).usage(`${import_constants.bin} <command> [options]`);
+  args.version(version);
+  const commands = [import_commands.analyze];
+  commands.forEach((cmd) => {
+    const { command: command2, description, options: options2, action } = cmd(ctx);
+    args.command(
+      command2,
+      description,
+      (yargs2) => {
+        return options2(yargs2.usage(`${import_constants.bin} ${command2} [options]`));
+      },
+      async (args2) => {
+        try {
+          await action(args2);
+        } catch (error) {
+          const { message, stack } = error;
+          console.log("");
+          console.error(import_chalk.default.red(stack || message));
+          process.exit(1);
+        }
+      }
+    );
+  });
+  if (!argv.length) {
+    args.showHelp();
+  }
+  await args.parse();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  execute
+});

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import { Common } from '@rsdoctor/types';
+import { Argv } from 'yargs';
+export interface Command<CMD, Options = Common.PlainObject, Result = unknown> {
+    (ctx: CommandContext): CommandOutput<CMD, Options, Result>;
+}
+export interface CommandContext {
+    name: string;
+    bin: string;
+    cwd: string;
+}
+export interface CommandOutput<CMD, Options, Result> {
+    command: CMD;
+    description: string;
+    options(yargs: Argv<Options>): void;
+    action(args: Options): Result | Promise<Result>;
+}
+export type GetCommandArgumentsType<T> = T extends Command<infer C, infer Options, infer Result> ? {
+    command: C;
+    options: Options;
+    result: Result;
+} : unknown;

package/dist/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import { Ora } from 'ora';
+import { Command } from './types';
+import { Common } from '@rsdoctor/types';
+export declare function enhanceCommand<CMD extends string, Options, Result>(fn: Command<CMD, Options, Result>): Command<CMD, Options, Result>;
+export declare function fetchText(url: string): Promise<any>;
+export declare function readFile(url: string, cwd: string): Promise<string>;
+export declare function loadJSON<T extends Common.PlainObject>(uri: string, cwd: string): Promise<T>;
+export declare function loadShardingFile(uri: string, cwd: string): Promise<string>;
+export declare function loadShardingFileWithSpinner(uri: string, cwd: string, spinner: Ora): Promise<string>;

package/dist/utils.js

@@ -0,0 +1,94 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  enhanceCommand: () => enhanceCommand,
+  fetchText: () => fetchText,
+  loadJSON: () => loadJSON,
+  loadShardingFile: () => loadShardingFile,
+  loadShardingFileWithSpinner: () => loadShardingFileWithSpinner,
+  readFile: () => readFile
+});
+module.exports = __toCommonJS(utils_exports);
+var import_axios = __toESM(require("axios"));
+var import_path = __toESM(require("path"));
+var import_common = require("@rsdoctor/utils/common");
+var import_build = require("@rsdoctor/utils/build");
+function enhanceCommand(fn) {
+  return (ctx) => {
+    const res = fn(ctx);
+    return res;
+  };
+}
+async function fetchText(url) {
+  const { data } = await import_axios.default.get(url, {
+    timeout: 6e4,
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Accept-Encoding": "gzip,deflate,compress"
+    }
+  });
+  return data;
+}
+async function readFile(url, cwd) {
+  const file = import_path.default.resolve(cwd, url);
+  return import_build.File.fse.readFile(file, "utf-8");
+}
+async function loadJSON(uri, cwd) {
+  if (import_common.Url.isUrl(uri)) {
+    const data = await fetchText(uri);
+    return data;
+  }
+  const file = await readFile(uri, cwd);
+  return JSON.parse(file);
+}
+async function loadShardingFile(uri, cwd) {
+  if (import_common.Url.isUrl(uri)) {
+    return fetchText(uri);
+  }
+  if (import_common.Url.isFilePath(uri)) {
+    return readFile(uri, cwd);
+  }
+  return Promise.resolve(uri);
+}
+async function loadShardingFileWithSpinner(uri, cwd, spinner) {
+  return loadShardingFile(uri, cwd).then((res) => {
+    spinner.text = `loaded "${uri}"`;
+    return res;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enhanceCommand,
+  fetchText,
+  loadJSON,
+  loadShardingFile,
+  loadShardingFileWithSpinner,
+  readFile
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rsdoctor/cli",
+  "version": "0.1.2",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-infra-dev/rsdoctor",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "rsdoctor": "./bin/rsdoctor"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/yargs": "17.0.13",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "axios": "^1.6.1",
+    "chalk": "^4.1.2",
+    "ora": "^5.0.1",
+    "tslib": "2.4.1",
+    "yargs": "17.6.2",
+    "@rsdoctor/sdk": "0.1.2",
+    "@rsdoctor/utils": "0.1.2",
+    "@rsdoctor/types": "0.1.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "dev": "npm run start",
+    "build": "modern build",
+    "start": "modern build -w",
+    "test": "vitest run"
+  }
+}