@rsdoctor/core 0.0.2-beta.0

package/dist/inner-plugins/utils/index.js

@@ -0,0 +1,30 @@
+"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 utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./loader"), module.exports);
+__reExport(utils_exports, require("./plugin"), module.exports);
+__reExport(utils_exports, require("./sdk"), module.exports);
+__reExport(utils_exports, require("./config"), module.exports);
+__reExport(utils_exports, require("./circleDetect"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./loader"),
+  ...require("./plugin"),
+  ...require("./sdk"),
+  ...require("./config"),
+  ...require("./circleDetect")
+});

package/dist/inner-plugins/utils/loader.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="lodash" />
+/// <reference types="node" />
+import { SDK, Plugin } from '@rsdoctor/types';
+import { ProxyLoaderInternalOptions, ProxyLoaderOptions } from "../../types";
+import { Utils as BuildUtils, Types } from "../../build-utils/build";
+export declare function getInternalLoaderOptions(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ProxyLoaderInternalOptions;
+export declare function getLoaderOptionsWithoutInternalKeys(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): import("lodash").Omit<ProxyLoaderOptions, "__l__">;
+export declare function getOriginLoaderModule(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): ReturnType<typeof BuildUtils.loadLoaderModule>;
+export declare function shouldSkipLoader(loaderContext: Plugin.LoaderContext<ProxyLoaderOptions>): boolean;
+export declare function interceptLoader<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderPath: string, options: Omit<ProxyLoaderInternalOptions, 'loader' | 'hasOptions'>, cwd?: string, resolveLoader?: Plugin.Configuration['resolve']): T[];
+export declare function reportLoader(ctx: Plugin.LoaderContext<ProxyLoaderOptions>, start: number, startHRTime: [number, number], isPitch: boolean, sync: boolean, code: string, err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Types.SourceMapInput): Promise<SDK.LoaderData>;

package/dist/inner-plugins/utils/loader.js

@@ -0,0 +1,201 @@
+"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 loader_exports = {};
+__export(loader_exports, {
+  getInternalLoaderOptions: () => getInternalLoaderOptions,
+  getLoaderOptionsWithoutInternalKeys: () => getLoaderOptionsWithoutInternalKeys,
+  getOriginLoaderModule: () => getOriginLoaderModule,
+  interceptLoader: () => interceptLoader,
+  reportLoader: () => reportLoader,
+  shouldSkipLoader: () => shouldSkipLoader
+});
+module.exports = __toCommonJS(loader_exports);
+var import_axios = __toESM(require("axios"));
+var import_enhanced_resolve = require("enhanced-resolve");
+var import_fs = __toESM(require("fs"));
+var import_loader_utils = require("loader-utils");
+var import_lodash = require("lodash");
+var import_path = __toESM(require("path"));
+var import_logger = require("@rsdoctor/utils/logger");
+var import_common = require("@rsdoctor/utils/common");
+var import_common2 = require("@rsdoctor/utils/common");
+var import_types = require("@rsdoctor/types");
+var import_error = require("@rsdoctor/utils/error");
+var import_sdk = require("./sdk");
+var import_circleDetect = require("./circleDetect");
+var import_build = require("../../build-utils/build");
+function getInternalLoaderOptions(loaderContext) {
+  const options = import_build.Utils.getLoaderOptions(loaderContext);
+  return options[import_common.Loader.LoaderInternalPropertyName];
+}
+function getLoaderOptionsWithoutInternalKeys(loaderContext) {
+  const options = import_build.Utils.getLoaderOptions(loaderContext);
+  const circlePaths = [];
+  const loaderOptions = (0, import_lodash.omit)(options, [import_common.Loader.LoaderInternalPropertyName]);
+  (0, import_circleDetect.checkCirclePath)(loaderOptions, [], circlePaths, 0);
+  if (circlePaths.length > 0) {
+    circlePaths.forEach((_path) => {
+      if (_path?.length > 0 && loaderOptions[_path[0]] !== "[Circular]") {
+        loaderOptions[_path[0]] = "[Circular]";
+      }
+    });
+  }
+  return loaderOptions;
+}
+function getOriginLoaderModule(loaderContext) {
+  const { loader, cwd } = getInternalLoaderOptions(loaderContext);
+  return import_build.Utils.loadLoaderModule(loader, cwd);
+}
+function shouldSkipLoader(loaderContext) {
+  const { skipLoaders, cwd, loader } = getInternalLoaderOptions(loaderContext) || {};
+  if (!loader)
+    return true;
+  if (Array.isArray(skipLoaders) && skipLoaders.length) {
+    if (skipLoaders.includes(loader))
+      return true;
+    const loaderName = import_build.Utils.extractLoaderName(loader, cwd);
+    if (skipLoaders.includes(loaderName))
+      return true;
+  }
+  return false;
+}
+function interceptLoader(rules, loaderPath, options, cwd = process.cwd(), resolveLoader) {
+  const loaderResolver = import_enhanced_resolve.create.sync({
+    fileSystem: new import_enhanced_resolve.CachedInputFileSystem(import_fs.default, 4e3),
+    conditionNames: ["loader", "require", "node"],
+    exportsFields: ["exports"],
+    mainFiles: ["index"],
+    mainFields: ["loader", "main"],
+    extensions: ["js", ".json"],
+    modules: ["node_modules"],
+    ...resolveLoader
+  });
+  const resolve = (target) => {
+    try {
+      const result = loaderResolver({}, cwd, target);
+      if (typeof result === "string") {
+        return result;
+      }
+    } catch (e) {
+    }
+    return target;
+  };
+  return import_build.Utils.mapEachRules(rules, (rule) => {
+    if (rule?.loader && rule.loader.startsWith("builtin:")) {
+      return rule;
+    }
+    const opts = {
+      ..."options" in rule ? typeof rule.options === "string" ? JSON.parse(rule.options) : rule.options : {}
+    };
+    opts[import_common.Loader.LoaderInternalPropertyName] = {
+      ...options,
+      hasOptions: "options" in rule && Boolean(rule.options),
+      loader: "loader" in rule ? resolve(rule.loader) : ""
+    };
+    return {
+      ...rule,
+      loader: loaderPath,
+      options: opts
+    };
+  });
+}
+async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, res, sourceMap) {
+  const end = import_common2.Time.getCurrentTimestamp(start, startHRTime);
+  const { loader, host } = getInternalLoaderOptions(ctx);
+  const loaderData = [
+    {
+      resource: {
+        path: ctx.resourcePath,
+        query: (0, import_loader_utils.parseQuery)(ctx.resourceQuery || "?"),
+        queryRaw: ctx.resourceQuery,
+        ext: import_path.default.extname(ctx.resourcePath).slice(1)
+      },
+      loaders: [
+        {
+          loader: import_build.Utils.extractLoaderName(loader),
+          loaderIndex: ctx.loaderIndex,
+          path: loader,
+          input: code,
+          result: typeof res === "string" || Buffer.isBuffer(res) ? res.toString() : res,
+          startAt: start,
+          endAt: end,
+          options: getLoaderOptionsWithoutInternalKeys(ctx),
+          isPitch,
+          sync,
+          errors: err ? [
+            new import_error.DevToolError(code, err.message, {
+              controller: { noStack: false, noColor: true },
+              stack: err.stack
+            })
+          ] : [],
+          pid: process.pid,
+          ppid: process.ppid
+        }
+      ]
+    }
+  ];
+  const data = !sourceMap ? {} : (0, import_lodash.isString)(sourceMap) ? JSON.parse(sourceMap) : sourceMap;
+  const sourceMapData = {
+    version: data.version ?? -1,
+    sources: data.sources ?? [],
+    names: data.names ?? [],
+    sourceRoot: data.sourceRoot,
+    sourcesContent: data.sourcesContent,
+    mappings: data.mappings,
+    file: loaderData[0].resource.path
+  };
+  const sdk = (0, import_sdk.getSDK)();
+  if (sdk && sdk.reportLoader) {
+    sdk.reportLoader(loaderData);
+    sdk.reportSourceMap(sourceMapData);
+    return loaderData;
+  }
+  await Promise.all([
+    import_axios.default.post(`${host}${import_types.SDK.ServerAPI.API.ReportLoader}`, loaderData, {
+      timeout: 8888
+    }).catch((err2) => {
+      (0, import_logger.debug)(() => `${err2.message}`, "[WebpackPlugin.ReportLoader][error]");
+    }),
+    import_axios.default.post(`${host}${import_types.SDK.ServerAPI.API.ReportSourceMap}`, sourceMapData, {
+      timeout: 8888
+    }).catch((err2) => {
+      (0, import_logger.debug)(() => `${err2.message}`, "[WebpackPlugin.ReportSourceMap][error]");
+    })
+  ]);
+  return loaderData;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getInternalLoaderOptions,
+  getLoaderOptionsWithoutInternalKeys,
+  getOriginLoaderModule,
+  interceptLoader,
+  reportLoader,
+  shouldSkipLoader
+});

package/dist/inner-plugins/utils/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Hook } from 'tapable';
+import type { SDK } from '@rsdoctor/types';
+import type { DoctorWebpackSDK } from '@rsdoctor/sdk';
+export declare function reportPluginData(sdk: DoctorWebpackSDK, hook: string, tapName: string, start: number, type: SDK.PluginHookData['type'], _res: unknown, err?: Error): void;
+export declare function interceptPluginHook(sdk: DoctorWebpackSDK, name: string, hook: Hook<any, any>): void;

package/dist/inner-plugins/utils/plugin.js

@@ -0,0 +1,126 @@
+"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 plugin_exports = {};
+__export(plugin_exports, {
+  interceptPluginHook: () => interceptPluginHook,
+  reportPluginData: () => reportPluginData
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_error = require("@rsdoctor/utils/error");
+function reportPluginData(sdk, hook, tapName, start, type, _res, err) {
+  const end = Date.now();
+  sdk.reportPlugin({
+    [hook]: [
+      {
+        tapName,
+        costs: end - start,
+        startAt: start,
+        endAt: end,
+        type,
+        result: null,
+        // there are circular structure in json
+        error: err ? [
+          new import_error.DevToolError(`${tapName} ${hook} Error`, err.message, {
+            controller: { noStack: false, noColor: true },
+            stack: err.stack
+          })
+        ] : []
+      }
+    ]
+  });
+}
+function interceptPluginHook(sdk, name, hook) {
+  if (!hook.intercept) {
+    return;
+  }
+  hook.intercept({
+    register(tap) {
+      const o = tap.fn;
+      if (tap.type === "sync") {
+        tap.fn = function() {
+          const start = Date.now();
+          try {
+            const res = o.apply(this, arguments);
+            reportPluginData(sdk, name, tap.name, start, tap.type, res);
+            return res;
+          } catch (error) {
+            reportPluginData(
+              sdk,
+              name,
+              tap.name,
+              start,
+              tap.type,
+              null,
+              error
+            );
+            throw error;
+          }
+        };
+      } else if (tap.type === "async") {
+        tap.fn = async function() {
+          const start = Date.now();
+          try {
+            const res = await o.apply(this, arguments);
+            reportPluginData(sdk, name, tap.name, start, tap.type, res);
+            return res;
+          } catch (error) {
+            reportPluginData(
+              sdk,
+              name,
+              tap.name,
+              start,
+              tap.type,
+              null,
+              error
+            );
+            throw error;
+          }
+        };
+      } else if (tap.type === "promise") {
+        tap.fn = function() {
+          const start = Date.now();
+          const isChild = arguments?.[0]?.compiler?.isChild();
+          return o.apply(this, arguments).then((res) => {
+            if (isChild)
+              return res;
+            reportPluginData(sdk, name, tap.name, start, tap.type, res);
+            return res;
+          }).catch((error) => {
+            reportPluginData(
+              sdk,
+              name,
+              tap.name,
+              start,
+              tap.type,
+              null,
+              error
+            );
+            throw error;
+          });
+        };
+      }
+      return tap;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  interceptPluginHook,
+  reportPluginData
+});

package/dist/inner-plugins/utils/sdk.d.ts

@@ -0,0 +1,3 @@
+import { DoctorWebpackSDK } from '@rsdoctor/sdk';
+export declare function setSDK(t: DoctorWebpackSDK): void;
+export declare function getSDK(): DoctorWebpackSDK;

package/dist/inner-plugins/utils/sdk.js

@@ -0,0 +1,36 @@
+"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 sdk_exports = {};
+__export(sdk_exports, {
+  getSDK: () => getSDK,
+  setSDK: () => setSDK
+});
+module.exports = __toCommonJS(sdk_exports);
+let sdk;
+function setSDK(t) {
+  sdk = t;
+}
+function getSDK() {
+  return sdk;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSDK,
+  setSDK
+});

package/dist/rules/index.d.ts

@@ -0,0 +1,3 @@
+export * from './linter';
+export * from './rule';
+export { rules } from './rules';

package/dist/rules/index.js

@@ -0,0 +1,33 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rules_exports = {};
+__export(rules_exports, {
+  rules: () => import_rules.rules
+});
+module.exports = __toCommonJS(rules_exports);
+__reExport(rules_exports, require("./linter"), module.exports);
+__reExport(rules_exports, require("./rule"), module.exports);
+var import_rules = require("./rules");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rules,
+  ...require("./linter"),
+  ...require("./rule")
+});

package/dist/rules/linter.d.ts

@@ -0,0 +1,13 @@
+import { Linter as LinterType, SDK } from '@rsdoctor/types';
+export { LinterType };
+export declare class Linter<Rules extends LinterType.ExtendRuleData[]> {
+  private rules;
+  constructor({
+    rules,
+    extends: extendRules,
+    level
+  }?: LinterType.Options<Rules>);
+  private getRules;
+  validate(context: SDK.RuntimeContext): Promise<LinterType.ValidateResult>;
+  afterValidate(context: LinterType.InternalRuleCheckerContextForCheckEnd): Promise<void>;
+}

package/dist/rules/linter.js

@@ -0,0 +1,74 @@
+"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 linter_exports = {};
+__export(linter_exports, {
+  Linter: () => Linter,
+  LinterType: () => import_types.Linter
+});
+module.exports = __toCommonJS(linter_exports);
+var import_types = require("@rsdoctor/types");
+var import_rule = require("./rule");
+var import_rules = require("./rules");
+var import_utils = require("./utils");
+class Linter {
+  constructor({
+    rules,
+    extends: extendRules,
+    level
+  } = {}) {
+    this.rules = [];
+    this.rules = this.getRules(
+      rules ?? {},
+      extendRules ?? [],
+      (0, import_utils.toSeverity)(level ?? "Error", import_types.Linter.Severity.Error)
+    );
+  }
+  getRules(ruleMap, extendRules, filterLevel) {
+    const outside = extendRules.map((item) => import_rule.Rule.from(item));
+    const rules = import_rules.rules.map((item) => new import_rule.Rule(item)).concat(outside);
+    rules.forEach((rule) => {
+      if (ruleMap[rule.title]) {
+        rule.setOption(ruleMap[rule.title]);
+      }
+    });
+    return rules.filter((rule) => rule.match(filterLevel));
+  }
+  async validate(context) {
+    const lintResult = {
+      errors: [],
+      replace: []
+    };
+    await Promise.all(
+      this.rules.map(async (rule) => {
+        const result = await rule.validate(context);
+        lintResult.errors.push(...result.errors);
+        lintResult.replace.push(...result.replace);
+      })
+    );
+    return lintResult;
+  }
+  async afterValidate(context) {
+    await Promise.all(this.rules.map((rule) => rule.afterValidate(context)));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Linter,
+  LinterType
+});

package/dist/rules/rule.d.ts

@@ -0,0 +1,31 @@
+import { Linter, SDK, Rule as RuleTypes } from '@rsdoctor/types';
+import { LinterType } from './linter';
+type DefaultRuleConfig = Linter.DefaultRuleConfig;
+export declare class Rule<Config = DefaultRuleConfig> implements Linter.RuleMeta<Config> {
+  static from<C>(data: Linter.ExtendRuleData<C>): Rule<C>;
+  readonly meta: Linter.RuleMeta<Config>;
+  private check;
+  /**
+   * execute when check end
+   */
+  private onCheckEnd;
+  private _severity;
+  private _config?;
+  constructor(data: Linter.RuleData<Config>);
+  get code(): RuleTypes.RuleMessageCode;
+  get title(): string;
+  get severity(): Linter.Severity;
+  get config(): Config | undefined;
+  get category(): "bundle" | "compile" | RuleTypes.RuleMessageCategory | "emo";
+  setOption(opt: Linter.RuleConfigItem): void;
+  match(level: Linter.Severity): boolean;
+  validate(context: SDK.RuntimeContext): Promise<Linter.ValidateResult>;
+  afterValidate({
+    hooks,
+    validateResult,
+    data
+  }: LinterType.InternalRuleCheckerContextForCheckEnd<Config>): Promise<void>;
+}
+export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.ExtendRuleConstructor<Title, T>): Linter.ExtendRuleData<T, Title>;
+export declare function defineRule<Title extends Linter.DefaultRuleTitle, T = Linter.DefaultRuleConfig>(ruleCreator: Linter.RuleConstructor<Title, T>): Linter.RuleData<T, Title>;
+export {};