miniprogram-ci 2.1.33 → 2.1.34

package/dist/@types/build-server/tasks/common/utils/tracing/Trace.d.ts

@@ -0,0 +1,50 @@
+export interface IEvent {
+    name: string;
+    cat: string;
+    ph: string;
+    ts: number;
+    pid: number;
+    tid: number;
+    args: any;
+    [key: string]: any;
+}
+export default class Trace {
+    private _processes;
+    constructor(events?: IEvent[]);
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    getProcess(id: number): Process;
+    rmProcess(id: number): void;
+    processes(): Process[];
+    toJSON(): IEvent[];
+}
+declare class Process {
+    private _id;
+    private _name;
+    private _threads;
+    private _metadata;
+    constructor(id: number);
+    id(): number;
+    name(): string;
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    getThread(id: number): Thread;
+    rmThread(id: number): void;
+    threads(): Thread[];
+    toJSON(): IEvent[];
+}
+declare class Thread {
+    private _id;
+    private _pid;
+    private _name;
+    private _events;
+    private _metadata;
+    constructor(id: number, pid: number);
+    id(): number;
+    name(): string;
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    events(): IEvent[];
+    toJSON(): IEvent[];
+}
+export {};

package/dist/@types/build-server/tasks/common/utils/tracing/aegis.d.ts

@@ -0,0 +1,3 @@
+export declare function error(message: string): void;
+export declare function info(message: string): void;
+export declare function reportTime(name: string, duration: number): void;

package/dist/@types/build-server/tasks/common/utils/tracing/index.d.ts

@@ -0,0 +1,34 @@
+declare class Tracing {
+    private pid;
+    private tid;
+    private processName;
+    private threadName;
+    private traceEventStack?;
+    private targetCat?;
+    private traceEventMap?;
+    private _trace?;
+    constructor({ pid, tid, processName, threadName, }?: {
+        pid?: number | undefined;
+        tid?: number | undefined;
+        processName?: string | undefined;
+        threadName?: string | undefined;
+    });
+    start(cat?: string): void;
+    stop(action?: (args: any) => void): import("./Trace").IEvent[] | undefined;
+    metadata(name: string, args: any, extra: any): void;
+    complete(cat: string, name: string, begin: number, end: number, args?: any): void;
+    begin(cat: string, name: string, args?: any): void;
+    end(args?: any): void;
+    asyncBegin(cat: string, name: string, id?: string, args?: {}, extra?: any): string;
+    asyncEnd(id: string, args?: {}): void;
+    instant(cat: string, name: string, scope?: string, args?: any): void;
+    traceAsyncFn<T extends FN>(asyncFn: T, cat: string, name: string, args?: any): T;
+    traceFn<T extends FN>(fn: T, cat: string, name: string, args?: any): T;
+    traceAsyncMethod(cat: string, name?: string, args?: any): (target: AnyObject, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    traceMethod(cat: string, name?: string, args?: any): (target: AnyObject, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    id(): string;
+    _addEvent(cat: string, name: string, ph: string, args?: {}, extra?: {}): void;
+    getCurTs(): number;
+}
+declare const tracing: Tracing;
+export default tracing;

package/dist/@types/build-server/tasks/common/utils/tracing/readiness.d.ts

@@ -0,0 +1,11 @@
+declare class Readiness {
+    private promises;
+    private resolves;
+    private states;
+    signal(tasks: string | string[]): void;
+    isReady(tasks: string | string[]): boolean;
+    ready(tasks: string | string[], fn?: FN): Promise<any>;
+    private getPromises;
+}
+declare const _default: Readiness;
+export default _default;

package/dist/@types/build-server/tasks/common/utils/tracing/report.d.ts

@@ -0,0 +1,14 @@
+declare class Report {
+    private reportStack;
+    private reportMap;
+    constructor();
+    complete(cat: string, name: string, dur: number): void;
+    begin(cat: string, name: string): void;
+    end(): void;
+    asyncBegin(cat: string, name: string, id: string, ts?: number): void;
+    asyncEnd(id: string): void;
+    private needToReport;
+    private report;
+}
+declare const _default: Report;
+export default _default;

package/dist/@types/build-server/tasks/common/utils/trans/transwxmltojs.d.ts

@@ -0,0 +1,28 @@
+import { IGlassEaselCompileResult } from '~/services/compilewxml/common/compilewxmlService';
+interface ITransWxmlOptions {
+    app?: boolean;
+    page?: string;
+    cut?: boolean;
+    hotReloadFile?: string;
+}
+interface IWXMLReturn {
+    name: string;
+    comm?: string;
+    code: string;
+    names?: AnyObject;
+    pages?: AnyObject;
+}
+type ITransWXMLResult = IWXMLReturn & {
+    glassEasel?: IGlassEaselCompileResult & {
+        commonTemplateResults: Record<string, string>;
+    };
+};
+declare function transWXMLToJS(project: IProject, options?: ITransWxmlOptions): Promise<IWXMLReturn>;
+declare function getWxmlJSOfComponent(project: IProject, options: ITransWxmlOptions): Promise<ITransWXMLResult>;
+declare function transWXMLToJSWithGlassEaselLazyload(project: IProject, options?: ITransWxmlOptions): Promise<ITransWXMLResult>;
+declare const _default: {
+    transWXMLToJS: typeof transWXMLToJS;
+    transWXMLToJSLazyload: typeof transWXMLToJSWithGlassEaselLazyload;
+    getWxmlJSOfComponent: typeof getWxmlJSOfComponent;
+};
+export = _default;

package/dist/@types/build-server/tasks/common/utils/transformsourcemap.d.ts

@@ -0,0 +1 @@
+export declare function transformSourceMapSources(sources?: Array<string | null> | undefined | null): Array<string | null>;

package/dist/@types/build-server/tasks/common/utils/web/glasseaselUtils.d.ts

@@ -0,0 +1 @@
+export declare const checkIsUseGlassEasel: (project: IProject) => Promise<boolean>;

package/dist/@types/build-server/tasks/common/utils/web/md5.d.ts

@@ -0,0 +1,2 @@
+import crypto = require('crypto');
+export declare function generateMD5(string: crypto.BinaryLike): string;

package/dist/@types/build-server/tasks/common/utils/web/processPath.d.ts

@@ -0,0 +1,9 @@
+interface INormalizePathOptions {
+    leading?: string;
+    noLeading?: string;
+    trailing?: string;
+    noTrailing?: string;
+}
+export declare function normalizePath(pathName?: string, options?: INormalizePathOptions): string;
+export declare function isLeftSubPathOfRight(child: string, parent: string): boolean;
+export {};

package/dist/@types/build-server/tasks/common/weapp.config.d.ts

@@ -0,0 +1,108 @@
+declare const c: {
+    readonly setting: any;
+    MAX_PAGE_STACK_DEPTH: number;
+    DEFAULT_NAVIGATIONBAR_WHITE_TEXTCOLOR: string;
+    DEFAULT_NAVIGATIONBAR_BLACK_TEXTCOLOR: string;
+    DEFAULT_NAVIGATIONBAR_BGCOLOR: string;
+    default_tabBarBorderBlackColor: string;
+    default_tabBarBorderWhiteColor: string;
+    default_backgroundColor: string;
+    default_android_singlepage_foot_height: number;
+    default_ios_singlepage_foot_height: number;
+    default_android_tabbar_height: number;
+    default_ios_tabbar_height: number;
+    default_android_navigationbar_height: number;
+    default_ios_navigationbar_height: number;
+    default_statusbar_height: number;
+    default_search_widget_radio: number;
+    default_conversation_widget_radio: number;
+    default_titlebar_height: number;
+    NO_BOM_VAR: string[];
+    readonly whiteFileExtName: {
+        [key: string]: boolean;
+    };
+    readonly gameWhiteFileExtName: {
+        [key: string]: boolean;
+    };
+    errorPrefix: {
+        COMPONENT_FOR_DEVELOPER: string;
+        WXML_RUNTIME_ERROR: string;
+        WXML_RUNTIME_ERROR_REG: RegExp;
+        WXML_PLUGIN_RUNTIME_ERROR_REG: RegExp;
+        WXS_RUNTIME_ERROR: string;
+        WEBVIEW_ERROR: string;
+        CODE_ERROR: string;
+    };
+    weappURLRegular: RegExp;
+    weappASURLRegular: RegExp;
+    weappLocalIdRegular: RegExp;
+    weappEditorServiceRegular: RegExp;
+    weappPluginServiceRegular: RegExp;
+    weappGamePageRegular: RegExp;
+    weappTraceRegular: RegExp;
+    weappSCFDebugRegular: RegExp;
+    weappSCFLongPollRegular: RegExp;
+    SCENE_DEFAULT: number;
+    SCENE_SINGLE_SHARE: number;
+    SCENE_GROUP_SHARE: number;
+    SCENE_PROFILE: number;
+    SCENE_CUSTOM_MENU: number;
+    SCENE_APP_SHARE_MESSAGE: number;
+    SCENE_MINI_PROGRAM: number;
+    SCENE_MINI_PROGRAM_BACK: number;
+    SCENE_TEMPLETE_MESSAGE: number;
+    SCENE_SHARE_TICKET: number;
+    SCENE_MOBILE_APPLICATION: number;
+    SCENE_GEOGRAPHIC_INFO: number;
+    SCENE_GROUP_TOOLBAR: number;
+    SCENE_GROUP_UPCOMING: number;
+    SCENE_CHAT_MATERIAL: number;
+    SCENE_H5_OPEN: number;
+    SCENE_SINGLE_MODE_OPEN: number;
+    APP_TYPE: {
+        NORMAL: number;
+        PLUGIN: number;
+        SHOP: number;
+        MINISHOP: number;
+        GAME: number;
+        CARD: number;
+        NATIVE: number;
+    };
+    DEBUGGER_FILE: {
+        AS_SUB_LOADER: string;
+        WORKER: string;
+        WORKER_AS_DEBUG: string;
+        SUB_AS_DEBUG: string;
+        AS_DEBUG: string;
+    };
+    DEFAULT_ATTR_INFO: {
+        network: {
+            RequestDomain: never[];
+            WsRequestDomain: never[];
+            UploadDomain: never[];
+            DownloadDomain: never[];
+            UDPDomain: never[];
+            TCPDomain: never[];
+            BizDomain: never[];
+        };
+        appImageUrl: string;
+        appName: string;
+        appType: number;
+        minPublicLibVersion: string;
+        platform: boolean;
+        released: boolean;
+        gameApp: boolean;
+        isSandbox: boolean;
+        hasMobile: boolean;
+        adminName: string;
+        sendQbaseConfirmMsgLimit: boolean;
+        share_info: never[];
+        isExtAppId: boolean;
+        authQY: boolean;
+        permissionBitset: string;
+        userbanded: boolean;
+        username: string;
+        readonly setting: any;
+    };
+};
+export = c;

package/dist/@types/build-server/tasks/pageInitSourceCompile/index.d.ts

@@ -0,0 +1,2 @@
+export declare const getPageInitResource: (project: any, filepath: string) => Promise<string>;
+export declare const getPageInitResourceCore: (project: any, filepath: string) => Promise<string>;

package/dist/@types/build-server/tasks/pageframeCompile/index.d.ts

@@ -0,0 +1 @@
+export declare function getPageframeCore(project: IBackendProject, isMultiPkg?: boolean): Promise<string>;

package/dist/@types/build-server/tasks/pageframeCompile/utils/appdevserver/getwxappcode.d.ts

@@ -0,0 +1,8 @@
+interface IGetWxAppCodeOptions {
+    app?: boolean;
+    page?: string;
+    noJson?: boolean;
+    noWXSS?: boolean;
+}
+export declare function getPageFrameWxAppCode(project: IProject, options?: IGetWxAppCodeOptions): Promise<string>;
+export {};

package/dist/@types/build-server/tasks/pageframeCompile/utils/trans/transwxsstojs.d.ts

@@ -0,0 +1,26 @@
+interface ITransWxssOptions {
+    app?: boolean;
+    page?: string;
+    hotReloadFile?: string;
+}
+interface ITransWxssInnerOptions {
+    appConfig: DR<AppConfig.IAppConfig>;
+    config?: DR<AppConfig.ISubpackageItem>;
+    lazyload?: boolean;
+}
+interface IWxssReturn {
+    comm: string;
+    page?: string;
+}
+declare function getWxssFilesAndContent(project: IProject, options: ITransWxssInnerOptions): Promise<{
+    wxssFiles: string[];
+    content: Record<string, string>;
+}>;
+declare function transWXSSToJS(project: IProject, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare function transWXSSToJSLazyload(project: IProject, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare const _default: {
+    transWXSSToJS: typeof transWXSSToJS;
+    transWXSSToJSLazyload: typeof transWXSSToJSLazyload;
+    getWxssFilesAndContent: typeof getWxssFilesAndContent;
+};
+export = _default;

package/dist/@types/build-server/testAppConfig.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testAppservice.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testInitSourceCompile.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testPageframe.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testSubProcess.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/@types/build-server/utils/fileTask.d.ts

@@ -0,0 +1,5 @@
+import { MiniProgramDevtools } from '../../types';
+import type { IBuildFileTaskQueue, IBuildFileTaskList } from '../type';
+import { ResolveFileInfo } from '../../modules/corecompiler/summer/resolver';
+export declare function getSummerTaskConfig(setting: MiniProgramDevtools.IProjectSetting): IBuildFileTaskQueue[];
+export declare function generateFileTaskList(fileList: ResolveFileInfo[], taskConfig: IBuildFileTaskQueue[]): IBuildFileTaskList;

package/dist/@types/build-server/utils/getFileOrCache.d.ts

@@ -0,0 +1,24 @@
+export declare const getFileContent: (data: {
+    ticket: string;
+    projectId: string;
+    snapshotId: string;
+    versionId: string;
+    filePath: string;
+}) => Promise<{
+    code: number;
+    data: string;
+}>;
+export declare const getFileOrCache: (data: {
+    ticket: string;
+    projectId: string;
+    snapshotId: string;
+    versionId: string;
+    fileTask: {
+        filePath: string;
+        taskLinks: string[];
+    };
+}) => Promise<{
+    code: number;
+    isCacheResult?: boolean;
+    data: string;
+}>;

package/dist/@types/build-server/utils/request.d.ts

@@ -0,0 +1,47 @@
+export declare const getFileContentHTTP: (data: {
+    ticket: string;
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    path: string | string[];
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        content: string;
+    }[];
+    message: string;
+}>;
+export declare const getProjectUpdateTimeHTTP: (data: {
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    ticket: string;
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        key: string;
+        lastModifiedTime: number;
+        size: number;
+        createTime: number;
+    }[];
+    message: string;
+}>;
+export declare const getProjectUpdateTimeContentHTTP: (data: {
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    ticket: string;
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        key: string;
+        lastModifiedTime: number;
+        size: number;
+        createTime: number;
+        content: string;
+    }[];
+    message: string;
+}>;

package/dist/@types/bussinessMonitor/monitor.d.ts

@@ -0,0 +1 @@
+export declare const BusinessReport: (module: string, action: string, data: string) => Promise<void>;

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

@@ -1,5 +1,5 @@
 import { IProject } from '../types';
-export declare const CI_VERSION = "2.1.33";
+export declare const CI_VERSION = "2.1.34";
 export declare const PARAM_ERROR = 10000;
 export declare const WXML_NOT_FOUND = 10007;
 export declare const JS_NOT_FOUND = 10008;

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

@@ -24,13 +24,11 @@ import MiniAppI18N from './utils/miniAppI18N';
 import * as MiniAppJson from './utils/miniappJson';
 import * as cosUpload from './utils/cosUpload';
 import { EServiceEnviroment, initServices } from './services/common/getservice';
-import { EPipeCMD, IPipeParamOutputTypeMap } from './modules/corecompiler/summer/pipeManager/types';
 export { Builder, SummerCompiler, DevtoolsProject, getSummerPluginConfig, getBabelHelperVersion, getBabelHelperDepMap, isValidHelperFunc, getHelperName, getHelperContent, getHelperOutputPath, getHelperDeps, packOptionsHelper, PackOptionsHelper, initServices, };
 export declare const workletVersion: any;
 export { EServiceEnviroment, };
 export { EFilterCode };
 export { BaseProject, WebProject, PreCompileProject, CIProject as Project, CIProject, };
-export { EPipeCMD, IPipeParamOutputTypeMap, };
 export { BaseCoreCompiler, OriginalCompiler, ICompilerStatus, ICompileOptions, };
 export * from './modules/corecompiler/original';
 export { getWhiteExtList, proxy, locales, isHexColor, DefaultProjectAttr, JSON_CONTENT_ERR, compileTypeConfig, generateMD5, mkdirSync, normalizePath, compareVersion, checkIsInSubPackage, escapeQuot, escapeScript, cosUpload, };

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

@@ -1,5 +1 @@
-import { Recorder } from '../../../../../utils/progressRecorder';
-import { IPipeRequest } from '../../../summer/pipeManager/types';
 export declare function readFileAsync(filePath: string, options: any): Promise<unknown>;
-export declare function setPipeIPCHandler(handler: (req: IPipeRequest, recorder: Recorder) => Promise<any>): void;
-export declare function handlePipeIPC(req: IPipeRequest): Promise<any>;

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

@@ -5,7 +5,6 @@ import { SubProcessProxy } from '../../utils/subprocess/processManager';
 import { IMessageHub } from '../../utils/messageHub';
 import { BaseCoreCompiler } from './baseCompiler';
 import { Analyzer } from '../../common/code-analyse';
-import { EPipeCMD, IExecutePipeData, IPipeParamOutputTypeMap } from './summer/pipeManager/types';
 export { ICompilerStatus } from './summer/summer';
 export declare class SummerCompiler extends BaseCoreCompiler {
     project: MiniProgramCore.IPreCompileProject;
@@ -162,7 +161,4 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         file: string;
         code: number;
     }[]>;
-    executePipe<T extends EPipeCMD.WCC | EPipeCMD.TRANS_WXML_TO_GLASS_EASEL | EPipeCMD.COMPILE_WXSS>(pipeName: T, params: IPipeParamOutputTypeMap[T]['input']): Promise<IPipeParamOutputTypeMap[T]['output']>;
-    getPageframe(isMultiPkg: boolean | undefined, extra: Pick<IExecutePipeData, 'backendProjectContext' | 'projectContext'>): Promise<string>;
-    getAppservice(extra: Pick<IExecutePipeData, 'backendProjectContext' | 'projectContext'>): Promise<string>;
 }

package/dist/@types/modules/fullcompiler/appservice/appservice.config.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    noBrowser: string;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/appservice/generatecode.utils.d.ts

@@ -0,0 +1,12 @@
+import { RawSourceMap } from 'source-map';
+declare function inlineSourceMap(sourceCode: string, sourceMap?: string | RawSourceMap, sourceURL?: string): string;
+declare function inlineSourceMapFile(sourceCode: string, sourceMapPath?: string): string;
+declare function wrapSourceCodeInDefine(filename: string, sourceCode: string, inject?: string): string;
+declare function wrapGameSourceCodeInDefine(filename: string, sourceCode: string, inject?: string): string;
+declare const _default: {
+    inlineSourceMap: typeof inlineSourceMap;
+    inlineSourceMapFile: typeof inlineSourceMapFile;
+    wrapSourceCodeInDefine: typeof wrapSourceCodeInDefine;
+    wrapGameSourceCodeInDefine: typeof wrapGameSourceCodeInDefine;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/appservice/getappservice.d.ts

@@ -0,0 +1,9 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+export default function getAppService(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler): Promise<{
+    success: boolean;
+    content: any;
+}>;
+export declare function getBabelCodeByName(project: any, modName: string): Promise<string>;
+export declare function getBabelHelperAndDepsCode(project: any, babelHelpers: any): Promise<Map<any, any>>;
+export declare function getAppCode(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, mainContentScript: string[], wxmlXCJS: any, componentFiles: string[], pageFiles: string[]): Promise<void>;

package/dist/@types/modules/fullcompiler/appservice/getcompiledjs.d.ts

@@ -0,0 +1,32 @@
+import { RawSourceMap } from 'source-map';
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+export type CompileResultType = 'production' | 'dev';
+export interface ICompileResult {
+    map?: RawSourceMap;
+    mapString?: string;
+    basenameMapString?: string;
+    code: string;
+    helpers: MiniProgramCore.IStringKeyMap;
+    customTranslated: boolean;
+    isLargeFile: boolean;
+    needCompile: boolean;
+    isBabelIgnore: boolean;
+    filePath?: string;
+    fromCache?: boolean;
+    cacheKey?: string;
+    mtime?: number;
+}
+interface IGetCompiledJSOptions {
+    relativePath: string;
+    fileName: string;
+    resultType: CompileResultType;
+    nameMapping?: MiniProgramCore.IStringKeyMap;
+    type: 'game' | 'gamePlugin' | 'miniProgram' | 'miniProgramPlugin';
+    onAfterRun?: MiniProgramCore.FN<void>;
+    sourceCode?: string;
+    useEngineIDE?: boolean;
+}
+export declare const getCompiledJS: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options: IGetCompiledJSOptions) => Promise<ICompileResult>;
+export declare const compileMiniProgramJS: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, fileName: string) => Promise<ICompileResult>;
+export {};

package/dist/@types/modules/fullcompiler/appservice/getjsfile.d.ts

@@ -0,0 +1,18 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+import { ICompileResult } from './getcompiledjs';
+interface IGetJSFileOptions {
+    force?: boolean;
+    noWarnings?: boolean;
+    injectHelpers?: boolean;
+    injectHelpersSync?: boolean;
+    isGame?: boolean;
+    isWorkerFile?: boolean;
+    sourceURL?: string;
+    formatResult?: (result: ICompileResult) => ICompileResult;
+}
+declare function getJsFile(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, fileName: string, options?: IGetJSFileOptions): Promise<{
+    code: string;
+    helpers: string[];
+}>;
+export = getJsFile;

package/dist/@types/modules/fullcompiler/appservice/getmainpkgsortedjsfiles.d.ts

@@ -0,0 +1,12 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+declare const getMainPkgSortedJSFiles: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler) => Promise<{
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    functionalPageFiles: string[];
+    workerFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+}>;
+export = getMainPkgSortedJSFiles;

package/dist/@types/modules/fullcompiler/appservice/getsubpackage.d.ts

@@ -0,0 +1,7 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { AppJSON, MiniProgramCore } from '../../../types';
+export default function getSubpackageAppServiceBuild(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, subPackConfig: AppJSON.ISubpackageItem): Promise<{
+    success: boolean;
+    content: any;
+}>;
+export declare function getSubpackageAppServiceBuildCore(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, subPackConfig: AppJSON.ISubpackageItem): Promise<string>;

package/dist/@types/modules/fullcompiler/appservice/getsubpkgsortedjsfiles.d.ts

@@ -0,0 +1,10 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+declare const getSubPkgSortedJSFiles: (project: MiniProgramCore.IPreCompileProject, compiler: SummerCompiler, rootPath: string) => Promise<{
+    allFiles: string[];
+    pageFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+    extendedLibFiles: string[];
+}>;
+export = getSubPkgSortedJSFiles;

package/dist/@types/modules/fullcompiler/appservice/getwxappcode.d.ts

@@ -0,0 +1,13 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+declare function getWxAppCode(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, requireDirectly?: boolean): Promise<string>;
+declare function getWxAppCodeOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pathName: string, genFnName: string, requireDirectly?: boolean): Promise<string>;
+declare function getWxAppCodeJsonOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pathName: string): Promise<string>;
+declare function getWxAppCodeWxmlOfPage(project: MiniProgramCore.IPreCompileProject, pathName: string, wxmlGenFnName: string, requireDirectly?: boolean): string;
+declare const _default: {
+    getWxAppCode: typeof getWxAppCode;
+    getWxAppCodeOfPage: typeof getWxAppCodeOfPage;
+    getWxAppCodeJsonOfPage: typeof getWxAppCodeJsonOfPage;
+    getWxAppCodeWxmlOfPage: typeof getWxAppCodeWxmlOfPage;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/config/apperrcode.config.d.ts

@@ -0,0 +1,48 @@
+export declare const appErrCode: {
+    APP_JSON_READ_ERR: number;
+    APP_JSON_PARSE_ERR: number;
+    APP_JSON_PAGES_ERR: number;
+    APP_JSON_ENTRANCE_NOT_FOUND_ERR: number;
+    APP_JSON_CONTENT_ERR: number;
+    PAGES_JSON_PARSE_ERR: number;
+    APP_JSON_WXML_NOT_FOUND: number;
+    APP_JSON_JS_NOT_FOUND: number;
+    JSON_CONTENT_ERR: number;
+    EXT_JSON_PARSE_ERR: number;
+    EXT_JSON_PAGES_ERR: number;
+    EXT_JSON_CONTENT_ERR: number;
+    APPSERVICE_LOSE_WXML: number;
+    APPSERVICE_LOSE_JS: number;
+    FILE_NOT_UTF8: number;
+    BABEL_TRANS_JS_ERR: number;
+    UGLIFY_JS_ERR: number;
+    BABILI_JS_ERR: number;
+    JS_ES6_ERR: number;
+    FILE_FLAT_ERR: number;
+    POST_WXSS_ERR: number;
+    TRANS_WXML_JS_ERR: number;
+    TRANS_WXSS_JS_ERR: number;
+    SUMMER_PLUGIN_ERR: number;
+    SUMMER_PLUGIN_CODE_ERR: number;
+    VENDOR_MD5_NOT_MATCH: number;
+    VENDOR_WCC_FILE_NOT_FOUND: number;
+    VENDOR_WCSC_FILE_NOT_FOUND: number;
+    CODE_SIZE_EXCEED: number;
+    GET_GEO_LOCATION_ERR: number;
+    QCLOUD_SVR_NO_FOUND_ERR: number;
+    QCLOUD_SVR_POLL_TIMEOUT: number;
+    QCLOUD_SVR_POLL_DOING: number;
+    QCLOUD_SVR_UP_DIR_CHECK: number;
+    PLUGIN_JSON_READ_ERR: number;
+    PLUGIN_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_CONTENT_ERR: number;
+    PLUGIN_PAGE_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_FILE_NOT_FOUND: number;
+    PLUGIN_PAGE_JSON_CONTENT_ERR: number;
+    PLUGIN_TRANS_WXML_JS_ERR: number;
+    PLUGIN_TRANS_WXSS_JS_ERR: number;
+    PLUGIN_JS_ES6_ERR: number;
+    PLUGIN_ONLINE_CODE_UNPACK_ERR: number;
+    PAGE_JSON_PARSE_ERR: number;
+    SITE_MAP_JSON_CONTENT_ERROR: number;
+};