miniprogram-ci 2.0.8 → 2.0.10

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+#### 2.0.10
+ - `fix` 修复 schema d.ts路径问题
+#### 2.0.9
+ - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
 #### 2.0.8
  - `fix` 修复 babel 导致的 path.requeueComputedKeyAndDecorators 问题
 #### 2.0.7

package/README.md

@@ -8,6 +8,10 @@ miniprogram-ci 从 1.0.28 开始支持第三方平台开发的上传和预览，
 
 ## 最近变更
 
+#### 2.0.10
+ - `fix` 修复 schema d.ts路径问题
+#### 2.0.9
+ - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
 #### 2.0.8
  - `fix` 修复 babel 导致的 path.requeueComputedKeyAndDecorators 问题
 #### 2.0.7

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.8";
+export declare const CI_VERSION = "2.0.10";
 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/original/validate/schemaValidate.d.ts

@@ -1,4 +1,4 @@
-import { ISchema, IValidateResult } from '../../../../../../schema/dist';
+import { ISchema, IValidateResult } from '../../../../schema/dist';
 export declare const config: {
     [key: string]: ISchema;
 };

package/dist/@types/modules/corecompiler/original/workerThread/task/minifywxml.d.ts

@@ -1,32 +1,34 @@
 /// <reference types="node" />
-import { MiniProgramDevtools } from '../../../../../types';
 interface ICompileData {
-    projectPath: string;
-    root: string;
+    code: string | Buffer;
     filePath: string;
-    setting: MiniProgramDevtools.IProjectSetting;
-    code: Buffer;
+    root?: string;
+    setting?: IMinifySetting;
 }
-declare enum TokenType {
-    ATTR = 0,
-    STRING1 = 1,
-    STRING2 = 2,
-    OTHERS = 3
+export interface IMinifySetting {
+    collapseWhitespace?: boolean;
+    conservativeCollapse?: boolean;
+    preserveLineBreaks?: boolean;
 }
-declare class Token {
-    type: TokenType;
-    value: string;
-    constructor(type: TokenType, value: string);
+export declare class TemplateTokenizer {
+    private tokens?;
+    constructor(src: string, path: string);
+    toString(): string;
+    private generateTokens;
+    private m_pSrc;
+    private path;
+    private machine;
 }
-declare class Tokenizer {
+export declare class StyleAttrValueTokenizer {
+    private tokens?;
     constructor(src: string, path: string);
-    generateTokens(output: Token[]): number;
+    toString(): string;
+    private generateTokens;
     private m_pSrc;
     private path;
     private machine;
 }
-declare function generateWXMLFromTokens(tokens: Token[]): string;
-declare function minifyWXML(data: ICompileData): Promise<{
+export declare function minifyWXML(data: ICompileData): Promise<{
     error: null;
     code: string;
 } | {
@@ -37,10 +39,4 @@ declare function minifyWXML(data: ICompileData): Promise<{
     };
     code?: undefined;
 }>;
-declare const _default: {
-    minifyWXML: typeof minifyWXML;
-    Tokenizer: typeof Tokenizer;
-    generateWXMLFromTokens: typeof generateWXMLFromTokens;
-    Token: typeof Token;
-};
-export = _default;
+export {};

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

@@ -1,14 +1,14 @@
 import { MiniProgramDevtools } from '../../types';
 interface IProcessMsg {
     type: 'progress';
-    id: number;
+    id: number | string;
     taskId: number;
     status: string;
     message: string;
 }
 interface IResponseMsg {
     type: 'response';
-    id: number;
+    id: number | string;
     data: any;
     error?: {
         code: number;
@@ -19,5 +19,6 @@ interface IResponseMsg {
 }
 type ICallbackMsg = IProcessMsg | IResponseMsg;
 export declare function initHandler(message: MiniProgramDevtools.InitMsg): Promise<void>;
-export declare function messageHandler(message: MiniProgramDevtools.SummerProcessMessage): Promise<ICallbackMsg | undefined>;
+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

@@ -10,9 +10,6 @@ export declare class AppGraph extends BaseGraph {
     getConf(recorder: Recorder): Promise<MiniProgramDevtools.IAppConf>;
     compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
     getDevCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
-    getDevCodeByFileList(recorder: Recorder, options: {
-        fileList: string[];
-    }): Promise<MiniProgramDevtools.CodeFiles>;
     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;
@@ -24,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,16 +69,22 @@ 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>;
-    abstract getDevCodeByFileList(recorder: Recorder, options: {
+    getDevCodeByFileList(recorder: Recorder, options: {
         fileList: string[];
     }): Promise<MiniProgramDevtools.CodeFiles>;
+    getProdCodeByFileList(recorder: Recorder, options: {
+        fileList: string[];
+        resultType?: MiniProgramCore.IResultType;
+    }): 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>;
@@ -86,6 +92,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

@@ -10,9 +10,6 @@ export declare class GameGraph extends BaseGraph {
     getConf(recorder: Recorder): Promise<MiniProgramDevtools.IGameConf>;
     compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
     getDevCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
-    getDevCodeByFileList(recorder: Recorder, options: {
-        fileList: string[];
-    }): Promise<MiniProgramDevtools.CodeFiles>;
     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;
@@ -24,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

@@ -10,17 +10,18 @@ export declare class GamePluginGraph extends BaseGraph {
     getConf(recorder: Recorder): Promise<MiniProgramDevtools.IGamePluginConf>;
     compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
     getDevCode(recorder: Recorder): Promise<MiniProgramDevtools.CodeFiles>;
-    getDevCodeByFileList(recorder: Recorder, options: {
-        fileList: string[];
-    }): Promise<MiniProgramDevtools.CodeFiles>;
     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

@@ -10,17 +10,18 @@ export declare class PluginGraph extends BaseGraph {
     getConf(recorder: Recorder): Promise<MiniProgramDevtools.IPluginConf>;
     compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
     getDevCode(recorder: Recorder): Promise<MiniProgramDevtools.CodeFiles>;
-    getDevCodeByFileList(recorder: Recorder, options: {
-        fileList: string[];
-    }): Promise<MiniProgramDevtools.CodeFiles>;
     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/module.d.ts

@@ -21,23 +21,29 @@ export default class Module {
     readonly path: string;
     readonly sourcePath: string;
     fileType: FileType;
-    md5: string;
-    json: any;
-    error?: CustomError | Error;
-    jsTag?: JsTag;
-    source?: MiniProgramSummer.SourceDescription;
-    target?: MiniProgramSummer.GenerateDescription;
-    processInfo?: MiniProgramSummer.IPluginProcessInfo[];
+    private _jsTag?;
+    private _error;
+    private loadResult?;
+    private generateResultPromise;
     depFiles: string[];
     independentRoot: string;
-    loadingPromise: Promise<Boolean> | undefined;
-    loadStart: number;
-    loadEnd: number;
+    isBabelIgnore: boolean;
+    private generatedTS;
     constructor(graph: BaseGraph, path: string, sourcePath: string, fileType: FileType);
-    setError(error: CustomError | Error): void;
-    setResult(generateResult: MiniProgramSummer.IGenerateResult): void;
-    toCodeFile(): MiniProgramDevtools.CodeFile | MiniProgramDevtools.CodeError;
-    toGenerateResult(): MiniProgramSummer.IGenerateResult;
+    private transResultType;
+    getGeneratedTS(resultType: MiniProgramCore.IResultType): number;
+    setError(resultType: MiniProgramCore.IResultType, error: CustomError | Error): void;
+    getError(resultType: MiniProgramCore.IResultType): Error | CustomError | undefined;
+    getJsTag(): Promise<JsTag | undefined>;
+    getSource(): Promise<MiniProgramSummer.SourceDescription>;
+    getMd5(): Promise<string>;
+    setLoadingPromise(promise: Promise<MiniProgramSummer.ILoadResult>): void;
+    getLoadingPromise(): Promise<MiniProgramSummer.ILoadResult> | undefined;
+    setGeneratingPromise(resultType: MiniProgramCore.IResultType, promise: Promise<MiniProgramSummer.IGenerateResult>): void;
+    getGeneratingPromise(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IGenerateResult> | undefined;
+    getProcessInfo(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IPluginProcessInfo[] | undefined>;
+    toCodeFile(resultType: MiniProgramCore.IResultType): Promise<MiniProgramDevtools.CodeFile | MiniProgramDevtools.CodeError>;
+    toGenerateResult(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IGenerateResult | MiniProgramDevtools.CodeError>;
     toJSON(): MiniProgramSummer.ModuleJSON;
     addWatchFile(file: string): void;
 }

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,11 +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

@@ -4,22 +4,25 @@ 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;
-    private codeCacheByPath;
-    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub);
+    private devCodeCacheByPath;
+    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;
@@ -33,9 +36,10 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     private invalidCodeCache;
     private onProgressUpdate;
     private getConf;
-    getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string): Promise<FileInfo[]>;
+    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>;
     getGameJSON(): Promise<any>;
@@ -57,6 +61,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>;
@@ -105,6 +110,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[]>;
@@ -134,4 +141,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;
@@ -25,10 +27,14 @@ export declare class Builder {
     private _options;
     private _checkReadyTask?;
     private _getSummerCompilerTask?;
+    private _getPrecompileProjectTask?;
     private _originalCompiler;
+    private _analyzer?;
     constructor(project: MiniProgramCI.IProject, opts: IBuilderOptions);
     getCompiler(): Promise<any>;
+    getAnalyzer(): Promise<Analyzer>;
     getPreCompileProject(): Promise<PreCompileProject>;
+    private _getPreCompileProject;
     getPreCompiler(): Promise<PreCompiler>;
     getSummerCompiler(): Promise<any>;
     private _getSummerCompiler;

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

@@ -28,6 +28,7 @@ export declare class NativeCompiler {
     buildAndroidPlugin(opts: IMiniApp.IAndroidBuildPluginArgs): Promise<void>;
     buildIOSPlugin(opts: IMiniApp.IBuildPluginIOSFrameworkArgs): Promise<void>;
     packIOSCloudBuildMaterial(opts: IMiniApp.IIOSBuildCloudGenMaterialArgs): Promise<string>;
+    initUSBConnectionProcess(): Promise<void>;
     destroy(): void;
 }
 export {};

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

@@ -3,6 +3,12 @@ import { IMiniApp, MiniProgramCore } from '../../../types';
 import { IEntitlements } from '../../../utils/codesign';
 import II18NInfo = IMiniApp.II18NInfo;
 type ITheme = 'Light' | 'LightSpecial' | 'Dark' | 'DarkSpecial' | 'Default';
+type IOpenMimeTypes = {
+    CFBundleTypeName: string;
+    LSHandlerRank: 'Owner' | 'Default' | 'Alternate' | 'None';
+    CFBundleTypeRole: 'Editor' | 'Viewer' | 'Shell' | 'None';
+    LSItemContentTypes: string[];
+}[];
 export declare const remoteBuildProjectMaterialAbsoluteCacheDir = "__absoluteFile";
 export interface IBuildCloudResult {
     projectPath: string;
@@ -21,6 +27,7 @@ declare class buildCloudManager {
     updatePrivacyBackgroundImage(projectPath: string, demoIpaPath: string, recorder: Recorder, type: 'contentViewImage' | 'cancelButtonImage' | 'confirmButtonImage', imagePath: string): void;
     updateIOSInfoPlistInfo(projectPath: string, bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, i18nInfo: II18NInfo): Promise<any>;
     getBundleIdentifier(mobileapp_info: MiniProgramCore.IStringKeyMap): any;
+    validateCFBundleDocumentTypes(openMimeTypes: IOpenMimeTypes, recorder: Recorder): boolean;
     useGDT(iosMiniappJson: MiniProgramCore.IStringKeyMap): any;
     updateIOSAppConfigPlistInfo(projectPath: string, bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, sdkPath: string, isSimulator: boolean, recorder: Recorder, theme: ITheme | undefined, i18nInfo: II18NInfo): Promise<void>;
     updateIOSAppexInfoPlistInfo(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, CFBundleVersion: number, recorder: Recorder): Promise<void>;
@@ -28,8 +35,8 @@ declare class buildCloudManager {
     updateIOSIcons(projectPath: string, demoIpaPath: string, miniappCacheDirPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, isPublish: boolean, recorder: Recorder): Promise<void>;
     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>;
+    genUseExtendedSdk(iosMiniappJson: MiniProgramCore.IStringKeyMap, debugInfo?: IMiniApp.IDebugInfo): MiniProgramCore.IStringKeyMap<any>;
+    updateExtendedSdk(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, sdkPath: string, arch: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, debugInfo: IMiniApp.IDebugInfo | undefined, recorder: Recorder): Promise<void>;
     updatePrivacyInfo(demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;
     updatePlugin(demoIpaPath: string, pluginDirList: IMiniApp.IIOSPluginDir[], projectPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, miniappCacheDirPath: string, isPublish: boolean, CFBundleVersion: string, recorder: Recorder): Promise<void>;
     copyUserResourcePathIntoPlugins(pluginId: string, projectPath: string, configResourcePath: string, distFrameworkPath: string, recorder: Recorder): void;