miniprogram-ci 1.9.27 → 2.0.0

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

@@ -0,0 +1,23 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { MiniProgramDevtools, MiniProgramCore } from '../../../../types';
+import { BaseGraph, FileInfo, IGraphOptions } from './basegraph';
+export declare class GamePluginGraph extends BaseGraph {
+    private pluginConf;
+    protected conf: MiniProgramDevtools.IGamePluginConf | undefined;
+    constructor(options: IGraphOptions);
+    protected getWhiteListConfig(): Promise<Set<string>>;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<MiniProgramDevtools.IGamePluginConf>;
+    compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    getDevCode(recorder: Recorder): 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[]>;
+    protected checkFilePackage(path: string): string;
+    protected getIndependentRoot(targetPath: string): string;
+    protected compileJSON(): Promise<{
+        conf: MiniProgramDevtools.IGamePluginConf;
+        jsons: Record<string, string>;
+    }>;
+}

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

@@ -0,0 +1,21 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { MiniProgramBaseConf } from './baseconf';
+export declare class PluginConf extends MiniProgramBaseConf {
+    private plugin;
+    private pages;
+    private comps;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<{
+        plugin: any;
+        pages: {
+            [k: string]: any;
+        };
+        comps: {
+            [k: string]: any;
+        };
+    }>;
+    protected resetState(): Promise<void>;
+    protected load(recorder: Recorder): Promise<void>;
+    protected loadPage(path: string): Promise<void>;
+    protected loadComp(resolvedPath: string, literalPath: string, from: string): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { MiniProgramDevtools, MiniProgramCore } from '../../../../types';
+import { BaseGraph, FileInfo, IGraphOptions } from './basegraph';
+export declare class PluginGraph extends BaseGraph {
+    private pluginConf;
+    protected conf: MiniProgramDevtools.IPluginConf | undefined;
+    constructor(options: IGraphOptions);
+    protected getWhiteListConfig(): Promise<Set<string>>;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<MiniProgramDevtools.IPluginConf>;
+    compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    getDevCode(recorder: Recorder): 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[]>;
+    protected getIndependentRoot(targetPath: string): string;
+    protected checkFilePackage(path: string): string;
+    protected compileJSON(): Promise<{
+        conf: MiniProgramDevtools.IPluginConf;
+        jsons: Record<string, string>;
+    }>;
+}

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

@@ -0,0 +1,2 @@
+export declare function resolvePath(currentPath: string, targetPath: string): string;
+export declare function isPluginPath(comp: string): boolean;

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

@@ -0,0 +1,3 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../types';
+export { ICompilerStatus } from './summer';
+export declare function compile(project: MiniProgramCore.IPreCompileProject, projectConfig: any, options: MiniProgramCore.ICompileOptions, _useCompilerPlugins: any): Promise<MiniProgramDevtools.ICompileResult>;

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

@@ -0,0 +1,2 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../types';
+export declare function initPlugin(pluginName: string, project: MiniProgramCore.IPreCompileProject, options: MiniProgramSummer.SummerPluginOptions): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,44 @@
+import { MiniProgramSummer, MiniProgramDevtools, MiniProgramCore } from '../../../types';
+import { CustomError } from '../../../utils/customError';
+import { BaseGraph, FileType } from './graph/basegraph';
+declare class JsTag {
+    isLargeFile: boolean;
+    isBabelIgnore: boolean;
+    helpers: string[];
+    resultType: MiniProgramCore.IResultType;
+    setBabelIgnore(): void;
+    setLargeFile(): void;
+    addHelpers(helpers: string[]): void;
+    setResultType(resultType?: MiniProgramCore.IResultType): void;
+    toJSON(): {
+        isLargeFile: boolean;
+        isBabelIgnore: boolean;
+        helpers: string[];
+    };
+}
+export default class Module {
+    private readonly graph;
+    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[];
+    depFiles: string[];
+    independentRoot: string;
+    loadingPromise: Promise<Boolean> | undefined;
+    loadStart: number;
+    loadEnd: number;
+    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;
+    toJSON(): MiniProgramSummer.ModuleJSON;
+    addWatchFile(file: string): void;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../types';
+import { FileInfo } from './graph/basegraph';
+export default class LogicPersistCache {
+    private baseCacheKey;
+    private persistCache;
+    private project;
+    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, baseCacheKey: string);
+    updateBaseCacheKey(key: string): void;
+    private getCacheKey;
+    get(projectPath: string, root: string, file: FileInfo): Promise<MiniProgramDevtools.CodeFile | undefined>;
+    set(projectPath: string, root: string, file: FileInfo, data: MiniProgramDevtools.CodeFile): Promise<void>;
+    clean(): Promise<void>;
+}

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

@@ -0,0 +1,45 @@
+import { MiniProgramSummer } from '../../../types';
+import { BaseGraph } from './graph/basegraph';
+interface IResolveExt {
+    json?: string;
+    wxml?: string;
+    wxss?: string;
+    js?: string;
+    wxs?: string;
+}
+type ResolveValue<T> = T extends Promise<infer K> ? K : T;
+type EnsurePromise<T> = Promise<ResolveValue<T>>;
+type Arg0<H extends Exclude<keyof MiniProgramSummer.PluginHooks, 'resolveExt'>> = Parameters<MiniProgramSummer.PluginHooks[H]>[0];
+export type ReplaceContext = (context: MiniProgramSummer.PluginContext, plugin: MiniProgramSummer.SummerPlugin) => MiniProgramSummer.PluginContext;
+export interface ICompilerPlugin extends MiniProgramSummer.PluginHooks {
+    resolveExt?: IResolveExt;
+}
+export declare function genResovleExtConf(plugins: MiniProgramSummer.SummerPlugin[]): {
+    json: string[];
+    wxml: string[];
+    wxss: string[];
+    js: string[];
+    wxs: string[];
+};
+export declare function getPluginContext(plugin: MiniProgramSummer.SummerPlugin, graph: BaseGraph): MiniProgramSummer.PluginContext;
+export declare class PluginDriver {
+    private graph;
+    private options;
+    resolveExtConf: {
+        json: string[];
+        wxml: string[];
+        wxss: string[];
+        js: string[];
+        wxs: string[];
+    };
+    plugins: MiniProgramSummer.SummerPlugin[];
+    private pluginContexts;
+    constructor(graph: BaseGraph, options: {
+        plugins: MiniProgramSummer.SummerPlugin[];
+    });
+    private runHook;
+    hookFirst<H extends MiniProgramSummer.AsyncPluginHooks & MiniProgramSummer.FirstPluginHooks>(hookName: H, args: Parameters<MiniProgramSummer.PluginHooks[H]>, replaceContext?: ReplaceContext | null): EnsurePromise<ReturnType<MiniProgramSummer.PluginHooks[H]>>;
+    hookParallel<H extends MiniProgramSummer.AsyncPluginHooks & MiniProgramSummer.ParallelPluginHooks>(hookName: H, args: Parameters<MiniProgramSummer.PluginHooks[H]>, replaceContext?: ReplaceContext): Promise<void>;
+    hookReduceArg0<H extends MiniProgramSummer.AsyncPluginHooks & MiniProgramSummer.SequentialPluginHooks>(hookName: H, [arg0, ...rest]: Parameters<MiniProgramSummer.PluginHooks[H]>, reduce: (reduction: Arg0<H>, result: ResolveValue<ReturnType<MiniProgramSummer.PluginHooks[H]>>, plugin: MiniProgramSummer.SummerPlugin) => Arg0<H>, replaceContext?: ReplaceContext | null): Promise<Arg0<H>>;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import { MiniProgramDevtools } from '../../../types';
+export type AvailableSummerPlugin = 'typescript' | 'javascript' | 'es6module' | 'enhance' | 'wxss' | 'less' | 'sass' | 'terser' | 'minifywxml' | 'worklet' | 'swc';
+export declare function couldUseSWCMode(setting: MiniProgramDevtools.IProjectSetting): boolean | undefined;
+export declare function getSummerPluginConfig(setting: MiniProgramDevtools.IProjectSetting): (AvailableSummerPlugin | [AvailableSummerPlugin, any])[];

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

@@ -0,0 +1,21 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../../types';
+export declare function getBabelRoot(independentRoot: string): string;
+export declare function transformES6ModuleAndGenCode(id: string, source: MiniProgramSummer.SourceDescription, options: {
+    babelRoot: string;
+    disableUseStrict: boolean;
+}): {
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    };
+    helpers: string[];
+};
+export default function (project: MiniProgramCore.IPreCompileProject, options: {
+    disableUseStrict: boolean;
+}): MiniProgramSummer.SummerPlugin;

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../../types';
+export interface IWxssOptions {
+    autoPrefix: boolean;
+    minify: boolean;
+}
+export default function (project: MiniProgramCore.IPreCompileProject, options?: IWxssOptions): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,4 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export default function (project: MiniProgramCore.IPreCompileProject, options: {
+    disableUseStrict: boolean;
+}): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,5 @@
+/// <reference types="less" />
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export declare const importWxssReg: RegExp;
+export declare const importWxssCssReg: RegExp;
+export default function (project: MiniProgramCore.IPreCompileProject, options: Pick<Less.Options, 'globalVars'>): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,5 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export interface IWxmlOptions {
+    minify: boolean;
+}
+export default function (project: MiniProgramCore.IPreCompileProject, options?: IWxmlOptions): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,3 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export declare function random(): string;
+export default function (project: MiniProgramCore.IPreCompileProject): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,2 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export default function (_project: MiniProgramCore.IPreCompileProject): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,2 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export default function (project: MiniProgramCore.IPreCompileProject): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,4 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
+export default function (project: MiniProgramCore.IPreCompileProject, options: {
+    disableUseStrict: boolean;
+}): MiniProgramSummer.SummerPlugin;

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

@@ -0,0 +1,29 @@
+import { IStat } from '../../../types';
+import { BaseGraph } from './graph/basegraph';
+declare const targetCodeExts: readonly ["json", "wxml", "wxss", "js", "wxs"];
+type TargetCodeExt = typeof targetCodeExts[number];
+type ResolveExtConf = Record<TargetCodeExt, string[]>;
+export interface ResolveFileInfo {
+    path: string;
+    source: string;
+    sourceExt: string;
+    stat?: IStat;
+}
+export declare class Resolver {
+    graph: BaseGraph;
+    root: string;
+    extConf: ResolveExtConf;
+    fileSet: Set<string>;
+    resolveInfoMap: Map<string, ResolveFileInfo>;
+    private extToTarget;
+    allExts: string[];
+    constructor(graph: BaseGraph, root: string, extConf: ResolveExtConf);
+    updateFileAndDirs(): void;
+    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string) => void;
+    resolve(source: string): ResolveFileInfo[];
+    stat(path: string): IStat | undefined;
+    private isCodeFile;
+    private getExt;
+    private updateFile;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { MiniProgramCore, MiniProgramDevtools, MiniProgramSummer } from '../../../types';
+import { Recorder } from '../../../utils/progressRecorder';
+import { PluginGraph } from './graph/plugingraph';
+import { GamePluginGraph } from './graph/gameplugingraph';
+import { BaseGraph } from './graph/basegraph';
+import PersistCache from './persistCache';
+export type ICompilerStatus = MiniProgramDevtools.ICompilerStatus;
+export declare class SummerCompiler {
+    project: MiniProgramCore.IPreCompileProject;
+    private cachePath;
+    private devtoolsProject;
+    projectPath: string;
+    appGraph: BaseGraph;
+    pluginGraph?: PluginGraph | GamePluginGraph;
+    plugins: MiniProgramSummer.SummerPlugin[];
+    proxyProject: any;
+    persistCache: PersistCache;
+    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, devtoolsProject: MiniProgramDevtools.IDevtoolsProjectInfo);
+    getBabelSetting(): {
+        ignore: string[];
+        disablePlugins: string[];
+        outputPath: string;
+    } | undefined;
+    getSWCSetting(): MiniProgramDevtools.ISWCSetting | undefined;
+    private initPlugins;
+    private isGameType;
+    private isPluginType;
+    private initAppGraph;
+    private initPluginGraph;
+    updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
+    destroy(): void;
+    getStatus(): MiniProgramDevtools.ICompilerStatus;
+    clearCache(): void;
+    getPackageFiles({ graphId, root, }: MiniProgramDevtools.IGetPackageFilesOptions): 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>;
+    getLocalFileList(graphId: MiniProgramDevtools.GraphId): Promise<MiniProgramCore.IFileInfos>;
+    compileSingleCode(options: MiniProgramDevtools.ICompileSingleCodeOptions, recorder: Recorder): Promise<MiniProgramDevtools.CodeFile>;
+    compile(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<MiniProgramDevtools.ICompileResult>;
+}

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

@@ -0,0 +1 @@
+export declare function ensureArray<T>(items: Array<T | null | undefined> | T | null | undefined): T[];

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

@@ -0,0 +1,2 @@
+import { MiniProgramSummer } from '../../../../types';
+export declare function tryGetInputSourceMap(code: string, absolutePath: string): Promise<MiniProgramSummer.SourceMap | undefined>;

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

@@ -0,0 +1,16 @@
+import { MiniProgramCore, MiniProgramSummer } from '../../../types';
+export type IRunSummerPluginHookData = {
+    command: 'clear';
+} | {
+    command: 'runMethod';
+    plugin: string;
+    projectInfo: MiniProgramCore.IPrecompileProjectSerializeInfo;
+    pluginOption: MiniProgramSummer.SummerPluginOptions;
+    method: string;
+    args: any;
+};
+export type IRunSummerPluginHookResult = {
+    error?: any;
+    result?: any;
+};
+export declare function runSummerPluginHook(data: IRunSummerPluginHookData): Promise<IRunSummerPluginHookResult>;

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

@@ -0,0 +1,121 @@
+/// <reference types="node" />
+import { MiniProgramDevtools, MiniProgramCore, ExtJSON } from '../../types';
+import { SubProcessProxy } from '../../utils/subprocess/processManager';
+import { IMessageHub } from '../../utils/messageHub';
+import { BaseCoreCompiler } from './baseCompiler';
+export { ICompilerStatus } from './summer/summer';
+export declare class SummerCompiler extends BaseCoreCompiler {
+    project: MiniProgramCore.IPreCompileProject;
+    private cachePath;
+    private projectInfo;
+    private devtoolMessagehub;
+    readonly isSummer = true;
+    subProcessManager: SubProcessProxy | undefined;
+    private codeCache;
+    private promiseCache;
+    private messageHub;
+    _status: MiniProgramDevtools.ICompilerStatus | undefined;
+    private _eventAdded;
+    private _locale;
+    constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub);
+    get status(): MiniProgramDevtools.ICompilerStatus | undefined;
+    protected init(): Promise<void>;
+    private loadStatus;
+    destroy(): void;
+    clearCache(): Promise<void>;
+    updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
+    private addProjectListener;
+    private removeProjectListener;
+    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
+    onPreCompileOptionsChange: (data: any) => Promise<void>;
+    private invalidCodeCache;
+    private onProgressUpdate;
+    private getConf;
+    getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string): Promise<any>;
+    private getCode;
+    getExtJSON(): Promise<ExtJSON.IExtJSON>;
+    getAppJSON(): Promise<any>;
+    getGameJSON(): Promise<any>;
+    getSiteMapJSON(): Promise<any>;
+    getPageJSON(pagePath: string): Promise<any>;
+    getAllPageAndComponent(): Promise<string[]>;
+    getAllSortedJSFiles(): Promise<{
+        otherJsFiles: string[];
+        jsPagesFiles: string[];
+        components: string[];
+    }>;
+    getAllWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPackageWxmlAndWxsFiles(packagePath: string): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPackageWxssFiles(packagePath: string): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getWxssMap(graphId: MiniProgramDevtools.GraphId, wxssPath: string): string | import("../../types").MiniProgramSummer.SourceMap | undefined;
+    getMainPkgSortedJSFiles(): Promise<{
+        hasAppJS: boolean;
+        allFiles: string[];
+        pageFiles: string[];
+        functionalPageFiles: string[];
+        workerFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    getSubPkgSortedJSFiles(rootPath: string): Promise<{
+        allFiles: string[];
+        pageFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    compileJS(options: {
+        root: string;
+        filePath: string;
+        babelRoot: string;
+        sourceCode?: string;
+        setting: MiniProgramDevtools.IProjectSetting;
+    }): Promise<{
+        isLargeFile?: boolean | undefined;
+        isBabelIgnore?: boolean | undefined;
+        helpers?: string[] | undefined;
+        filePath: string;
+        code: string;
+        map: string | import("../../types").MiniProgramSummer.SourceMap | undefined;
+    }>;
+    compile(options: MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.ICompileResult>;
+    getPluginJSON(localPath?: string): Promise<any>;
+    getPluginPageJSON(pagePath: string): Promise<any>;
+    getPluginComponents(): Promise<string[]>;
+    getPluginJSFiles(): Promise<{
+        jsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPluginWxssFiles(): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPluginWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    checkThemeJSON(options: {
+        themeLocation: string;
+        isPlugin?: boolean;
+    }): Promise<any>;
+    setProxy(proxyUrl: string): void;
+    setLocale(locale: string): void;
+    uglifyFileNames(project: MiniProgramDevtools.IDevtoolsProject, result: Record<string, string | Buffer>, nameMapping: Record<string, string>): Promise<MiniProgramCore.IAnyObject>;
+    getMPFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    getPluginFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    getCompAndPagesOfConf(): Promise<{
+        pages: Record<string, any>;
+        comps: Record<string, any>;
+    }>;
+}

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

@@ -0,0 +1,18 @@
+import { MiniProgramCore } from '../types';
+import { SummerCompiler, ICompilerStatus } from './corecompiler/summerCompiler';
+export declare class SummerCompilerFactory {
+    summerCompiler: SummerCompiler | null;
+    private project;
+    private createPromise;
+    summerCompilerStatus: ICompilerStatus | undefined;
+    private releaseCbs;
+    getSummerCompiler(project: MiniProgramCore.IPreCompileProject): Promise<SummerCompiler>;
+    private shouldCreate;
+    private releaseLastCompiler;
+    private ensureCacheDir;
+    private createSummerCompiler;
+    private getFileFilter;
+    private getSummerOptions;
+}
+export declare const summerCompilerFactory: SummerCompilerFactory;
+export declare const getSummerCompiler: (project: MiniProgramCore.IPreCompileProject) => Promise<SummerCompiler>;

package/dist/@types/modules/fullcompiler/app/app.d.ts

@@ -0,0 +1,74 @@
+import { AppJSON, BaseInfo } from '../../../types';
+interface IStandaloneAppJson {
+    miniModuleId: string;
+    nickname: string;
+    device_orientation: string;
+    appVersion: string | number;
+    pkgInfos: Array<{
+        miniModuleId: string;
+        pkgType: number;
+        appVersion: number;
+        versionType: number;
+        moduleName?: string;
+        pkgMd5: string;
+        assetPath: string;
+        signVersion: number;
+        signFilePath: string;
+    }>;
+    contactBase64: string;
+    launchBase64: string;
+    cpfWxaAttrSyncResponse: string;
+    version: number;
+    devtoolsLocalServerUrl?: string;
+    remoteDebugWsEndpoint?: string;
+    miniappPkgType: IMiniappPkgType;
+}
+export interface IPkgModule {
+    name: string;
+    filePath: string;
+    pkgType: number;
+    md5: string;
+    size: number;
+    independent: boolean;
+    page_count: number;
+    alias: string[];
+    wxacode_lib_info_list: string[];
+    without_lib_md5: string;
+    separated_plugin_list: string[];
+    md5_list: string[];
+    widget_list: [];
+    buildVersion?: number;
+    signVersion?: number;
+    signFilePath?: string;
+}
+declare enum IMiniappPkgType {
+    'Release' = "Release",
+    'Debug' = "Debug",
+    'HotReload' = "HotReload"
+}
+export interface ISubPkg {
+    file: string;
+    type: number;
+    name: string;
+    signVersion: number;
+    signFile: string;
+    md5: string;
+    versionType?: IMiniappPkgType;
+}
+export declare function packAllPackagesToWxapkg(distPath: string, appJson: AppJSON.IAppJSON, appid: string): Promise<{
+    wholePkgMd5: string;
+    moduleListConfig: IPkgModule[];
+}>;
+interface ISubPackageAppInfo {
+    miniModuleId: string;
+    nickName: string;
+    brandIconURL: string;
+    pageOrientation: BaseInfo.PageOrientation;
+    buildVersion: number;
+    subpkgs: ISubPkg[];
+    contact: string;
+    cpfWxaAttrSyncResponse: string;
+    miniappPkgType: IMiniappPkgType;
+}
+export declare function generateSubPkgAppInfoJson(data: ISubPackageAppInfo): Promise<IStandaloneAppJson>;
+export {};

package/dist/@types/modules/fullcompiler/app/contactandlaunch/originalcontactbase64.d.ts

@@ -0,0 +1,2 @@
+declare const originalContactBase64 = "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";
+export default originalContactBase64;