@rsdoctor/components 0.3.11 → 0.3.12-alpha.0

package/dist/components/Alert/package-relation.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SDK } from '@rsdoctor/types';
+import { Rule, SDK } from '@rsdoctor/types';
 import { PackageRelationAlertProps } from './types';
 export declare const PackageRelationReasons: React.FC<{
     data: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetPackageRelationAlertDetails>;
@@ -10,7 +10,7 @@ export declare const PackageRelationReasonsWithServer: React.FC<Omit<{
     cwd: string;
 }, "data"> & Partial<{
     body: {
-        id: string | number;
+        id: Rule.RuleStoreDataItem["id"];
         target: SDK.PackageBasicData;
     };
 }>>;

package/dist/components/Alerts/overlay.d.ts

@@ -20,7 +20,7 @@ export declare const OverlayAlertsWithButton: React.FC<Omit<{
 }>>;
 export declare const OverlayAlertsWithTips: React.FC<Omit<{
     alerts: SDK.ServerAPI.InferResponseType<SDK.ServerAPI.API.GetOverlayAlerts>;
-    defaultOpen?: boolean | undefined;
+    defaultOpen?: boolean;
 }, "alerts"> & Partial<{
     body?: any;
 }>>;

package/dist/components/BundleDiff/DiffContainer/packages.d.ts

@@ -10,8 +10,8 @@ export declare const getPackagesTableDataSource: ({ baseline, current, }: {
 }) => {
     updateType: UpdateType;
     name: string;
-    baseline?: SDK.PackageData[] | undefined;
-    current?: SDK.PackageData[] | undefined;
+    baseline?: SDK.PackageData[];
+    current?: SDK.PackageData[];
 }[];
 export declare const Packages: React.FC<{
     baseline: SDK.PackageGraphData;

package/dist/components/BundleDiff/DiffContainer/row.d.ts

@@ -2,8 +2,8 @@ import { ColumnGroupType, ColumnType } from 'antd/es/table/interface';
 import React from 'react';
 import { BundleDiffComponentCardProps, BundleDiffTableAssetsData, BundleDiffTableModulesData } from './types';
 export declare const ModuleHashPattern: RegExp;
-export declare const getSizeColumnPropsForModuleRow: (key: 'baseline' | 'current', sizeKey: 'parsedSize' | 'sourceSize') => ColumnType<BundleDiffTableModulesData>;
-export declare const getTargetColumnPropsForModuleRow: (key: 'baseline' | 'current', bMoudlesCount: number, cMoudlesCount: number) => ColumnGroupType<BundleDiffTableModulesData>;
+export declare const getSizeColumnPropsForModuleRow: (key: "baseline" | "current", sizeKey: "parsedSize" | "sourceSize") => ColumnType<BundleDiffTableModulesData>;
+export declare const getTargetColumnPropsForModuleRow: (key: "baseline" | "current", bMoudlesCount: number, cMoudlesCount: number) => ColumnGroupType<BundleDiffTableModulesData>;
 export declare const ModuleRowForAsset: React.FC<{
     data: BundleDiffTableAssetsData;
 } & Pick<BundleDiffComponentCardProps, 'baseline' | 'current'>>;

package/dist/components/BundleDiff/DiffContainer/types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Client, Manifest, SDK } from '@rsdoctor/types';
 import { UpdateType } from './constants';
 import { InferServerAPIBody } from '../../Manifest';

package/dist/components/BundleDiff/DiffServerAPIProvider/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { SDK } from '@rsdoctor/types';
 import { BundleDiffServerAPIProviderComponentCommonProps } from '../DiffContainer/types';
 export declare const DiffServerAPIProvider: <T extends SDK.ServerAPI.API | SDK.ServerAPI.APIExtends>(props: BundleDiffServerAPIProviderComponentCommonProps<T>) => JSX.Element;

package/dist/components/Charts/TimelineCharts/index.js

@@ -1,7 +1,14 @@
 import { jsx } from "react/jsx-runtime";
 import { useState, useEffect, memo } from "react";
-import ReactECharts from "echarts-for-react";
+import ReactEChartsCore from "echarts-for-react/lib/core";
 import * as echarts from "echarts/core";
+import { CustomChart } from "echarts/charts";
+import {
+  TooltipComponent,
+  GridComponent,
+  DataZoomComponent
+} from "echarts/components";
+import { CanvasRenderer } from "echarts/renderers";
 import dayjs from "dayjs";
 import { groupBy } from "lodash-es";
 import { LITTLE_PALETTE_COLORS, PALETTE_COLORS } from "../constants";
@@ -10,6 +17,13 @@ const TimelineCom = memo(({ loaderData, pluginsData, formatterFn, chartType = "n
   const data = [];
   let categories = [];
   const [optionsData, setOptinsData] = useState({});
+  echarts.use([
+    CustomChart,
+    TooltipComponent,
+    GridComponent,
+    DataZoomComponent,
+    CanvasRenderer
+  ]);
   useEffect(() => {
     if (!loaderData)
       return;
@@ -199,7 +213,7 @@ const TimelineCom = memo(({ loaderData, pluginsData, formatterFn, chartType = "n
     setOptinsData(option);
   }, [loaderData, pluginsData]);
   return /* @__PURE__ */ jsx(
-    ReactECharts,
+    ReactEChartsCore,
     {
       option: optionsData,
       echarts,

package/dist/components/CodeViewer/hightlight.js

@@ -3,9 +3,19 @@ import { useRef } from "react";
 import { Space, Card, Tooltip } from "antd";
 import { InfoCircleOutlined } from "@ant-design/icons";
 import Editor from "@monaco-editor/react";
-import { getOriginalLanguage, beautifyModulePath, getSelectionRange, getRevealPositionForViewer } from "../../utils";
+import {
+  getOriginalLanguage,
+  beautifyModulePath,
+  getSelectionRange,
+  getRevealPositionForViewer
+} from "../../utils";
 import { CodeOpener } from "../Opener";
-const FileHightLightViewer = ({ dependency, module, cwd, moduleCode }) => {
+const FileHightLightViewer = ({
+  dependency,
+  module,
+  cwd,
+  moduleCode
+}) => {
   const editorRef = useRef(null);
   if (!dependency)
     return null;
@@ -14,12 +24,18 @@ const FileHightLightViewer = ({ dependency, module, cwd, moduleCode }) => {
   const { start, end } = statements?.[0]?.position ? hasSourceRange ? statements[0].position.source : statements[0].position.transformed : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } };
   const content = hasSourceRange ? moduleCode?.source : moduleCode?.transformed || moduleCode?.source;
   const modulePath = module.path;
-  const handleEditorDidMount = (editor2, monaco) => {
-    editorRef.current = editor2;
-    const range = getSelectionRange({ start, end }, monaco.Range);
-    const position = getRevealPositionForViewer(range.startLineNumber, range.startColumn);
-    editor2.revealPositionInCenter(position);
-    editor2.deltaDecorations(
+  const handleEditorDidMount = (editor, monaco) => {
+    editorRef.current = editor;
+    const range = getSelectionRange(
+      { start, end },
+      monaco.Range
+    );
+    const position = getRevealPositionForViewer(
+      range.startLineNumber,
+      range.startColumn
+    );
+    editor.revealPositionInCenter(position);
+    editor.deltaDecorations(
       [],
       [
         {

package/dist/components/Layout/menus.d.ts

@@ -1,7 +1,7 @@
 import { Manifest } from '@rsdoctor/types';
 import React from 'react';
 export declare const Menus: React.FC<Omit<{
-    style?: React.CSSProperties | undefined;
+    style?: React.CSSProperties;
     routes: Manifest.RsdoctorManifestClientRoutes[];
 }, "routes"> & Partial<{
     body?: any;

package/dist/config.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { Manifest } from '@rsdoctor/types';
 import { PageState, ViewMode, Language, Theme } from './constants';
 export interface Config {

package/dist/pages/BundleSize/config.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface config {
     setModuleJumpList(ids: number[]): void;
     moduleJumpList: number[];

package/dist/pages/TreeShaking/editor.js

@@ -4,7 +4,7 @@ import path from "path-browserify";
 import { Card, Space, Tooltip, Typography } from "antd";
 import { InfoCircleOutlined, LoadingOutlined } from "@ant-design/icons";
 import Editor from "@monaco-editor/react";
-import { Range, editor } from "monaco-editor";
+import { Range } from "./range";
 import { parseOpenTag } from "./open-tag";
 import { getHoverMessageInModule } from "./utils";
 import { getOriginalLanguage, getSelectionRange } from "../../utils";
@@ -40,7 +40,10 @@ function CodeEditor(props) {
         oldRanges.current,
         ranges.map((arr) => {
           return {
-            range: getSelectionRange(arr, Range),
+            range: getSelectionRange(
+              arr,
+              Range
+            ),
             options: {
               stickiness: 1,
               inlineClassName: "tree-shaking-statement-side-effect",
@@ -52,7 +55,7 @@ function CodeEditor(props) {
       );
       if (editorRef.current && typeof toLine === "number" && oldToLine.current !== toLine) {
         oldToLine.current = toLine;
-        editorRef.current.revealLine(toLine, editor.ScrollType.Smooth);
+        editorRef.current.revealLine(toLine, 0);
       }
     }
     if (changeModule) {
@@ -80,8 +83,8 @@ function CodeEditor(props) {
   if (!module) {
     return /* @__PURE__ */ jsx("div", { children: "请选择要查看的模块" });
   }
-  const handleEditorDidMount = (editor2) => {
-    editorRef.current = editor2;
+  const handleEditorDidMount = (editor) => {
+    editorRef.current = editor;
   };
   return /* @__PURE__ */ jsx(
     Card,

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

@@ -0,0 +1,282 @@
+/**
+ * The following is modified based on source found in
+ * https://github.com/microsoft/monaco-editor
+ *
+ * MIT Licensed
+ * Copyright (c) 2016 - present Microsoft Corporation
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ */
+export declare class Range {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+    constructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number);
+    /**
+     * Test if this range is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Test if `range` is empty.
+     */
+    static isEmpty(range: Range): boolean;
+    /**
+     * Test if position is in this range. If the position is at the edges, will return true.
+     */
+    containsPosition(position: any): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return true.
+     */
+    static containsPosition(range: Range, position: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if `position` is in `range`. If the position is at the edges, will return false.
+     * @internal
+     */
+    static strictContainsPosition(range: Range, position: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if range is in this range. If the range is equal to this range, will return true.
+     */
+    containsRange(range: Range): boolean;
+    /**
+     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
+     */
+    static containsRange(range: Range, otherRange: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    }): boolean;
+    /**
+     * 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: Range): boolean;
+    /**
+     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.
+     */
+    static strictContainsRange(range: Range, otherRange: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    }): boolean;
+    /**
+     * 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: Range): 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: Range, b: Range): Range;
+    /**
+     * A intersection of the two ranges.
+     */
+    intersectRanges(range: Range): Range | null;
+    /**
+     * A intersection of the two ranges.
+     */
+    static intersectRanges(a: Range, b: Range): Range | null;
+    /**
+     * Test if this range equals other.
+     */
+    equalsRange(other: Range): boolean;
+    /**
+     * Test if range `a` equals `b`.
+     */
+    static equalsRange(a: Range, b: Range): boolean;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    getEndPosition(): Position;
+    /**
+     * Return the end position (which will be after or equal to the start position)
+     */
+    static getEndPosition(range: Range): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    getStartPosition(): Position;
+    /**
+     * Return the start position (which will be before or equal to the end position)
+     */
+    static getStartPosition(range: Range): Position;
+    /**
+     * Transform to a user presentable string representation.
+     */
+    toString(): string;
+    /**
+     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
+     */
+    setEndPosition(endLineNumber: number, endColumn: number): Range;
+    /**
+     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
+     */
+    setStartPosition(startLineNumber: number, startColumn: number): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    collapseToStart(): Range;
+    /**
+     * Create a new empty range using this range's start position.
+     */
+    static collapseToStart(range: Range): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    collapseToEnd(): Range;
+    /**
+     * Create a new empty range using this range's end position.
+     */
+    static collapseToEnd(range: Range): Range;
+    /**
+     * Moves the range by the given amount of lines.
+     */
+    delta(lineCount: number): Range;
+    static fromPositions(start: {
+        lineNumber: number;
+        column: number;
+    }, end?: {
+        lineNumber: number;
+        column: number;
+    }): Range;
+    static lift(range: Range): Range | null;
+    /**
+     * Test if `obj` is an `IRange`.
+     */
+    static isIRange(obj: Range): boolean;
+    /**
+     * Test if the two ranges are touching in any way.
+     */
+    static areIntersectingOrTouching(a: Range, b: Range): boolean;
+    /**
+     * Test if the two ranges are intersecting. If the ranges are touching it returns true.
+     */
+    static areIntersecting(a: Range, b: Range): boolean;
+    /**
+     * 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: Range, b: Range): number;
+    /**
+     * 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: {
+        endLineNumber: number;
+        endColumn: number;
+        startLineNumber: number;
+        startColumn: number;
+    }, b: {
+        endLineNumber: number;
+        endColumn: number;
+        startLineNumber: number;
+        startColumn: number;
+    }): number;
+    /**
+     * Test if the range spans multiple lines.
+     */
+    static spansMultipleLines(range: Range): boolean;
+    toJSON(): this;
+}
+/**
+ * A position in the editor.
+ */
+export declare class Position {
+    lineNumber: number;
+    column: number;
+    constructor(lineNumber: number, column: number);
+    /**
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
+     */
+    with(newLineNumber?: number, newColumn?: number): Position;
+    /**
+     * Derive a new position from this position.
+     *
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
+     */
+    delta(deltaLineNumber?: number, deltaColumn?: number): Position;
+    /**
+     * Test if this position equals other position
+     */
+    equals(other: any): boolean;
+    /**
+     * Test if position `a` equals position `b`
+     */
+    static equals(a: any, b: {
+        lineNumber: any;
+        column: any;
+    }): boolean;
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
+     */
+    isBefore(other: any): boolean;
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
+     */
+    static isBefore(a: any, b: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
+     */
+    isBeforeOrEqual(other: any): boolean;
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
+     */
+    static isBeforeOrEqual(a: any, b: {
+        lineNumber: number;
+        column: number;
+    }): boolean;
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a: {
+        lineNumber: number;
+        column: number;
+    }, b: {
+        lineNumber: number;
+        column: number;
+    }): number;
+    /**
+     * Clone this position.
+     */
+    clone(): Position;
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString(): string;
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos: {
+        lineNumber: any;
+        column: any;
+    }): Position;
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj: {
+        lineNumber: any;
+        column: any;
+    }): boolean;
+    toJSON(): {
+        lineNumber: number;
+        column: number;
+    };
+}

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/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;

package/dist/utils/monaco.js

@@ -39,7 +39,12 @@ function getRevealPositionForViewer(startLineNumber, startColumn) {
 function getSelectionRange(source, Range) {
   const { start, end } = source;
   const { line = 1, column = 0 } = start;
-  return new Range(line, column + 1, end?.line ?? line, (end?.column ?? 9999) + 1);
+  return new Range(
+    line,
+    column + 1,
+    end?.line ?? line,
+    (end?.column ?? 9999) + 1
+  );
 }
 const initMonaco = (monacoRef) => {
   return new Promise((resolve, reject) => {

package/dist/utils/request.d.ts

@@ -2,9 +2,9 @@ import { Manifest, SDK } from '@rsdoctor/types';
 export declare function fetchShardingFile(url: string): Promise<string>;
 export declare function loadManifestByUrl(url: string): Promise<{
     data: Manifest.RsdoctorManifestData;
-    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string | string[]> | undefined;
-    __LOCAL__SERVER__?: boolean | undefined;
-    __SOCKET__URL__?: string | undefined;
+    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string[] | string>;
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__URL__?: string;
     client: Manifest.RsdoctorManifestClient;
     cloudManifestUrl?: string | undefined;
     name?: string | undefined;
@@ -14,9 +14,9 @@ export declare function fetchJSONByUrl(url: string): Promise<Manifest.RsdoctorMa
 export declare function fetchJSONByUrls(urls: string[]): Promise<Manifest.RsdoctorManifestWithShardingFiles[]>;
 export declare function parseManifest(json: Manifest.RsdoctorManifestWithShardingFiles): Promise<{
     data: Manifest.RsdoctorManifestData;
-    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string | string[]> | undefined;
-    __LOCAL__SERVER__?: boolean | undefined;
-    __SOCKET__URL__?: string | undefined;
+    cloudData?: Record<keyof Manifest.RsdoctorManifestData, string[] | string>;
+    __LOCAL__SERVER__?: boolean;
+    __SOCKET__URL__?: string;
     client: Manifest.RsdoctorManifestClient;
     cloudManifestUrl?: string | undefined;
     name?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/components",
-  "version": "0.3.11",
+  "version": "0.3.12-alpha.0",
   "main": "./dist/index.js",
   "license": "MIT",
   "module": "dist/index.js",
@@ -44,7 +44,7 @@
     "dist/"
   ],
   "devDependencies": {
-    "@ant-design/icons": "4.8.3",
+    "@ant-design/icons": "5.3.5",
     "@monaco-editor/react": "4.6.0",
     "@types/lodash-es": "4.17.12",
     "@types/node": "^16",
@@ -75,9 +75,9 @@
     "terser": "^5.31.3",
     "typescript": "^5.2.2",
     "url-parse": "1.5.10",
-    "@rsdoctor/graph": "0.3.11",
-    "@rsdoctor/types": "0.3.11",
-    "@rsdoctor/utils": "0.3.11"
+    "@rsdoctor/graph": "0.3.12-alpha.0",
+    "@rsdoctor/types": "0.3.12-alpha.0",
+    "@rsdoctor/utils": "0.3.12-alpha.0"
   },
   "publishConfig": {
     "access": "public",