@rsdoctor/components 0.3.11 → 0.4.0

package/dist/pages/TreeShaking/range.js

@@ -0,0 +1,542 @@
+class Range {
+  constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
+    if (startLineNumber > endLineNumber || startLineNumber === endLineNumber && startColumn > endColumn) {
+      this.startLineNumber = endLineNumber;
+      this.startColumn = endColumn;
+      this.endLineNumber = startLineNumber;
+      this.endColumn = startColumn;
+    } else {
+      this.startLineNumber = startLineNumber;
+      this.startColumn = startColumn;
+      this.endLineNumber = endLineNumber;
+      this.endColumn = endColumn;
+    }
+  }
+  /**
+   * Test if this range is empty.
+   */
+  isEmpty() {
+    return Range.isEmpty(this);
+  }
+  /**
+   * Test if `range` is empty.
+   */
+  static isEmpty(range) {
+    return range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn;
+  }
+  /**
+   * Test if position is in this range. If the position is at the edges, will return true.
+   */
+  containsPosition(position) {
+    return Range.containsPosition(this, position);
+  }
+  /**
+   * Test if `position` is in `range`. If the position is at the edges, will return true.
+   */
+  static containsPosition(range, position) {
+    if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+      return false;
+    }
+    if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
+      return false;
+    }
+    if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Test if `position` is in `range`. If the position is at the edges, will return false.
+   * @internal
+   */
+  static strictContainsPosition(range, position) {
+    if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
+      return false;
+    }
+    if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {
+      return false;
+    }
+    if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Test if range is in this range. If the range is equal to this range, will return true.
+   */
+  containsRange(range) {
+    return Range.containsRange(this, range);
+  }
+  /**
+   * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+   */
+  static containsRange(range, otherRange) {
+    if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+      return false;
+    }
+    if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+      return false;
+    }
+    if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {
+      return false;
+    }
+    if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.
+   */
+  strictContainsRange(range) {
+    return Range.strictContainsRange(this, range);
+  }
+  /**
+   * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+   */
+  static strictContainsRange(range, otherRange) {
+    if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
+      return false;
+    }
+    if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
+      return false;
+    }
+    if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {
+      return false;
+    }
+    if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * A reunion of the two ranges.
+   * The smallest position will be used as the start point, and the largest one as the end point.
+   */
+  plusRange(range) {
+    return Range.plusRange(this, range);
+  }
+  /**
+   * A reunion of the two ranges.
+   * The smallest position will be used as the start point, and the largest one as the end point.
+   */
+  static plusRange(a, b) {
+    let startLineNumber;
+    let startColumn;
+    let endLineNumber;
+    let endColumn;
+    if (b.startLineNumber < a.startLineNumber) {
+      startLineNumber = b.startLineNumber;
+      startColumn = b.startColumn;
+    } else if (b.startLineNumber === a.startLineNumber) {
+      startLineNumber = b.startLineNumber;
+      startColumn = Math.min(b.startColumn, a.startColumn);
+    } else {
+      startLineNumber = a.startLineNumber;
+      startColumn = a.startColumn;
+    }
+    if (b.endLineNumber > a.endLineNumber) {
+      endLineNumber = b.endLineNumber;
+      endColumn = b.endColumn;
+    } else if (b.endLineNumber === a.endLineNumber) {
+      endLineNumber = b.endLineNumber;
+      endColumn = Math.max(b.endColumn, a.endColumn);
+    } else {
+      endLineNumber = a.endLineNumber;
+      endColumn = a.endColumn;
+    }
+    return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+  }
+  /**
+   * A intersection of the two ranges.
+   */
+  intersectRanges(range) {
+    return Range.intersectRanges(this, range);
+  }
+  /**
+   * A intersection of the two ranges.
+   */
+  static intersectRanges(a, b) {
+    let resultStartLineNumber = a.startLineNumber;
+    let resultStartColumn = a.startColumn;
+    let resultEndLineNumber = a.endLineNumber;
+    let resultEndColumn = a.endColumn;
+    const otherStartLineNumber = b.startLineNumber;
+    const otherStartColumn = b.startColumn;
+    const otherEndLineNumber = b.endLineNumber;
+    const otherEndColumn = b.endColumn;
+    if (resultStartLineNumber < otherStartLineNumber) {
+      resultStartLineNumber = otherStartLineNumber;
+      resultStartColumn = otherStartColumn;
+    } else if (resultStartLineNumber === otherStartLineNumber) {
+      resultStartColumn = Math.max(resultStartColumn, otherStartColumn);
+    }
+    if (resultEndLineNumber > otherEndLineNumber) {
+      resultEndLineNumber = otherEndLineNumber;
+      resultEndColumn = otherEndColumn;
+    } else if (resultEndLineNumber === otherEndLineNumber) {
+      resultEndColumn = Math.min(resultEndColumn, otherEndColumn);
+    }
+    if (resultStartLineNumber > resultEndLineNumber) {
+      return null;
+    }
+    if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {
+      return null;
+    }
+    return new Range(
+      resultStartLineNumber,
+      resultStartColumn,
+      resultEndLineNumber,
+      resultEndColumn
+    );
+  }
+  /**
+   * Test if this range equals other.
+   */
+  equalsRange(other) {
+    return Range.equalsRange(this, other);
+  }
+  /**
+   * Test if range `a` equals `b`.
+   */
+  static equalsRange(a, b) {
+    if (!a && !b) {
+      return true;
+    }
+    return !!a && !!b && a.startLineNumber === b.startLineNumber && a.startColumn === b.startColumn && a.endLineNumber === b.endLineNumber && a.endColumn === b.endColumn;
+  }
+  /**
+   * Return the end position (which will be after or equal to the start position)
+   */
+  getEndPosition() {
+    return Range.getEndPosition(this);
+  }
+  /**
+   * Return the end position (which will be after or equal to the start position)
+   */
+  static getEndPosition(range) {
+    return new Position(range.endLineNumber, range.endColumn);
+  }
+  /**
+   * Return the start position (which will be before or equal to the end position)
+   */
+  getStartPosition() {
+    return Range.getStartPosition(this);
+  }
+  /**
+   * Return the start position (which will be before or equal to the end position)
+   */
+  static getStartPosition(range) {
+    return new Position(range.startLineNumber, range.startColumn);
+  }
+  /**
+   * Transform to a user presentable string representation.
+   */
+  toString() {
+    return `[${this.startLineNumber},${this.startColumn} -> ${this.endLineNumber},${this.endColumn}]`;
+  }
+  /**
+   * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+   */
+  setEndPosition(endLineNumber, endColumn) {
+    return new Range(
+      this.startLineNumber,
+      this.startColumn,
+      endLineNumber,
+      endColumn
+    );
+  }
+  /**
+   * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+   */
+  setStartPosition(startLineNumber, startColumn) {
+    return new Range(
+      startLineNumber,
+      startColumn,
+      this.endLineNumber,
+      this.endColumn
+    );
+  }
+  /**
+   * Create a new empty range using this range's start position.
+   */
+  collapseToStart() {
+    return Range.collapseToStart(this);
+  }
+  /**
+   * Create a new empty range using this range's start position.
+   */
+  static collapseToStart(range) {
+    return new Range(
+      range.startLineNumber,
+      range.startColumn,
+      range.startLineNumber,
+      range.startColumn
+    );
+  }
+  /**
+   * Create a new empty range using this range's end position.
+   */
+  collapseToEnd() {
+    return Range.collapseToEnd(this);
+  }
+  /**
+   * Create a new empty range using this range's end position.
+   */
+  static collapseToEnd(range) {
+    return new Range(
+      range.endLineNumber,
+      range.endColumn,
+      range.endLineNumber,
+      range.endColumn
+    );
+  }
+  /**
+   * Moves the range by the given amount of lines.
+   */
+  delta(lineCount) {
+    return new Range(
+      this.startLineNumber + lineCount,
+      this.startColumn,
+      this.endLineNumber + lineCount,
+      this.endColumn
+    );
+  }
+  // ---
+  static fromPositions(start, end = start) {
+    return new Range(
+      start.lineNumber,
+      start.column,
+      end.lineNumber,
+      end.column
+    );
+  }
+  static lift(range) {
+    if (!range) {
+      return null;
+    }
+    return new Range(
+      range.startLineNumber,
+      range.startColumn,
+      range.endLineNumber,
+      range.endColumn
+    );
+  }
+  /**
+   * Test if `obj` is an `IRange`.
+   */
+  static isIRange(obj) {
+    return obj && typeof obj.startLineNumber === "number" && typeof obj.startColumn === "number" && typeof obj.endLineNumber === "number" && typeof obj.endColumn === "number";
+  }
+  /**
+   * Test if the two ranges are touching in any way.
+   */
+  static areIntersectingOrTouching(a, b) {
+    if (a.endLineNumber < b.startLineNumber || a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn) {
+      return false;
+    }
+    if (b.endLineNumber < a.startLineNumber || b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+   */
+  static areIntersecting(a, b) {
+    if (a.endLineNumber < b.startLineNumber || a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn) {
+      return false;
+    }
+    if (b.endLineNumber < a.startLineNumber || b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * A function that compares ranges, useful for sorting ranges
+   * It will first compare ranges on the startPosition and then on the endPosition
+   */
+  static compareRangesUsingStarts(a, b) {
+    if (a && b) {
+      const aStartLineNumber = a.startLineNumber | 0;
+      const bStartLineNumber = b.startLineNumber | 0;
+      if (aStartLineNumber === bStartLineNumber) {
+        const aStartColumn = a.startColumn | 0;
+        const bStartColumn = b.startColumn | 0;
+        if (aStartColumn === bStartColumn) {
+          const aEndLineNumber = a.endLineNumber | 0;
+          const bEndLineNumber = b.endLineNumber | 0;
+          if (aEndLineNumber === bEndLineNumber) {
+            const aEndColumn = a.endColumn | 0;
+            const bEndColumn = b.endColumn | 0;
+            return aEndColumn - bEndColumn;
+          }
+          return aEndLineNumber - bEndLineNumber;
+        }
+        return aStartColumn - bStartColumn;
+      }
+      return aStartLineNumber - bStartLineNumber;
+    }
+    const aExists = a ? 1 : 0;
+    const bExists = b ? 1 : 0;
+    return aExists - bExists;
+  }
+  /**
+   * A function that compares ranges, useful for sorting ranges
+   * It will first compare ranges on the endPosition and then on the startPosition
+   */
+  static compareRangesUsingEnds(a, b) {
+    if (a.endLineNumber === b.endLineNumber) {
+      if (a.endColumn === b.endColumn) {
+        if (a.startLineNumber === b.startLineNumber) {
+          return a.startColumn - b.startColumn;
+        }
+        return a.startLineNumber - b.startLineNumber;
+      }
+      return a.endColumn - b.endColumn;
+    }
+    return a.endLineNumber - b.endLineNumber;
+  }
+  /**
+   * Test if the range spans multiple lines.
+   */
+  static spansMultipleLines(range) {
+    return range.endLineNumber > range.startLineNumber;
+  }
+  toJSON() {
+    return this;
+  }
+}
+class Position {
+  constructor(lineNumber, column) {
+    this.lineNumber = lineNumber;
+    this.column = column;
+  }
+  /**
+   * Create a new position from this position.
+   *
+   * @param newLineNumber new line number
+   * @param newColumn new column
+   */
+  with(newLineNumber = this.lineNumber, newColumn = this.column) {
+    if (newLineNumber === this.lineNumber && newColumn === this.column) {
+      return this;
+    }
+    return new Position(newLineNumber, newColumn);
+  }
+  /**
+   * Derive a new position from this position.
+   *
+   * @param deltaLineNumber line number delta
+   * @param deltaColumn column delta
+   */
+  delta(deltaLineNumber = 0, deltaColumn = 0) {
+    return this.with(
+      this.lineNumber + deltaLineNumber,
+      this.column + deltaColumn
+    );
+  }
+  /**
+   * Test if this position equals other position
+   */
+  equals(other) {
+    return Position.equals(this, other);
+  }
+  /**
+   * Test if position `a` equals position `b`
+   */
+  static equals(a, b) {
+    if (!a && !b) {
+      return true;
+    }
+    return !!a && !!b && a.lineNumber === b.lineNumber && a.column === b.column;
+  }
+  /**
+   * Test if this position is before other position.
+   * If the two positions are equal, the result will be false.
+   */
+  isBefore(other) {
+    return Position.isBefore(this, other);
+  }
+  /**
+   * Test if position `a` is before position `b`.
+   * If the two positions are equal, the result will be false.
+   */
+  static isBefore(a, b) {
+    if (a.lineNumber < b.lineNumber) {
+      return true;
+    }
+    if (b.lineNumber < a.lineNumber) {
+      return false;
+    }
+    return a.column < b.column;
+  }
+  /**
+   * Test if this position is before other position.
+   * If the two positions are equal, the result will be true.
+   */
+  isBeforeOrEqual(other) {
+    return Position.isBeforeOrEqual(this, other);
+  }
+  /**
+   * Test if position `a` is before position `b`.
+   * If the two positions are equal, the result will be true.
+   */
+  static isBeforeOrEqual(a, b) {
+    if (a.lineNumber < b.lineNumber) {
+      return true;
+    }
+    if (b.lineNumber < a.lineNumber) {
+      return false;
+    }
+    return a.column <= b.column;
+  }
+  /**
+   * A function that compares positions, useful for sorting
+   */
+  static compare(a, b) {
+    const aLineNumber = a.lineNumber | 0;
+    const bLineNumber = b.lineNumber | 0;
+    if (aLineNumber === bLineNumber) {
+      const aColumn = a.column | 0;
+      const bColumn = b.column | 0;
+      return aColumn - bColumn;
+    }
+    return aLineNumber - bLineNumber;
+  }
+  /**
+   * Clone this position.
+   */
+  clone() {
+    return new Position(this.lineNumber, this.column);
+  }
+  /**
+   * Convert to a human-readable representation.
+   */
+  toString() {
+    return `(${this.lineNumber},${this.column})`;
+  }
+  // ---
+  /**
+   * Create a `Position` from an `IPosition`.
+   */
+  static lift(pos) {
+    return new Position(pos.lineNumber, pos.column);
+  }
+  /**
+   * Test if `obj` is an `IPosition`.
+   */
+  static isIPosition(obj) {
+    return obj && typeof obj.lineNumber === "number" && typeof obj.column === "number";
+  }
+  toJSON() {
+    return {
+      lineNumber: this.lineNumber,
+      column: this.column
+    };
+  }
+}
+export {
+  Position,
+  Range
+};

package/dist/pages/TreeShaking/utils.d.ts

@@ -1,5 +1,5 @@
 import { Module, ModuleGraph, Statement } from '@rsdoctor/graph';
-import { editor } from 'monaco-editor';
+import type { editor } from 'monaco-editor';
 export declare function useFileStructures(modules: Module[], moduleGraph: ModuleGraph, searchInput: string, selectedModule: Module, onItemClick: (file: string) => void, cwd: string): import("../../utils").DataNode[];
 export declare function getTreeFilesDefaultExpandedKeys(files: any[]): (string | number)[];
 export declare function ellipsisPath(full: string): string;

package/dist/pages/TreeShaking/utils.js

@@ -4,7 +4,7 @@ import path from "path-browserify";
 import { escape, get } from "lodash-es";
 import { Module } from "@rsdoctor/graph";
 import { Tag, Space } from "antd";
-import { Range } from "monaco-editor";
+import { Range } from "./range";
 import { getOpenTagText } from "./open-tag";
 import {
   createFileStructures,

package/dist/pages/WebpackLoaders/Analysis/index.js

@@ -8,7 +8,7 @@ const Page = () => {
     {
       title: "Webpack Loader Analysis",
       extra: /* @__PURE__ */ jsx(WebpackConfigurationViewer, { defaultKeys: ["module", "resolve"] }),
-      bodyStyle: { paddingTop: 0 },
+      bodyStyle: { paddingTop: 0, height: 800 },
       children: /* @__PURE__ */ jsx(LoaderAnalysis, {})
     }
   );

package/dist/utils/data/brief.d.ts

@@ -0,0 +1,11 @@
+import { Manifest, SDK } from '@rsdoctor/types';
+import { BaseDataLoader } from './base';
+export declare class BriefDataLoader extends BaseDataLoader {
+    isLocal(): boolean;
+    loadData<T extends Manifest.RsdoctorManifestMappingKeys>(key: T): Promise<Manifest.InferManifestDataValue<T>>;
+    getData(scope: keyof Manifest.RsdoctorManifestData): any;
+    loadAPI<T extends SDK.ServerAPI.API, B extends SDK.ServerAPI.InferRequestBodyType<T> = SDK.ServerAPI.InferRequestBodyType<T>, R extends SDK.ServerAPI.InferResponseType<T> = SDK.ServerAPI.InferResponseType<T>>(...args: B extends void ? [api: T] : [api: T, body: B]): Promise<R>;
+    dispose(): void;
+    onDataUpdate(): void;
+    removeOnDataUpdate(): void;
+}

package/dist/utils/data/brief.js

@@ -0,0 +1,42 @@
+import { Algorithm } from "@rsdoctor/utils/common";
+import { BaseDataLoader } from "./base";
+import { Constants } from "@rsdoctor/types";
+class BriefDataLoader extends BaseDataLoader {
+  isLocal() {
+    return false;
+  }
+  async loadData(key) {
+    console.log(`[loadData]-[key]: ${key}`);
+    const [scope] = this.getKeys(key);
+    console.log(`[loadData]-[scope]: ${scope}`);
+    const data = this.getData(scope);
+    console.log(`[loadData]-[data]: ${data}`);
+    if (!data)
+      return;
+    let res = data;
+    if (!this.shardingDataMap.has(scope)) {
+      const scopeData = typeof res === "object" ? res : JSON.parse(Algorithm.decompressText(res));
+      console.log(`[loadData]-[scopeData]: ${scopeData}`);
+      this.shardingDataMap.set(scope, scopeData);
+    }
+    res = await this.shardingDataMap.get(scope);
+    return res;
+  }
+  getData(scope) {
+    console.log(`[getData]-[scope]: ${scope}`);
+    return window[Constants.WINDOW_RSDOCTOR_TAG][scope];
+  }
+  async loadAPI(...args) {
+    return this.loader.loadAPI(...args);
+  }
+  dispose() {
+    super.dispose();
+  }
+  onDataUpdate() {
+  }
+  removeOnDataUpdate() {
+  }
+}
+export {
+  BriefDataLoader
+};

package/dist/utils/data/index.js

@@ -1,19 +1,23 @@
+import { Constants } from "@rsdoctor/types";
 import { useEffect, useState } from "react";
 import { LocalServerDataLoader } from "./local";
 import { RemoteDataLoader } from "./remote";
 import { getAPILoaderModeFromStorage } from "../storage";
 import { APILoaderMode4Dev } from "../../constants";
+import { BriefDataLoader } from "./brief";
 const loaderTask = /* @__PURE__ */ new WeakMap();
 async function createDataLoader(manifest) {
   try {
     if (process.env.NODE_ENV === "development") {
       const mode = getAPILoaderModeFromStorage();
+      console.log(`[development]-${mode}`);
       if (mode === APILoaderMode4Dev.Local)
         return new LocalServerDataLoader(manifest);
       if (mode === APILoaderMode4Dev.Remote)
         return new RemoteDataLoader(manifest);
     }
     if (manifest.__LOCAL__SERVER__) {
+      console.log(`[LocalServerDataLoader]`);
       return new LocalServerDataLoader(manifest);
     }
   } catch (error) {
@@ -23,6 +27,13 @@ async function createDataLoader(manifest) {
 }
 function useDataLoader(manifest) {
   const [loader, setLoader] = useState(void 0);
+  useEffect(() => {
+    if (window[Constants.WINDOW_RSDOCTOR_TAG]) {
+      console.log("[brief mode]");
+      const loader2 = new BriefDataLoader({ data: [] });
+      setLoader(loader2);
+    }
+  }, []);
   useEffect(() => {
     if (!manifest)
       return;

package/dist/utils/file.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Common } from '@rsdoctor/types';
 import { UploadFile } from 'antd';
 import { FieldDataNode } from 'rc-tree';

package/dist/utils/hooks.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Manifest, Rule, SDK } from '@rsdoctor/types';
 import { useTranslation } from 'react-i18next';
 import './i18n';

package/dist/utils/manifest.d.ts

@@ -5,7 +5,7 @@ export declare function useManifestJson(): Manifest.RsdoctorManifest;
 export declare function useLocale(): import("../constants").Language;
 export declare function useTheme(): {
     theme: Theme;
-    setTheme: (theme: Theme) => void;
+    setTheme: (theme: import("../config").Config["theme"]) => void;
     isDark: boolean;
     isLight: boolean;
 };
@@ -14,10 +14,7 @@ export declare function useViewMode(): {
         bundleAlerts: ViewMode;
         compileAlerts: ViewMode;
     };
-    setViewMode: (mode: Partial<{
-        bundleAlerts: ViewMode;
-        compileAlerts: ViewMode;
-    }>, saveStorage?: boolean | undefined) => void;
+    setViewMode: (mode: Partial<import("../config").Config["viewMode"]>, saveStorage?: boolean) => void;
     setCompileAlertsViewMode(mode: ViewMode): void;
     setBundleAlertsViewMode(mode: ViewMode): void;
     isCompileList: boolean;