@rsdoctor/types 0.0.2-beta.0

package/dist/rule/code/E1004.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.message = exports.code = void 0;
+exports.code = 'E1004';
+exports.message = {
+    code: exports.code,
+    title: 'ECMA Version Check',
+    type: 'markdown',
+    category: 'bundle',
+    description: `
+#### Description
+
+Detect if there is a low version of ECMA syntax in the js bundle file
+`,
+};

package/dist/rule/code/index.d.ts

@@ -0,0 +1,23 @@
+import { RuleMessage } from './type';
+import * as E1001 from './E1001';
+import * as E1002 from './E1002';
+import * as E1003 from './E1003';
+import * as E1004 from './E1004';
+export type RuleErrorCodes = {
+    [E1001.code]: typeof E1001;
+    [E1002.code]: typeof E1002;
+    [E1003.code]: typeof E1003;
+    [E1004.code]: typeof E1004;
+};
+/**
+ * The format is E + "4 digits".
+ * - The first number represents the category:
+ * - 1 for Webpack build related indexes
+ * - ...
+ * - The rest of the numbers can be increased by adding zeros
+ */
+export declare const RuleErrorMap: Record<keyof RuleErrorCodes, RuleMessage>;
+export declare enum DoctorRuleClientConstant {
+    UrlQueryForErrorCode = "code"
+}
+export * from './type';

package/dist/rule/code/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctorRuleClientConstant = exports.RuleErrorMap = void 0;
+const E1001 = __importStar(require("./E1001"));
+const E1002 = __importStar(require("./E1002"));
+const E1003 = __importStar(require("./E1003"));
+const E1004 = __importStar(require("./E1004"));
+/**
+ * The format is E + "4 digits".
+ * - The first number represents the category:
+ * - 1 for Webpack build related indexes
+ * - ...
+ * - The rest of the numbers can be increased by adding zeros
+ */
+exports.RuleErrorMap = {
+    [E1001.code]: E1001.message,
+    [E1002.code]: E1002.message,
+    [E1003.code]: E1003.message,
+    [E1004.code]: E1004.message,
+};
+var DoctorRuleClientConstant;
+(function (DoctorRuleClientConstant) {
+    DoctorRuleClientConstant["UrlQueryForErrorCode"] = "code";
+})(DoctorRuleClientConstant || (exports.DoctorRuleClientConstant = DoctorRuleClientConstant = {}));
+__exportStar(require("./type"), exports);

package/dist/rule/code/type.d.ts

@@ -0,0 +1,27 @@
+import { RuleErrorCodes } from '.';
+/**
+ * only defined the code which can be enumerated
+ */
+export declare enum RuleMessageCodeEnumerated {
+    /**
+     * others tools / frameworks errors, such as PIA
+     */
+    Extend = "EXTEND",
+    /**
+     * errors show in the overlay at the client, such as Webpack compile errors in development
+     */
+    Overlay = "OVERLAY"
+}
+export type RuleMessageCode = keyof RuleErrorCodes | `${RuleMessageCodeEnumerated}` | RuleMessageCodeEnumerated;
+export declare enum RuleMessageCategory {
+    Compile = "compile",
+    Bundle = "bundle",
+    EMO = "emo"
+}
+export interface RuleMessage {
+    code: RuleMessageCode;
+    title: string;
+    type: 'text' | 'markdown';
+    category: `${RuleMessageCategory}` | RuleMessageCategory;
+    description: string;
+}

package/dist/rule/code/type.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleMessageCategory = exports.RuleMessageCodeEnumerated = void 0;
+/**
+ * only defined the code which can be enumerated
+ */
+var RuleMessageCodeEnumerated;
+(function (RuleMessageCodeEnumerated) {
+    /**
+     * others tools / frameworks errors, such as PIA
+     */
+    RuleMessageCodeEnumerated["Extend"] = "EXTEND";
+    /**
+     * errors show in the overlay at the client, such as Webpack compile errors in development
+     */
+    RuleMessageCodeEnumerated["Overlay"] = "OVERLAY";
+})(RuleMessageCodeEnumerated || (exports.RuleMessageCodeEnumerated = RuleMessageCodeEnumerated = {}));
+var RuleMessageCategory;
+(function (RuleMessageCategory) {
+    RuleMessageCategory["Compile"] = "compile";
+    RuleMessageCategory["Bundle"] = "bundle";
+    RuleMessageCategory["EMO"] = "emo";
+})(RuleMessageCategory || (exports.RuleMessageCategory = RuleMessageCategory = {}));

package/dist/rule/data.d.ts

@@ -0,0 +1,132 @@
+import type { WorkspaceCheckDataType } from '../emo';
+import type { RuleMessage, RuleMessageCodeEnumerated } from './code';
+import type { SourceRange } from '../sdk';
+import type { PackageBasicData } from '../sdk/package';
+export interface BaseRuleStoreData extends Pick<RuleMessage, 'code' | 'category'> {
+    /**
+     * unique of error
+     */
+    id: number | string;
+    /**
+     * title of alerts
+     */
+    title: string;
+    /**
+     * description of alerts
+     */
+    description?: string;
+    /**
+     * level of error
+     */
+    level: 'warn' | 'error';
+    /**
+     * rule doc link
+     */
+    link?: string;
+}
+export interface LinkRuleStoreData extends BaseRuleStoreData {
+    type: 'link';
+}
+export interface DependencyWithPackageData {
+    /**
+     * use to group files, such as different version of duplicate packages.
+     * @example
+     * [
+     *   { group: "lodash@1.0.1", ... },
+     *   { group: "lodash@1.0.1", ... },
+     *   { group: "lodash@2.0.0", ... },
+     * ]
+     */
+    group?: string;
+    /**
+     * module dependency id
+     */
+    dependencyId: number;
+}
+export interface PackageRelationData {
+    /** Target package data */
+    target: PackageBasicData;
+    /** Target package size */
+    targetSize: {
+        sourceSize: number;
+        parsedSize: number;
+    };
+    /** package dependency chain */
+    dependencies: DependencyWithPackageData[];
+}
+/**
+ * Generally serves to view package relationship detection rules.
+ */
+export interface PackageRelationDiffRuleStoreData extends BaseRuleStoreData {
+    type: 'package-relation';
+    packages: PackageRelationData[];
+}
+/**
+ * General service to view file relationship detection rules.
+ */
+export interface FileRelationRuleStoreData extends BaseRuleStoreData {
+    type: 'file-relation';
+    /** Target file */
+    target: string;
+    /** Dependency chain */
+    dependencies: number[];
+}
+/**
+ * the rule which code view only
+ */
+export interface CodeViewRuleStoreData extends BaseRuleStoreData {
+    type: 'code-view';
+    file: {
+        /**
+         * file path
+         */
+        path: string;
+        /**
+         * the code content
+         */
+        content: string;
+        /**
+         * fix highlight range in source
+         */
+        ranges?: SourceRange[];
+    };
+}
+/**
+ * the rule which need to change the file code.
+ */
+export interface CodeChangeRuleStoreData extends BaseRuleStoreData {
+    type: 'code-change';
+    file: {
+        /**
+         * file path
+         */
+        path: string;
+        /**
+         * the actual file content
+         */
+        actual: string;
+        /**
+         * the expected file content
+         */
+        expected: string;
+        /**
+         * fix code line in source
+         */
+        line?: number;
+        /**
+         * whether this case is fixed
+         *   - @default `false`
+         */
+        isFixed?: boolean;
+    };
+}
+export interface EMORuleStoreData extends BaseRuleStoreData {
+    type: 'emo';
+    emoCheckData: WorkspaceCheckDataType;
+}
+export interface OverlayRuleStoreData extends BaseRuleStoreData {
+    code: RuleMessageCodeEnumerated.Overlay;
+    stack?: string;
+}
+export type RuleStoreDataItem = LinkRuleStoreData | FileRelationRuleStoreData | CodeChangeRuleStoreData | PackageRelationDiffRuleStoreData | CodeViewRuleStoreData | EMORuleStoreData;
+export type RuleStoreData = RuleStoreDataItem[];

package/dist/rule/data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/rule/index.d.ts

@@ -0,0 +1,2 @@
+export * from './code';
+export * from './data';

package/dist/rule/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./code"), exports);
+__exportStar(require("./data"), exports);

package/dist/sdk/chunk.d.ts

@@ -0,0 +1,125 @@
+import type { NonFunctionProperties } from '../common';
+import type { ModuleInstance, ToDataType } from './module';
+export interface AssetInstance {
+    path: string;
+    size: number;
+    /** File belongs to Chunk */
+    chunks: ChunkInstance[];
+    /** File resource content */
+    content: string;
+    /** Generate data */
+    toData(type: ToDataType): AssetData;
+}
+export interface ChunkInstance {
+    /** Chunk Identifier */
+    id: string;
+    /** Chunk Name */
+    name: string;
+    /** Whether to load on the homepage */
+    initial: boolean;
+    size: number;
+    /** Is it an entrance */
+    entry: boolean;
+    /** Is it the entrance Chunk */
+    isEntry(): boolean;
+    /** Is the module a Chunk entrance */
+    isChunkEntryModule(module: ModuleInstance): boolean;
+    /** Does it contain modules */
+    hasModule(module: ModuleInstance): boolean;
+    /** Connection module */
+    addModule(module: ModuleInstance): void;
+    addAsset(asset: AssetInstance): void;
+    /** Add Dependency Chunk */
+    addDependency(dep: ChunkInstance): void;
+    /** Add Dependent Chunk */
+    addImported(imported: ChunkInstance): void;
+    /** Includes products */
+    getAssets(): AssetInstance[];
+    /** Contains original modules */
+    getModules(): ModuleInstance[];
+    /** Depends on Chunk */
+    getDependencies(): ChunkInstance[];
+    /** Add Dependent Chunk  */
+    getImported(): ChunkInstance[];
+    /** add parsed chunk size */
+    setParsedSize(size: number): void;
+    /** Generate data */
+    toData(): ChunkData;
+}
+export interface ChunkGraphInstance {
+    /** Obtain product data */
+    getAssets(): AssetInstance[];
+    /** Get Chunk Data */
+    getChunks(): ChunkInstance[];
+    /** Add product data */
+    addAsset(...assets: AssetInstance[]): void;
+    /** Add Chunk Data */
+    addChunk(...chunks: ChunkInstance[]): void;
+    /** Get chunk by identifier */
+    getChunkById(id: string): ChunkInstance | undefined;
+    /** Get Chunk by Module */
+    getChunkByModule(module: ModuleInstance): ChunkInstance | undefined;
+    /** Get the file according to the path */
+    getAssetByPath(path: string): AssetInstance | undefined;
+    /** Get files based on Chunk */
+    getAssetsByChunk(chunk: ChunkInstance): AssetInstance[] | undefined;
+    /**
+     * get the list of entry points
+     */
+    getEntryPoints(): EntryPointInstance[];
+    /**
+     * add the entry point instance to chunk graph
+     */
+    addEntryPoint(...entrypoint: EntryPointInstance[]): void;
+    /** Output pure data */
+    toData(type: ToDataType): ChunkGraphData;
+}
+export interface AssetData extends Omit<NonFunctionProperties<AssetInstance>, 'chunks'> {
+    /** Chunk Identifier to which the file belongs */
+    chunks: string[];
+}
+export interface ChunkGraphData extends NonFunctionProperties<ChunkGraphInstance> {
+    assets: AssetData[];
+    chunks: ChunkData[];
+    entrypoints: EntryPointData[];
+}
+export interface ChunkData extends Omit<NonFunctionProperties<ChunkInstance>, 'assets' | 'modules' | 'dependencies' | 'imported'> {
+    /** Is it the entrance Chunk */
+    entry: boolean;
+    /** Contains product path */
+    assets: string[];
+    /** contains the original module identifier */
+    modules: number[];
+    /** Depends on Chunk Identifier */
+    dependencies: string[];
+    /** Dependent Chunk Identifier */
+    imported: string[];
+    /** chunk parsed size */
+    parsedSize: number;
+}
+export interface EntryPointInstance {
+    name: string;
+    /**
+     * add asset which contained in this entry point
+     */
+    addAsset(asset: AssetInstance): void;
+    /**
+     * add chunk which contained in this entry point
+     */
+    addChunk(chunk: ChunkInstance): void;
+    toData(): EntryPointData;
+}
+export interface EntryPointData extends NonFunctionProperties<EntryPointInstance> {
+    /**
+     * id list for chunks which contained in this entry point.
+     */
+    chunks: ChunkData['id'][];
+    /**
+     * path list for assets which contained in this entry point.
+     */
+    assets: AssetData['path'][];
+    /**
+     * total size of assets
+     */
+    size: number;
+}

package/dist/sdk/chunk.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/config.d.ts

@@ -0,0 +1,8 @@
+import type { Configuration } from 'webpack';
+export interface WebpackConfigData {
+    name: 'webpack';
+    version: string | number;
+    bin?: string;
+    config: Configuration;
+}
+export type ConfigData = WebpackConfigData[];

package/dist/sdk/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/context.d.ts

@@ -0,0 +1,23 @@
+import type { ChunkGraphInstance } from './chunk';
+import type { ModuleGraphInstance } from './module';
+import type { PackageGraphInstance, OtherReports } from './package';
+import { ConfigData } from './config';
+import { LoaderData } from './loader';
+export interface RuntimeContext {
+    /** Project root directory */
+    root: string;
+    /** Project configuration */
+    configs: ConfigData;
+    /** build error */
+    errors: Error[];
+    /** Chunk chart */
+    chunkGraph: ChunkGraphInstance;
+    /** Module diagram */
+    moduleGraph: ModuleGraphInstance;
+    /** Dependency graph */
+    packageGraph: PackageGraphInstance;
+    loader: LoaderData;
+    otherReports?: OtherReports | undefined;
+}
+export interface RuntimeContextOptions {
+}

package/dist/sdk/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/envinfo.d.ts

@@ -0,0 +1,19 @@
+export interface EnvInfo {
+    /**
+     * @example "macOS 11.4"
+     */
+    os: string;
+    /**
+     * @example "(12) x64 Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz"
+     */
+    cpu: string;
+    /**
+     * @example "1.07 GB / 32.00 GB"
+     */
+    memory: string;
+    nodeVersion: string;
+    yarnVersion: string;
+    npmVersion: string;
+    pnpmVersion: string;
+    [key: string]: string;
+}

package/dist/sdk/envinfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/hooks.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncSeriesHook } from 'tapable';
+import { DoctorManifestWithShardingFiles } from '../manifest';
+/**
+ * sdk hooks map
+ */
+export interface Hooks {
+    afterSaveManifest: AsyncSeriesHook<[
+        {
+            manifestWithShardingFiles: DoctorManifestWithShardingFiles;
+            manifestDiskPath: string;
+        }
+    ]>;
+}

package/dist/sdk/hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/index.d.ts

@@ -0,0 +1,16 @@
+export * from './loader';
+export * from './resolver';
+export * from './plugin';
+export * from './module';
+export * from './chunk';
+export * from './result';
+export * from './summary';
+export * from './package';
+export * from './context';
+export * from './config';
+export * from './server';
+export * from './statement';
+export * from './treeShaking';
+export * from './envinfo';
+export * from './instance';
+export * from './hooks';

package/dist/sdk/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./loader"), exports);
+__exportStar(require("./resolver"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./chunk"), exports);
+__exportStar(require("./result"), exports);
+__exportStar(require("./summary"), exports);
+__exportStar(require("./package"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./statement"), exports);
+__exportStar(require("./treeShaking"), exports);
+__exportStar(require("./envinfo"), exports);
+__exportStar(require("./instance"), exports);
+__exportStar(require("./hooks"), exports);