@modern-js/module-tools 1.5.8 → 1.6.1

package/dist/types/features/build/bundleless/runBabel.d.ts

@@ -0,0 +1,32 @@
+import type { PluginAPI } from '@modern-js/core';
+import type { BabelOptions, ICompilerResult, BuildWatchEmitter, ICompilerMessageDetail } from '@modern-js/babel-compiler';
+import type { NormalizedBundlelessBuildConfig } from '../types';
+import type { ITsconfig } from '../../../types';
+export declare class BabelBuildError extends Error {
+  readonly summary?: string;
+  readonly details?: ICompilerMessageDetail[];
+  constructor(message: string, opts?: {
+    summary?: string;
+    details?: ICompilerMessageDetail[];
+  });
+  toString(): string;
+  formatError(): string[];
+}
+interface IBuildSourceCodeConfig {
+  appDirectory: string;
+  watch?: boolean;
+  babelConfig: BabelOptions;
+  srcRootDir: string;
+  willCompilerDirOrFile: string;
+  distDir: string;
+  tsconfigPath: string;
+}
+export declare const getWillCompilerCode: (srcDirOrFile: string, option: {
+  tsconfig: ITsconfig | null;
+  isTsProject: boolean;
+}) => string[];
+export declare const buildSourceCode: (config: IBuildSourceCodeConfig) => Promise<ICompilerResult | BuildWatchEmitter>;
+export declare const jsFileSuffix: string[];
+export declare const haveNotAnyJsFile: (sourceDir: string) => Promise<boolean>;
+export declare const runBabelBuild: (api: PluginAPI, config: NormalizedBundlelessBuildConfig) => Promise<void>;
+export {};

package/dist/types/features/build/bundleless/style.d.ts

@@ -0,0 +1,25 @@
+import type { PluginAPI } from '@modern-js/core';
+import type { BuildWatchEmitter, ICompilerResult, SingleFileCompilerResult, LessOption, PostcssOption, SassOptions } from '@modern-js/style-compiler';
+import type { NormalizedBundlelessBuildConfig } from '../types';
+export declare class StyleBuildError extends Error {
+  readonly summary?: string;
+  readonly details?: SingleFileCompilerResult[];
+  constructor(message: string, opts?: {
+    summary?: string;
+    details?: SingleFileCompilerResult[];
+  });
+  toString(): string;
+  formatError(): string[];
+}
+export declare const runBuild: (option: {
+  appDirectory: string;
+  srcDir: string;
+  outDir: string;
+  watch: boolean;
+  lessOption: LessOption | undefined;
+  sassOption: SassOptions<'sync'> | undefined;
+  postcssOption: PostcssOption;
+}) => Promise<BuildWatchEmitter | ICompilerResult | undefined>;
+export declare const styleFileSuffix: string[];
+export declare const haveNotAnyStyles: (sourceDir: string) => Promise<boolean>;
+export declare const buildStyle: (api: PluginAPI, config: NormalizedBundlelessBuildConfig) => Promise<void>;

package/dist/types/features/build/constants.d.ts

@@ -1,14 +1,18 @@
-import type { IPackageModeValue } from '../../types';
-export declare const DEFAULT_PACKAGE_MODE = "universal-js";
-export declare const PACKAGE_MODES: {
-  'universal-js': IPackageModeValue[];
-  'universal-js-lite': IPackageModeValue[];
-  'browser-js': IPackageModeValue[];
-  'browser-js-lite': IPackageModeValue[];
-  'node-js': IPackageModeValue[];
+import type { BaseBuildConfig, Target } from '../../schema/types';
+export declare const clearFlag = "\u001Bc";
+export declare const buildingText: string;
+export declare const buildSuccessText: string;
+export declare const buildFailText: string;
+export declare const targets: Target[];
+export declare const npmLibraryPresetConfig: BaseBuildConfig[];
+export declare const npmLibraryWithUmdPresetConfig: BaseBuildConfig[];
+export declare const npmComponentPresetConfig: BaseBuildConfig[];
+export declare const npmComponentWithUmdPresetConfig: BaseBuildConfig[];
+export declare const unPresetConfigs: {
+  'npm-library': BaseBuildConfig[];
+  'npm-library-with-umd': BaseBuildConfig[];
+  'npm-component': BaseBuildConfig[];
+  'npm-component-with-umd': BaseBuildConfig[];
 };
-export declare const runBabelCompilerTitle = "Run babel compiler code log";
-export declare const runTscWatchTitle = "Run `tsc -w` log";
-export declare const runTscTitle = "Run `tsc` log";
-export declare const runStyleCompilerTitle = "Run style compiler code log";
-export declare const clearFlag = "\u001Bc";
+export declare const unPresets: ("npm-library" | "npm-library-with-umd" | "npm-component" | "npm-component-with-umd")[];
+export declare const unPresetWithTargetConfigs: Record<string, BaseBuildConfig[]>;

package/dist/types/features/build/error.d.ts

@@ -0,0 +1,33 @@
+import type { ExecaError } from '@modern-js/utils';
+import type { BuildType, Format, Target } from '../../schema/types';
+export declare const padSpaceWith: (str: string, targetL: number, opts?: {
+  endStr?: string | undefined;
+  style?: ((s: string) => string) | undefined;
+}) => string;
+export declare class InternalBuildError extends Error {
+  buildType: BuildType;
+  target: Target;
+  format: Format;
+  private e;
+  constructor(e: Error, opts: {
+    buildType: BuildType;
+    format: Format;
+    target: Target;
+  });
+  toString(): string;
+  formatError(): string[];
+}
+export declare class InternalDTSError extends Error {
+  buildType: BuildType;
+  private e;
+  constructor(e: Error | ExecaError, opts: {
+    buildType: BuildType;
+  });
+  toString(): string;
+  formatError(): string[];
+}
+export declare class ModuleBuildError extends Error {
+  constructor(e: InternalBuildError | InternalDTSError);
+}
+export declare const isInternalError: (e: unknown) => e is InternalBuildError | InternalDTSError;
+export declare const isExecaError: (e: any) => e is ExecaError<string>;

package/dist/types/features/build/index.d.ts

@@ -1,3 +1,12 @@
-import type { NormalizedConfig, PluginAPI } from '@modern-js/core';
-import type { IBuildConfig } from '../../types';
-export declare const build: (api: PluginAPI, config: IBuildConfig, modernConfig: NormalizedConfig) => Promise<void>;
+import type { PluginAPI } from '@modern-js/core';
+import type { IBuildFeatOption } from '../../types';
+import type { NormalizedBuildConfig } from './types';
+export declare const checkPlatformAndRunBuild: (platform: IBuildFeatOption['platform'], options: {
+  api: PluginAPI;
+  isTsProject: boolean;
+}) => Promise<{
+  exit: boolean;
+}>;
+export declare const runBuild: (api: PluginAPI, normalizedModuleConfig: NormalizedBuildConfig[], config: IBuildFeatOption) => Promise<void>;
+export declare const buildInNormalMode: (api: PluginAPI, normalizedModuleConfig: NormalizedBuildConfig[], config: IBuildFeatOption) => Promise<void>;
+export declare const build: (api: PluginAPI, config: IBuildFeatOption) => Promise<void>;

package/dist/types/features/build/legacy-constants.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_PACKAGE_MODE = "universal-js";
+export declare const PACKAGE_MODES: {
+  'universal-js': import("../../schema/types").BaseBuildConfig[];
+  'universal-js-lite': import("../../schema/types").BaseBuildConfig[];
+  'browser-js': import("../../schema/types").BaseBuildConfig[];
+  'browser-js-lite': import("../../schema/types").BaseBuildConfig[];
+  'node-js': import("../../schema/types").BaseBuildConfig[];
+};

package/dist/types/features/build/normalize.d.ts

@@ -0,0 +1,19 @@
+import type { PluginAPI } from '@modern-js/core';
+import type { BuildConfig, BaseBuildConfig, SourceMap } from '../../schema/types';
+import type { IBuildFeatOption } from '../../types';
+import type { NormalizedBuildConfig } from './types';
+export declare const getNormalizeModuleConfigByPackageModeAndFileds: (api: PluginAPI, buildFeatOption: IBuildFeatOption) => BuildConfig;
+export declare const getFinalTsconfig: (config: {
+  tsconfig?: string;
+}, buildFeatOption: IBuildFeatOption) => string;
+export declare const getFinalDts: (config: Pick<BaseBuildConfig, 'enableDts'>, buildFeatOption: IBuildFeatOption) => boolean;
+export declare const getSourceMap: (config: Pick<BaseBuildConfig, 'sourceMap'>, buildType: BaseBuildConfig['buildType'], api: PluginAPI) => SourceMap;
+export declare const normalizeBuildConfig: (context: {
+  buildFeatOption: IBuildFeatOption;
+  api: PluginAPI;
+}, buildConfig: BuildConfig, deps?: string[]) => NormalizedBuildConfig[];
+export declare const normalizeModuleConfig: (context: {
+  buildFeatOption: IBuildFeatOption;
+  api: PluginAPI;
+  deps?: string[];
+}) => NormalizedBuildConfig[];

package/dist/types/features/build/types.d.ts

@@ -0,0 +1,15 @@
+import type { BaseBuildConfig, BundlelessOptions, BundleOptions } from '../../schema/types';
+export declare type NormalizedBuildConfig = NormalizedBundleBuildConfig | NormalizedBundlelessBuildConfig;
+export declare type CommonNormalizedBuildConfig = Required<Omit<BaseBuildConfig, 'bundleOptions' | 'bundlelessOptions'>> & {
+  watch?: boolean;
+};
+export declare type NormalizedBundleBuildConfig = {
+  buildType: 'bundle';
+} & CommonNormalizedBuildConfig & {
+  bundleOptions: BundleOptions;
+};
+export declare type NormalizedBundlelessBuildConfig = {
+  buildType: 'bundleless';
+} & CommonNormalizedBuildConfig & {
+  bundlelessOptions: Required<BundlelessOptions>;
+};

package/dist/types/features/build/utils.d.ts

@@ -1,29 +1,5 @@
-import type { PluginAPI } from '@modern-js/core';
-import type { IBuildConfig, IPackageModeValue, ITaskMapper } from '../../types';
-import type { LoggerText } from './logger';
-export declare const getCodeInitMapper: (api: PluginAPI, _: IBuildConfig) => IPackageModeValue[];
-export declare const getCodeMapper: (api: PluginAPI, {
-  logger,
-  taskPath,
-  config,
-  initMapper,
-  srcRootDir,
-  willCompilerDirOrFile
-}: ITaskMapper & {
-  config: IBuildConfig;
-  initMapper: IPackageModeValue[];
-  srcRootDir: string;
-  willCompilerDirOrFile: string;
-}) => {
-  logger: LoggerText | null;
-  taskPath: string;
-  params: string[];
-}[];
-export declare const getDtsMapper: (api: PluginAPI, config: IBuildConfig, logger: LoggerText) => {
-  logger: LoggerText;
-  taskPath: string;
-  params: string[];
-}[];
+import type { NormalizedConfig } from '@modern-js/core';
+import type { PostcssOption } from '@modern-js/style-compiler';
 /**
  * 处理日志信息
  */
@@ -52,8 +28,11 @@ export declare const logTemplate: (title: string, messageStack: string[], maxLen
   leftBorder?: string | undefined;
   contentColor?: ((s: string) => string) | undefined;
 }) => string;
-export declare class TimeCounter {
-  static _now: number;
-  static time(): void;
-  static timeEnd(): string;
-}
+export declare enum SectionTitleStatus {
+  Success = 0,
+  Fail = 1,
+  Log = 2,
+}
+export declare const watchSectionTitle: (str: string, status: SectionTitleStatus) => string;
+export declare const getPostcssOption: (appDirectory: string, modernConfig: NormalizedConfig) => PostcssOption;
+export declare const getAllDeps: <T>(appDirectory: string) => string[];

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import type { CliPlugin } from '@modern-js/core';
+export * from './types';
 export { defineConfig } from '@modern-js/core';
 
 declare const _default: () => CliPlugin;

package/dist/types/locale/en.d.ts

@@ -7,7 +7,9 @@ export declare const EN_LOCALE: {
       style_only: string;
       platform: string;
       no_tsc: string;
+      dts: string;
       no_clear: string;
+      config: string;
     };
     dev: {
       describe: string;

package/dist/types/locale/index.d.ts

@@ -8,7 +8,9 @@ declare const localeKeys: {
       style_only: string;
       platform: string;
       no_tsc: string;
+      dts: string;
       no_clear: string;
+      config: string;
     };
     dev: {
       describe: string;
@@ -30,7 +32,9 @@ declare const localeKeys: {
       style_only: string;
       platform: string;
       no_tsc: string;
+      dts: string;
       no_clear: string;
+      config: string;
     };
     dev: {
       describe: string;

package/dist/types/locale/zh.d.ts

@@ -7,7 +7,9 @@ export declare const ZH_LOCALE: {
       style_only: string;
       platform: string;
       no_tsc: string;
+      dts: string;
       no_clear: string;
+      config: string;
     };
     dev: {
       describe: string;

package/dist/types/schema/build-config.d.ts

@@ -0,0 +1,197 @@
+export declare const targets: string[];
+export declare const presets: string[];
+export declare const buildSchema: ({
+  target: string;
+  schema: {
+    if: {
+      type: string;
+    };
+    then: {
+      items: {
+        type: string;
+        properties: {
+          target: {
+            enum: string[];
+          };
+          format: {
+            enum: string[];
+          };
+          sourceMap: {
+            enum: (string | boolean)[];
+          };
+          buildType: {
+            enum: string[];
+          };
+          bundleOptions: {
+            type: string;
+            properties: {
+              entry: {
+                type: string;
+              };
+              splitting: {
+                type: string;
+              };
+              externals: {
+                type: string;
+                items: {
+                  anyOf: ({
+                    instanceof: string;
+                    typeof?: undefined;
+                  } | {
+                    typeof: string;
+                    instanceof?: undefined;
+                  })[];
+                };
+              };
+              platform: {
+                enum: string[];
+              };
+              minify: {
+                enum: (string | boolean)[];
+              };
+              skipDeps: {
+                type: string;
+              };
+            };
+          };
+          bundlelessOptions: {
+            type: string;
+            properties: {
+              sourceDir: {
+                type: string;
+              };
+              style: {
+                type: string;
+                properties: {
+                  compileMode: {
+                    enum: (string | boolean)[];
+                  };
+                  path: {
+                    type: string;
+                  };
+                };
+              };
+              static: {
+                type: string;
+                properties: {
+                  path: {
+                    type: string;
+                  };
+                };
+              };
+            };
+          };
+          tsconfig: {
+            type: string;
+          };
+          enableDts: {
+            type: string;
+          };
+          dtsOnly: {
+            type: string;
+          };
+          outputPath: {
+            type: string;
+          };
+        };
+      }[];
+    };
+    else: {
+      type: string;
+      properties: {
+        target: {
+          enum: string[];
+        };
+        format: {
+          enum: string[];
+        };
+        sourceMap: {
+          enum: (string | boolean)[];
+        };
+        buildType: {
+          enum: string[];
+        };
+        bundleOptions: {
+          type: string;
+          properties: {
+            entry: {
+              type: string;
+            };
+            splitting: {
+              type: string;
+            };
+            externals: {
+              type: string;
+              items: {
+                anyOf: ({
+                  instanceof: string;
+                  typeof?: undefined;
+                } | {
+                  typeof: string;
+                  instanceof?: undefined;
+                })[];
+              };
+            };
+            platform: {
+              enum: string[];
+            };
+            minify: {
+              enum: (string | boolean)[];
+            };
+            skipDeps: {
+              type: string;
+            };
+          };
+        };
+        bundlelessOptions: {
+          type: string;
+          properties: {
+            sourceDir: {
+              type: string;
+            };
+            style: {
+              type: string;
+              properties: {
+                compileMode: {
+                  enum: (string | boolean)[];
+                };
+                path: {
+                  type: string;
+                };
+              };
+            };
+            static: {
+              type: string;
+              properties: {
+                path: {
+                  type: string;
+                };
+              };
+            };
+          };
+        };
+        tsconfig: {
+          type: string;
+        };
+        enableDts: {
+          type: string;
+        };
+        dtsOnly: {
+          type: string;
+        };
+        outputPath: {
+          type: string;
+        };
+      };
+    };
+    enum?: undefined;
+  };
+} | {
+  target: string;
+  schema: {
+    enum: string[];
+    if?: undefined;
+    then?: undefined;
+    else?: undefined;
+  };
+})[];