miniprogram-ci 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,7 +1,9 @@
+#### 2.0.9
+ - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
+#### 2.0.8
+ - `fix` 修复 babel 导致的 path.requeueComputedKeyAndDecorators 问题
 #### 2.0.7
  - `fix` 修复 Skyline disableScroll 不强制为 true
-#### 2.0.6
- - `fix` 修复 未设置 onProgressUpdate 输出日志为[object Object]的问题
 #### 2.0.5
  - `fix` 修复 命令行执行完不退出的问题
  - `fix` 修复 输出日志为[object Object]的问题

package/README.md

@@ -8,6 +8,12 @@ miniprogram-ci 从 1.0.28 开始支持第三方平台开发的上传和预览，
 
 ## 最近变更
 
+#### 2.0.9
+ - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
+#### 2.0.8
+ - `fix` 修复 babel 导致的 path.requeueComputedKeyAndDecorators 问题
+#### 2.0.7
+ - `fix` 修复 Skyline disableScroll 不强制为 true
 #### 2.0.6
  - `fix` 修复 未设置 onProgressUpdate 输出日志为[object Object]的问题
 #### 2.0.5

package/dist/@types/ci/utils/tools.d.ts

@@ -1,4 +1,5 @@
 import { MiniProgramCI, MiniProgramDevtools } from '../../types';
+export declare const CompileSettingsKeysInProjectConfig: string[];
 export declare function isGameApp(project: MiniProgramCI.IProject): boolean;
 export declare const checkIsUseCompilerPlugins: (project: MiniProgramCI.IProject) => boolean | undefined;
 export declare function isUndefined(value: any): boolean;

package/dist/@types/common/code-analyse/index.d.ts

@@ -32,8 +32,17 @@ export declare class Analyzer {
     /** 文件是否已经发生改变？ */
     invalid: boolean;
     constructor(option: AnalyzerOption);
+    destroy(): void;
     private getEntryDep;
-    analyse(): Promise<void>;
+    analyse(force?: boolean): Promise<void>;
+    /**
+     * 不管怎么样都会从新分析的
+     */
+    private realAnalyse;
+    /**
+     * 只要 fileUtils 抛出 change 事件，就分析
+     * @param callback
+     */
     watch(callback: () => void): void;
     serialize(): IAnalyseResult | undefined;
     callPlugin<T extends Exclude<keyof AnalyzerPlugin, 'name'>>(event: T, ...args: any): void;
@@ -82,9 +91,11 @@ export declare class FileHelper implements IFileHelper {
     root: string;
     type: CompileType;
     compilerPlugins: ICompilerPlugin[];
+    private _watcher;
     dirSet: Set<string>;
     fileSet: Set<string>;
     constructor(root: string, type?: CompileType, compilerPlugins?: ICompilerPlugin[]);
+    destroy(): void;
     private cacheDirName;
     get pattern(): string;
     init(): void;
@@ -203,6 +214,9 @@ declare interface IAppJSON {
     tabBar?: {
         custom?: boolean;
     };
+    appBar?: {
+        custom?: boolean;
+    };
     resolveAlias?: {
         [key: string]: string;
     };
@@ -260,6 +274,7 @@ export declare interface IFileHelper {
     readdir(dirPath: string): Promise<string[]>;
     watchFileChange(callback: () => void): void;
     getLocalFileString?(filePath: string): Promise<string>;
+    destroy(): void;
 }
 
 /**

package/dist/@types/config/config.d.ts

@@ -1,5 +1,5 @@
 import { IProject } from '../types';
-export declare const CI_VERSION = "2.0.7";
+export declare const CI_VERSION = "2.0.9";
 export declare const PARAM_ERROR = 10000;
 export declare const WXML_NOT_FOUND = 10007;
 export declare const JS_NOT_FOUND = 10008;
@@ -91,3 +91,10 @@ export declare enum AstType {
     Babel = "babel",
     Acorn = "acorn"
 }
+export declare enum EFilterCode {
+    Include = 0,
+    PackOptionsIgnore = 1,
+    AnalyseNoUse = 2,
+    PartialCompileNoUse = 3
+}
+export declare const MAX_CODE_LENGTH: number;

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

@@ -18,10 +18,11 @@ import { getHelperOutputPath, getHelperDeps, isValidHelperFunc, getHelperContent
 import * as adroidDeviceUtils from './modules/nativecompiler/android/device';
 import * as iosDeviceUtils from './modules/nativecompiler/ios/device';
 import * as miniappBuilder from './utils/miniapp-builder';
+import packOptionsHelper from './utils/packOptionsHelper';
 export { BaseProject, CIProject as Project, CIProject, DevtoolsProject, WebProject, PreCompileProject, };
 export { BaseCoreCompiler, OriginalCompiler, SummerCompiler, ICompilerStatus, ICompileOptions, Builder, };
 export * from './modules/corecompiler/original';
 export declare const workletVersion: any;
-export { getWhiteExtList, proxy, locales, isHexColor, DefaultProjectAttr, JSON_CONTENT_ERR, compileTypeConfig, generateMD5, mkdirSync, normalizePath, checkIsInSubPackage, getHelperOutputPath, isValidHelperFunc, getHelperName, getHelperContent, getHelperDeps, getBabelHelperVersion, getBabelHelperDepMap, escapeQuot, escapeScript, getSummerPluginConfig, };
+export { getWhiteExtList, proxy, locales, isHexColor, DefaultProjectAttr, JSON_CONTENT_ERR, compileTypeConfig, generateMD5, mkdirSync, normalizePath, checkIsInSubPackage, getHelperOutputPath, isValidHelperFunc, getHelperName, getHelperContent, getHelperDeps, getBabelHelperVersion, getBabelHelperDepMap, escapeQuot, escapeScript, getSummerPluginConfig, packOptionsHelper, };
 export { adroidDeviceUtils, iosDeviceUtils, miniappBuilder, };
 export * from './ci/index';

package/dist/@types/modules/corecompiler/baseCompiler.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { ExtJSON, AppJSON, IGameJSON, MiniProgramCore, PageJSON, PluginJSON, SiteMapJSON, ThemeJSON, MiniProgramDevtools } from '../../types';
 import { SingletonTask } from '../../utils/singletontask';
+import { EFilterCode } from '../../config/config';
 import { FileInfo } from './summer/graph/basegraph';
 export type ICompileOptions = MiniProgramCore.ICompileOptions;
 export declare abstract class BaseCoreCompiler {
@@ -52,6 +53,10 @@ export declare abstract class BaseCoreCompiler {
     getMPJSFileList(filter?: string): string[];
     getMPWXSSFileList(filter?: string): string[];
     getMPJSONFileList(filter?: string): string[];
+    getFiltedFileListReason(resultType: MiniProgramCore.IResultType): Promise<{
+        file: string;
+        code: EFilterCode;
+    }[]>;
     getPluginFileList(prefix?: string, extName?: string): string[];
     getPluginWXMLFileList(filter?: string): string[];
     getPluginWXSFileList(filter?: string): string[];
@@ -61,6 +66,7 @@ export declare abstract class BaseCoreCompiler {
     isValidComponent(prefix: string | undefined, filePath: string): boolean;
     getAllFileInfo(prefix?: string): MiniProgramCore.IFileInfos;
     abstract getMPFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    abstract getPackageWxssFileList(packagePath: string): Promise<string[]>;
     abstract getPackageWxssFiles(packagePath: string): Promise<{
         wxssFiles: string[];
         content: Record<string, string>;

package/dist/@types/modules/corecompiler/originalCompiler.d.ts

@@ -63,6 +63,7 @@ export declare class OriginalCompiler extends BaseCoreCompiler {
     }>;
     setLocale(locale: string): void;
     clearCache(): void;
+    getPackageWxssFileList(_packagePath: string): Promise<never[]>;
     getPackageWxssFiles(_packagePath: string): Promise<{
         wxssFiles: string[];
         content: Record<string, string>;

package/dist/@types/modules/corecompiler/processHandler.d.ts

@@ -0,0 +1,24 @@
+import { MiniProgramDevtools } from '../../types';
+interface IProcessMsg {
+    type: 'progress';
+    id: number | string;
+    taskId: number;
+    status: string;
+    message: string;
+}
+interface IResponseMsg {
+    type: 'response';
+    id: number | string;
+    data: any;
+    error?: {
+        code: number;
+        message: string;
+        stack: string;
+        path: string;
+    };
+}
+type ICallbackMsg = IProcessMsg | IResponseMsg;
+export declare function initHandler(message: MiniProgramDevtools.InitMsg): Promise<void>;
+export declare function destroy(): Promise<void>;
+export declare function messageHandler(message: MiniProgramDevtools.SummerProcessMessage, onProgressUpdate?: MiniProgramDevtools.ProgressUpdate): Promise<ICallbackMsg | undefined>;
+export {};

package/dist/@types/modules/corecompiler/summer/graph/appconf.d.ts

@@ -26,6 +26,10 @@ export declare class AppConf extends MiniProgramBaseConf {
         pageResults: Record<string, string>;
         componentResults: Record<string, string>;
     }>;
+    buildPagesAndCompsWithFileListForUpload(recorder: Recorder, fileList: string[], disabelSpreadingUsingComponent?: boolean): Promise<{
+        pageResults: Record<string, string>;
+        componentResults: Record<string, string>;
+    }>;
     onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string) => void;
     protected resetState(): Promise<void>;
     protected load(recorder: Recorder): Promise<void>;

package/dist/@types/modules/corecompiler/summer/graph/appgraph.d.ts

@@ -21,4 +21,10 @@ export declare class AppGraph extends BaseGraph {
             [x: string]: string;
         };
     }>;
+    protected compileJSONWithFileList(options: MiniProgramCore.ICompileOptionsWithFileList, recorder: Recorder): Promise<{
+        conf: MiniProgramDevtools.IAppConf;
+        jsons: {
+            [x: string]: string;
+        };
+    }>;
 }

package/dist/@types/modules/corecompiler/summer/graph/basegraph.d.ts

@@ -54,14 +54,14 @@ export declare abstract class BaseGraph {
     protected abstract checkFilePackage(path: string): string;
     protected abstract getIndependentRoot(targetPath: string): string;
     private onFileChange;
-    private onFileAndDirChange;
     private invalidateModules;
     private loadModuleFromFile;
     private loadSourceForModule;
     protected doCompileSingleCode(info: FileInfo, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
     private getCodeFileTask;
     protected getCodeFiles(files: FileInfo[], recorder: Recorder, options?: MiniProgramCore.ICompileOptions & {
-        useCache: boolean;
+        useCache?: boolean;
+        resultType?: MiniProgramCore.IResultType;
     }): Promise<MiniProgramDevtools.CodeFiles>;
     private readFile;
     private tranform;
@@ -69,13 +69,21 @@ export declare abstract class BaseGraph {
     private optimize;
     private compress;
     compile(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<MiniProgramDevtools.ICompileResult>;
+    compileWithFileList(options: MiniProgramCore.ICompileOptionsWithFileList, recorder: Recorder): Promise<MiniProgramDevtools.ICompileResult>;
     protected abstract getWhiteListConfig(): Promise<Set<string>>;
     getLocalFileList(): Promise<MiniProgramCore.IFileInfos>;
     private compileOther;
     private compileCodeWithoutJSON;
+    private compileCodeWithoutJSONWithFileList;
     protected isBabelSettingIgnore(fileInfo: ResolveFileInfo): boolean;
     protected abstract onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
     abstract getConf(recorder: Recorder): Promise<MiniProgramDevtools.IAppConf | MiniProgramDevtools.IPluginConf | MiniProgramDevtools.IGameConf | MiniProgramDevtools.IGamePluginConf>;
+    getDevCodeByFileList(recorder: Recorder, options: {
+        fileList: string[];
+    }): Promise<MiniProgramDevtools.CodeFiles>;
+    getProdCodeByFileList(recorder: Recorder, options: {
+        fileList: string[];
+    }): Promise<MiniProgramDevtools.CodeFiles>;
     abstract getDevCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
     abstract getProdCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
     abstract compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
@@ -83,6 +91,10 @@ export declare abstract class BaseGraph {
         conf: any;
         jsons: Record<string, string>;
     }>;
+    protected abstract compileJSONWithFileList(options: MiniProgramCore.ICompileOptionsWithFileList, recorder: Recorder): Promise<{
+        conf: any;
+        jsons: Record<string, string>;
+    }>;
     protected abstract getLocalCodeFileList(): string[];
 }
 export {};

package/dist/@types/modules/corecompiler/summer/graph/gamegraph.d.ts

@@ -21,4 +21,10 @@ export declare class GameGraph extends BaseGraph {
             [x: string]: string;
         };
     }>;
+    protected compileJSONWithFileList(options: MiniProgramCore.ICompileOptionsWithFileList, recorder: Recorder): Promise<{
+        conf: MiniProgramDevtools.IGameConf;
+        jsons: {
+            [x: string]: string;
+        };
+    }>;
 }

package/dist/@types/modules/corecompiler/summer/graph/gameplugingraph.d.ts

@@ -13,11 +13,15 @@ export declare class GamePluginGraph extends BaseGraph {
     getProdCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
     protected getLocalCodeFileList(): string[];
     protected onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
-    getPackageFile(): Promise<FileInfo[]>;
+    getPackageFile(root?: string): Promise<FileInfo[]>;
     protected checkFilePackage(path: string): string;
     protected getIndependentRoot(targetPath: string): string;
     protected compileJSON(): Promise<{
         conf: MiniProgramDevtools.IGamePluginConf;
         jsons: Record<string, string>;
     }>;
+    protected compileJSONWithFileList(): Promise<{
+        conf: MiniProgramDevtools.IGamePluginConf;
+        jsons: Record<string, string>;
+    }>;
 }

package/dist/@types/modules/corecompiler/summer/graph/plugingraph.d.ts

@@ -13,11 +13,15 @@ export declare class PluginGraph extends BaseGraph {
     getProdCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
     protected getLocalCodeFileList(): string[];
     protected onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
-    getPackageFile(): Promise<FileInfo[]>;
+    getPackageFile(root?: string): Promise<FileInfo[]>;
     protected getIndependentRoot(targetPath: string): string;
     protected checkFilePackage(path: string): string;
     protected compileJSON(): Promise<{
         conf: MiniProgramDevtools.IPluginConf;
         jsons: Record<string, string>;
     }>;
+    protected compileJSONWithFileList(): Promise<{
+        conf: MiniProgramDevtools.IPluginConf;
+        jsons: Record<string, string>;
+    }>;
 }

package/dist/@types/modules/corecompiler/summer/plugins/base/javascript.d.ts

@@ -1,3 +1,3 @@
 import { MiniProgramCore, MiniProgramSummer } from '../../../../../types';
-export declare const MAX_CODE_LENGTH: number;
+export { MAX_CODE_LENGTH, } from '../../../../../config/config';
 export default function (project: MiniProgramCore.IPreCompileProject): MiniProgramSummer.SummerPlugin;

package/dist/@types/modules/corecompiler/summer/plugins/base/swc.d.ts

@@ -1,5 +1,5 @@
 import { MiniProgramCore, MiniProgramSummer } from '../../../../../types';
-export declare const MAX_CODE_LENGTH: number;
+export { MAX_CODE_LENGTH, } from '../../../../../config/config';
 export declare function getSWCRoot(project: MiniProgramCore.IPreCompileProject, independentRoot: string): string;
 export default function (project: MiniProgramCore.IPreCompileProject, options: {
     disableUseStrict: boolean;

package/dist/@types/modules/corecompiler/summer/summer.d.ts

@@ -31,10 +31,15 @@ export declare class SummerCompiler {
     destroy(): void;
     getStatus(): MiniProgramDevtools.ICompilerStatus;
     clearCache(): void;
-    getPackageFiles({ graphId, root, }: MiniProgramDevtools.IGetPackageFilesOptions): Promise<import("./graph/basegraph").FileInfo[] | undefined>;
+    getPackageFiles({ graphId, root, }: MiniProgramCore.IGetPackageFilesOptions, recorder: Recorder): Promise<import("./graph/basegraph").FileInfo[] | undefined>;
     getConf({ graphId }: MiniProgramDevtools.IGetConfOptions, recorder: Recorder): Promise<MiniProgramDevtools.IAppConf | MiniProgramDevtools.IPluginConf | MiniProgramDevtools.IGameConf | MiniProgramDevtools.IGamePluginConf>;
     getCode(options: MiniProgramDevtools.IGetCodeOptions, recorder: Recorder): Promise<MiniProgramDevtools.CodeFiles>;
+    getDevCodeByFileList(options: MiniProgramDevtools.IGetCodeByFileListOptions, recorder: Recorder): Promise<MiniProgramDevtools.CodeFiles>;
     getLocalFileList(graphId: MiniProgramDevtools.GraphId): Promise<MiniProgramCore.IFileInfos>;
     compileSingleCode(options: MiniProgramDevtools.ICompileSingleCodeOptions, recorder: Recorder): Promise<MiniProgramDevtools.CodeFile>;
+    compileNewLogic(options: MiniProgramCore.ICompileOptionsWithFileList, recorder: Recorder): Promise<{
+        app: MiniProgramDevtools.ICompileResult;
+        plugin?: MiniProgramDevtools.ICompileResult;
+    }>;
     compile(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<MiniProgramDevtools.ICompileResult>;
 }

package/dist/@types/modules/corecompiler/summerCompiler.d.ts

@@ -1,23 +1,29 @@
 /// <reference types="node" />
 import { MiniProgramDevtools, MiniProgramCore, ExtJSON } from '../../types';
+import { FileInfo } from './summer/graph/basegraph';
 import { SubProcessProxy } from '../../utils/subprocess/processManager';
 import { IMessageHub } from '../../utils/messageHub';
 import { BaseCoreCompiler } from './baseCompiler';
+import { Analyzer } from '../../common/code-analyse';
 export { ICompilerStatus } from './summer/summer';
 export declare class SummerCompiler extends BaseCoreCompiler {
     project: MiniProgramCore.IPreCompileProject;
     private cachePath;
     private projectInfo;
     private devtoolMessagehub;
+    private analyzer;
+    private _filterFactory?;
     readonly isSummer = true;
     subProcessManager: SubProcessProxy | undefined;
     private codeCache;
     private promiseCache;
+    private _taskCache;
     private messageHub;
     _status: MiniProgramDevtools.ICompilerStatus | undefined;
     private _eventAdded;
     private _locale;
-    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub);
+    private codeCacheByPath;
+    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub, analyzer: Analyzer, _filterFactory?: MiniProgramDevtools.IFilterFactory | undefined);
     get status(): MiniProgramDevtools.ICompilerStatus | undefined;
     protected init(): Promise<void>;
     private loadStatus;
@@ -31,7 +37,10 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     private invalidCodeCache;
     private onProgressUpdate;
     private getConf;
-    getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string): Promise<any>;
+    getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string, resultType?: MiniProgramCore.IResultType, useCache?: boolean): Promise<FileInfo[]>;
+    _getPackageFiles: (graphId: import("../../types").MiniProgramCI.ProjectType, root: string, resultType?: MiniProgramCore.IResultType) => Promise<FileInfo[]>;
+    private filterFactory;
+    private getCodeByFileList;
     private getCode;
     getExtJSON(): Promise<ExtJSON.IExtJSON>;
     getAppJSON(): Promise<any>;
@@ -54,6 +63,7 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         wxsFiles: string[];
         content: Record<string, string>;
     }>;
+    getPackageWxssFileList(packagePath: string): Promise<any[]>;
     getPackageWxssFiles(packagePath: string): Promise<{
         wxssFiles: string[];
         content: Record<string, string>;
@@ -75,6 +85,18 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         componentFiles: string[];
         otherFiles: string[];
     }>;
+    compileJSList(options: {
+        root: string;
+        fileList: string[];
+        babelRoot: string;
+    }): Promise<{
+        isLargeFile?: boolean | undefined;
+        isBabelIgnore?: boolean | undefined;
+        helpers?: string[] | undefined;
+        filePath: string;
+        code: string;
+        map: string | import("../../types").MiniProgramSummer.SourceMap | undefined;
+    }[]>;
     compileJS(options: {
         root: string;
         filePath: string;
@@ -90,6 +112,8 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         map: string | import("../../types").MiniProgramSummer.SourceMap | undefined;
     }>;
     compile(options: MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.ICompileResult>;
+    private compileOther;
+    compile2(options: MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.ICompileResult>;
     getPluginJSON(localPath?: string): Promise<any>;
     getPluginPageJSON(pagePath: string): Promise<any>;
     getPluginComponents(): Promise<string[]>;
@@ -119,4 +143,8 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         pages: Record<string, any>;
         comps: Record<string, any>;
     }>;
+    getFiltedFileListReason(resultType: MiniProgramCore.IResultType): Promise<{
+        file: string;
+        code: number;
+    }[]>;
 }

package/dist/@types/modules/createSummer.d.ts

@@ -1,12 +1,13 @@
 import { MiniProgramCore } from '../types';
 import { SummerCompiler, ICompilerStatus } from './corecompiler/summerCompiler';
+import { Analyzer } from '../common/code-analyse';
 export declare class SummerCompilerFactory {
     summerCompiler: SummerCompiler | null;
     private project;
     private createPromise;
     summerCompilerStatus: ICompilerStatus | undefined;
     private releaseCbs;
-    getSummerCompiler(project: MiniProgramCore.IPreCompileProject): Promise<SummerCompiler>;
+    getSummerCompiler(project: MiniProgramCore.IPreCompileProject, analyzer: Analyzer): Promise<SummerCompiler>;
     private shouldCreate;
     private releaseLastCompiler;
     private ensureCacheDir;
@@ -15,4 +16,4 @@ export declare class SummerCompilerFactory {
     private getSummerOptions;
 }
 export declare const summerCompilerFactory: SummerCompilerFactory;
-export declare const getSummerCompiler: (project: MiniProgramCore.IPreCompileProject) => Promise<SummerCompiler>;
+export declare const getSummerCompiler: (project: MiniProgramCore.IPreCompileProject, analyzer: Analyzer) => Promise<SummerCompiler>;

package/dist/@types/modules/index.d.ts

@@ -4,6 +4,7 @@ import { IMessageHub, IConsoleDisplay } from '../utils/messageHub';
 import { PreCompiler } from './precompiler/index';
 import { SummerCompiler } from './corecompiler/summerCompiler';
 import { NativeCompiler } from './nativecompiler';
+import { Analyzer } from '../common/code-analyse';
 interface IBuilderOptions {
     summerCompilerClass?: typeof SummerCompiler;
     cachePath?: string;
@@ -15,6 +16,7 @@ interface IBuilderOptions {
     targetPlatform?: MiniProgramCore.ITargetPlatform;
     targetPlatformDefines?: MiniProgramCore.ITargetPlatformDefine;
     outputDir?: string;
+    filterFactory?: MiniProgramDevtools.IFilterFactory;
 }
 export declare class Builder {
     originProject: MiniProgramCI.IProject;
@@ -24,12 +26,16 @@ export declare class Builder {
     private _nativeCompiler;
     private _options;
     private _checkReadyTask?;
+    private _getSummerCompilerTask?;
     private _originalCompiler;
+    private _analyzer?;
     constructor(project: MiniProgramCI.IProject, opts: IBuilderOptions);
-    getCompiler(): Promise<SummerCompiler>;
+    getCompiler(): Promise<any>;
+    getAnalyzer(): Promise<Analyzer>;
     getPreCompileProject(): Promise<PreCompileProject>;
     getPreCompiler(): Promise<PreCompiler>;
-    getSummerCompiler(): Promise<SummerCompiler>;
+    getSummerCompiler(): Promise<any>;
+    private _getSummerCompiler;
     ready(): Promise<any>;
     init(): Promise<void>;
     getNativeCompiler(): Promise<NativeCompiler>;

package/dist/@types/modules/nativecompiler/ios/buildCloud.d.ts

@@ -4,7 +4,6 @@ import { IEntitlements } from '../../../utils/codesign';
 import II18NInfo = IMiniApp.II18NInfo;
 type ITheme = 'Light' | 'LightSpecial' | 'Dark' | 'DarkSpecial' | 'Default';
 export declare const remoteBuildProjectMaterialAbsoluteCacheDir = "__absoluteFile";
-export declare const privateDescriptions: string[];
 export interface IBuildCloudResult {
     projectPath: string;
     demoIpaPath: string;
@@ -27,7 +26,8 @@ declare class buildCloudManager {
     updateIOSAppexInfoPlistInfo(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, CFBundleVersion: number, recorder: Recorder): Promise<void>;
     private updateBundleIcons;
     updateIOSIcons(projectPath: string, demoIpaPath: string, miniappCacheDirPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, isPublish: boolean, recorder: Recorder): Promise<void>;
-    updateSplashScreen(projectPath: string, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, theme?: ITheme): Promise<false | undefined>;
+    replaceLaunchScreenImage(storyboardPath: string, newScreenImagePath: string, oldScreenImageName: string, recorder: Recorder, projectPath: string, demoIpaPath: string): string | undefined;
+    updateSplashScreen(projectPath: string, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, theme: ITheme | undefined, i18nInfo: II18NInfo): Promise<void>;
     genUseExtendedSdk(iosMiniappJson: MiniProgramCore.IStringKeyMap): MiniProgramCore.IStringKeyMap<any>;
     updateExtendedSdk(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, sdkPath: string, arch: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;
     updatePrivacyInfo(demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;

package/dist/@types/types/ci.d.ts

@@ -67,6 +67,7 @@ export declare namespace MiniProgramCI {
             ignore: MiniProgramDevtools.IProjectConfigPackOption[];
             include: MiniProgramDevtools.IProjectConfigPackOption[];
         };
+        destroy?: () => void;
     }
     interface IStringKeyMap<T = any> {
         [propName: string]: T;
@@ -104,7 +105,7 @@ export declare namespace MiniProgramCI {
     interface ITaskStatus {
         id: string;
         message: string;
-        status: 'doing' | 'done' | 'fail';
+        status: 'doing' | 'done' | 'fail' | 'warn';
     }
     interface IDevToolsCompileCache {
         init: (project: IProject) => Promise<void>;

package/dist/@types/types/core.d.ts

@@ -45,11 +45,16 @@ export declare namespace MiniProgramCore {
         getAllFileInfo: (prefix?: string) => IFileInfos;
         onFileChange?: any;
     }
+    type IGetPackageFilesOptions = {
+        graphId: ProjectType;
+        root: string;
+    };
     interface IPreCompileProject extends IProject {
         project: MiniProgramCI.IProject;
         targetPlatform?: ITargetPlatform;
         targetPlatformDefines?: ITargetPlatformDefine;
         conditionCompiler?: any;
+        updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
         getSrcFile(prefix: string, filePath: string): Buffer;
     }
     interface IStringKeyMap<T = any> {
@@ -73,11 +78,11 @@ export declare namespace MiniProgramCore {
         [key: string]: any;
     }
     type ICompileSettings = MiniProgramCI.ICompileSettings;
-    type IResultType = 'prod' | 'dev';
+    type IResultType = 'prod' | 'dev' | 'preview';
     interface ITaskStatus {
         id: string;
         message: string;
-        status: 'doing' | 'fail' | 'done';
+        status: 'doing' | 'fail' | 'done' | 'warn';
     }
     interface IDevToolsCompileCache {
         init: (project: IProject) => Promise<void>;
@@ -107,6 +112,20 @@ export declare namespace MiniProgramCore {
         analyzer?: Analyzer;
         disableSpreadingUsingComponents?: boolean;
         resultType?: IResultType;
+        useCache?: boolean;
+        targetPlatform?: 'mini-ios' | 'mini-android' | 'miniprogram';
+    }
+    interface ICompileOptionsWithFileList {
+        nameMapping?: IStringKeyMap<string>;
+        setting?: MiniProgramDevtools.IProjectSetting;
+        fileList: string[];
+        onProgressUpdate?: (task: ITaskStatus) => void;
+        devToolsCompileCache?: IDevToolsCompileCache;
+        __compileDebugInfo__?: IDevtoolsDebugInfo;
+        compilePages?: string[];
+        analyzer?: Analyzer;
+        disableSpreadingUsingComponents?: boolean;
+        resultType?: IResultType;
     }
     type IProjectAttr = MiniProgramCI.IProjectAttr;
     interface IWarnItem {

package/dist/@types/types/devtools.d.ts

@@ -11,6 +11,7 @@ export declare namespace MiniProgramDevtools {
         sitemap: any;
         theme: any;
     }
+    type IFilterFactory = (resultType: MiniProgramCore.IResultType) => Promise<(graph: GraphId, abFilePath: string) => number>;
     interface IGameConf {
         app: any;
         packages: Record<string, any>;
@@ -24,7 +25,7 @@ export declare namespace MiniProgramDevtools {
         plugin: any;
     }
     type IShowBuildLog = (msgId: string, type: IBuildLogType, text: string) => void;
-    type ProgressUpdate = (id: number, status: 'doing' | 'fail' | 'done', message: string) => void;
+    type ProgressUpdate = (id: number | string, status: 'doing' | 'fail' | 'done' | 'warn', message: string) => void;
     type ISummerPluginConfig = Array<string | [string, MiniProgramSummer.SummerPluginOptions]>;
     type IBabelSetting = {
         outputPath?: string;
@@ -44,15 +45,15 @@ export declare namespace MiniProgramDevtools {
         pluginRoot: string;
         summerPlugins: ISummerPluginConfig;
         setting: MiniProgramDevtools.IProjectSetting;
+        packOptions?: {
+            ignore: MiniProgramDevtools.IProjectConfigPackOption[];
+            include: MiniProgramDevtools.IProjectConfigPackOption[];
+        };
     }
     type GraphId = MiniProgramCore.ProjectType;
     type IGetConfOptions = {
         graphId: GraphId;
     };
-    type IGetPackageFilesOptions = {
-        graphId: GraphId;
-        root: string;
-    };
     type ICompileSingleCodeOptions = {
         graphId: GraphId;
         filePath: string;
@@ -63,6 +64,11 @@ export declare namespace MiniProgramDevtools {
         cacheMd5: Record<string, string>;
         package?: string;
     };
+    type IGetCodeByFileListOptions = {
+        graphId: GraphId;
+        cacheMd5: Record<string, string>;
+        fileList: string[];
+    };
     interface IDevtoolsProject {
         id: string;
         appid: string;