miniprogram-ci 2.1.31 → 2.1.33

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

@@ -0,0 +1,3 @@
+import { IPipeContext, IPipeDefinition } from '../../types';
+export declare function getPageframeCore(context: IPipeContext, isMultiPkg?: boolean): Promise<string>;
+export declare const pageframePipe: IPipeDefinition;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appdevserver/getAppService.d.ts

@@ -0,0 +1,6 @@
+import { IPipeContext } from '../../../types';
+export declare function getInitJS(mainContentScript: string[]): void;
+export declare function getJSCodeBuild(context: IPipeContext, mainContentScript: string[], hasAppJS: boolean, pageFiles: string[], componentFiles: string[], functionalPageFiles: string[], otherFiles: string[], allFiles: string[]): Promise<void>;
+export declare function getBabelCodeByName(context: IPipeContext, modName: string): Promise<string>;
+export declare function getBabelHelperAndDepsCode(context: IPipeContext, babelHelpers: any): Promise<Map<any, any>>;
+export declare function getAppCode(context: IPipeContext, mainContentScript: string[], wxmlXCJS: any, componentFiles: string[], pageFiles: string[]): Promise<void>;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appdevserver/getwxappcode.d.ts

@@ -0,0 +1,9 @@
+import { IPipeContext } from '../../../types';
+interface IGetWxAppCodeOptions {
+    app?: boolean;
+    page?: string;
+    noJson?: boolean;
+    noWXSS?: boolean;
+}
+export declare function getPageFrameWxAppCode(context: IPipeContext, options?: IGetWxAppCodeOptions): Promise<string>;
+export {};

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getjsfile.d.ts

@@ -0,0 +1,12 @@
+import { RawSourceMap } from 'source-map';
+import { IPipeContext } from '../../../types';
+declare function getJsFile(context: IPipeContext, fileName: string, options?: {
+    injectHelpers?: boolean;
+    injectHelpersSync?: boolean;
+}): Promise<{
+    code: string;
+    helpers: string[];
+    map: RawSourceMap | undefined;
+    mtime: number | undefined;
+}>;
+export = getJsFile;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getmainpkgsortedjsfiles.d.ts

@@ -0,0 +1,11 @@
+import { IPipeContext } from '../../../types';
+declare const getMainPkgSortedJSFiles: (context: IPipeContext) => Promise<{
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    functionalPageFiles: string[];
+    workerFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+}>;
+export = getMainPkgSortedJSFiles;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getwxappcode.d.ts

@@ -0,0 +1,8 @@
+import { IPipeContext } from '../../../types';
+declare function getWxAppCode(context: IPipeContext, requireDirectly?: boolean): Promise<any>;
+declare function getWxAppCodeOfPage(context: IPipeContext, pathName: string, genFnName: string, requireDirectly?: boolean): Promise<string>;
+declare const _default: {
+    getWxAppCode: typeof getWxAppCode;
+    getWxAppCodeOfPage: typeof getWxAppCodeOfPage;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/common/apperrcode.config.d.ts

@@ -0,0 +1,92 @@
+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;
+    CHECK_UPLOAD_STATUS_ERR: number;
+    CLEAR_SESSION_ERR: number;
+    GAME_CODE_LIB_MD5_ERR: number;
+    LOAD_QRCODE_OTHER_ERR: number;
+    JUMP_QCLOUD_PAGE_ERR: number;
+    PACK_NPM_ERR: number;
+    GET_PROJECT_CONFIG_ERR: number;
+    MINI_PROGRAM_CONSUME_TIMING: number;
+    MINI_GAME_CONSUME_TIMING: number;
+    UPLOAD_PROGRESS_FAIIL: number;
+    UPLOAD_PLUGIN_ERR: number;
+    UPLOAD_FAIILED: number;
+    COMPILE_CONDITION_APPID_ERR: number;
+    COMPILE_CONDITION_PROGRAM_ERR: number;
+    COMPILE_CONDITION_ERR: number;
+    COMPILE_CONDITION_ERR_WITH_DETAIL: number;
+    WIDGET_GET_SEARCH_QUERY_ERROR: number;
+    QCLOUD_CHOOSE_ENVIRONMENT_ERROR: number;
+    QCLOUD_UPLOAD_FAIL: number;
+    TOOLBAR_REMOTE_DEBUG_ERROR: number;
+    PREPROCESS_UPLOAD_ERROR: number;
+    DOWNLOAD_SOURCEMAP_ERROR: number;
+    SOURCEMAP_WRITE_ERROR: number;
+    CLEAN_USER_AUTH_ERROR: number;
+    JUMP_WXGIT_ERROR: number;
+    TCB_DELETE_FAILED: number;
+    FETCH_REMOTE_SETTING_ERROR: number;
+    UPLOAD_LOCAL_SETTING_ERROR: number;
+    UPLOAD_SOURCE_CODE_ERROR: number;
+    UPLOAD_EXCEED_SIZE_LIMIT: number;
+    PROJECT_CONFIG_JSON_ERROR: number;
+    TEST_CODE_RUN_ERROR: number;
+    AUTO_UPLOAD_ERROR: number;
+    CLOUD_UPLOAD_OPEN_ERROR: number;
+    CLOUD_BUILD_OPEN_ERROR: number;
+    WEBVIEW_NETWORK_ERROR: number;
+    APPSERVICE_NETWORK_ERROR: number;
+    PLUGIN_ERROR: number;
+    ONLINE_CODE_UNPACK_ERR: number;
+    URL_SCHEME_INVALID_ERROR: number;
+    URL_SCHEME_OTHER_ERROR: number;
+    APP_UPGRADE_ERROR: number;
+    APP_ADD_AUTHO_PAGE_ERROR: number;
+};
+export = appErrCode;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/common/tools.d.ts

@@ -0,0 +1 @@
+export declare function wrapCodeByEval(code: string): string;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/appconfig.d.ts

@@ -0,0 +1,6 @@
+import { IPipeContext } from '../../../types';
+declare function getAppConfig(context: IPipeContext, forceDarkMode?: boolean): Promise<DR<AppConfig.IAppConfig>>;
+declare const _default: {
+    getAppConfig: typeof getAppConfig;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/appjson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare const getCompiledAppJSON: (context: IPipeContext) => Promise<any>;
+export = getCompiledAppJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/customcomponent.d.ts

@@ -0,0 +1,21 @@
+import { IPipeContext } from '../../../types';
+interface IComponentsConfigReturn {
+    [p: string]: {
+        file: string;
+        config: DR<AppConfig.ISubpackageItem> | undefined;
+        pageJSON: IPageJSON;
+    };
+}
+declare function getFileListJustInPack(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare function getWxssCompileConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare function getWxmlCompileConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<any[]>;
+declare function getWxmlCompileLazyConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare const _default: {
+    getFileListJustInPack: typeof getFileListJustInPack;
+    getWxssCompileConfig: typeof getWxssCompileConfig;
+    getWxmlCompileConfig: typeof getWxmlCompileConfig;
+    getWxmlCompileLazyConfig: typeof getWxmlCompileLazyConfig;
+    getCustomComponentsConfig: (context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>) => Promise<IComponentsConfigReturn>;
+    findSubpackageForFile: (file: string, appConfig: DR<AppConfig.IAppConfig>) => DR<AppConfig.ISubpackageItem> | undefined;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/helper/theme.d.ts

@@ -0,0 +1,40 @@
+import { PipeCPProject } from '../../../../pipeCPProject';
+export declare function checkTabbarListItemIconPath(prefix: string, absolutePath: string, project: PipeCPProject): any[];
+export declare function checkThemeRules(projectPath: string, project?: PipeCPProject): {
+    windowConfigRules: ({
+        key: string;
+        valids: string[];
+        hexColor?: undefined;
+    } | {
+        key: string;
+        hexColor: boolean;
+        valids?: undefined;
+    })[];
+    tabbarRules: ({
+        key: string;
+        hexColor: boolean;
+        valids?: undefined;
+    } | {
+        key: string;
+        valids: string[];
+        hexColor?: undefined;
+    })[];
+    tabbarListItemRules: {
+        key: string;
+        validate: (key: string, value: string) => void;
+    }[];
+};
+export declare function getDefaultWindowConfig(isDarkMode: boolean): {
+    backgroundColor: string;
+    backgroundTextStyle: string;
+};
+export declare function checkVariables(options: {
+    isDarkMode: boolean;
+    themeLocation: string;
+    filePath: string;
+    windowConfig: IStringKeyMap;
+    themeJSON: IStringKeyMap;
+    rules: any[];
+    keyPrefix: string;
+    isPlugin?: boolean;
+}): void;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/pagejson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare const getCompiledPageJSON: (context: IPipeContext, pagePath: string) => Promise<any>;
+export = getCompiledPageJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/wxappcodejson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare function getWXAppCodeJSON(context: IPipeContext, pagePath: string): Promise<any>;
+export = getWXAppCodeJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/trans/transwxmltojs.d.ts

@@ -0,0 +1,19 @@
+import { IPipeContext } from '../../../types';
+interface ITransWxmlOptions {
+    app?: boolean;
+    page?: string;
+    cut?: boolean;
+    hotReloadFile?: string;
+}
+interface IWXMLReturn {
+    name: string;
+    comm?: string;
+    code: string;
+    names?: AnyObject;
+    pages?: AnyObject;
+}
+declare function transWXMLToJS(context: IPipeContext, options?: ITransWxmlOptions): Promise<IWXMLReturn>;
+declare const _default: {
+    transWXMLToJS: typeof transWXMLToJS;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/trans/transwxsstojs.d.ts

@@ -0,0 +1,15 @@
+import { IPipeContext } from '../../../types';
+interface ITransWxssOptions {
+    app?: boolean;
+    page?: string;
+    hotReloadFile?: string;
+}
+interface IWxssReturn {
+    comm: string;
+    page?: string;
+}
+declare function transWXSSToJS(context: IPipeContext, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare const _default: {
+    transWXSSToJS: typeof transWXSSToJS;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/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/modules/corecompiler/summer/pipeManager/pipes/wccPipe.d.ts

@@ -0,0 +1,3 @@
+import { ICompileWxmlOptions } from '~/services/compilewxml/common/compilewxmlService';
+import { IPipeDefinition } from '../types';
+export declare const wccPipe: IPipeDefinition<ICompileWxmlOptions>;

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

@@ -0,0 +1,100 @@
+import { ICompileResult, ICompileWxmlOptions, ICompileWxmlToGlassEasel, IGlassEaselCompileResult } from '~/services/compilewxml/common/compilewxmlService';
+import { ICompileWxssOptions, ICompileWxssResult } from '~/services/compilewxss/common/compilewxssService';
+import { vsbase } from '../../../../services/common/vsbase';
+import { MiniProgramCore } from '../../../../types';
+import { PipeCPProject } from './pipeCPProject';
+import type { IBackendContextFromWeb } from '~/types/type';
+type ServiceIdentifier<T> = vsbase.vs.platform.instantiation.common.instantiation.$types.ServiceIdentifier<T>;
+export declare enum EPipeCMD {
+    WCC = "WCC",
+    TRANS_WXML_TO_GLASS_EASEL = "TRANS_WXML_TO_GLASS_EASEL",
+    COMPILE_WXSS = "COMPILE_WXSS",
+    PAGEFRAME = "PAGEFRAME",
+    PAGE_INIT_SOURCE = "PAGE_INIT_SOURCE",
+    APPSERVICE = "APPSERVICE"
+}
+export interface IPipiInputOutputType<T, P> {
+    input: T;
+    output: P;
+}
+export type IPipeParamOutputTypeMap = {
+    [EPipeCMD.WCC]: IPipiInputOutputType<ICompileWxmlOptions, ICompileResult>;
+    [EPipeCMD.TRANS_WXML_TO_GLASS_EASEL]: IPipiInputOutputType<ICompileWxmlToGlassEasel, IGlassEaselCompileResult>;
+    [EPipeCMD.COMPILE_WXSS]: IPipiInputOutputType<ICompileWxssOptions, ICompileWxssResult>;
+    [EPipeCMD.PAGEFRAME]: IPipiInputOutputType<{
+        isMultiPkg?: boolean;
+    }, string>;
+    [EPipeCMD.PAGE_INIT_SOURCE]: IPipiInputOutputType<{
+        filepath: string;
+    }, string>;
+    [EPipeCMD.APPSERVICE]: IPipiInputOutputType<Record<string, never>, string>;
+};
+export interface IPipeDefinition<TParams = any, TOutput = unknown> {
+    name: string;
+    timeout?: number;
+    execute(context: IPipeContext, params: TParams): Promise<TOutput>;
+}
+export interface IPipeContext {
+    requestPipe<T = unknown>(pipeName: string, params?: Record<string, unknown>): Promise<T>;
+    callCompiler<T = unknown>(method: string, ...args: unknown[]): Promise<T>;
+    project: PipeCPProject;
+    getService<T>(id: ServiceIdentifier<T>): T;
+}
+export interface IPipeProjectSerializeInfo {
+    appid: string;
+    attr: any;
+    type: MiniProgramCore.ProjectType;
+    projectPath: string;
+    projectArchitecture: MiniProgramCore.IProjectArchitecture;
+    miniprogramRoot: string;
+    pluginRoot: string;
+    setting: any;
+    backendProjectContext?: IBackendContextFromWeb;
+    projectContext?: {
+        projectId: string;
+        versionId: string;
+        ticket: string;
+        sessionId: string;
+    };
+}
+export type IPipeRequest = {
+    type: 'pipe';
+    requestId: string;
+    name: string;
+    params?: Record<string, unknown>;
+} | {
+    type: 'compiler';
+    requestId: string;
+    method: string;
+    args: unknown[];
+};
+export interface IPipeResponse {
+    requestId: string;
+    data?: any;
+    error?: {
+        code: number;
+        message: string;
+        stack: string;
+    };
+}
+export interface IPipeTaskData {
+    pipeName: string;
+    params?: Record<string, unknown>;
+    projectInfo: IPipeProjectSerializeInfo;
+}
+export interface IPipeTaskResult {
+    error?: any;
+    result?: any;
+}
+export interface IExecutePipeData {
+    pipeName: string;
+    params?: Record<string, unknown>;
+    backendProjectContext?: IBackendContextFromWeb;
+    projectContext?: {
+        projectId: string;
+        versionId: string;
+        ticket: string;
+        sessionId: string;
+    };
+}
+export {};

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

@@ -1,4 +1,3 @@
-/// <reference types="less" />
 import { MiniProgramCore, MiniProgramSummer } from '../../../../types';
 export declare const importWxssReg: RegExp;
 export declare const importWxssCssReg: RegExp;

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

@@ -1,5 +1,5 @@
 import { MiniProgramSummer } from '../../../../../types';
 export declare function doCompress(targetPath: string, target: Pick<MiniProgramSummer.GenerateDescription, 'code' | 'map'>): Promise<{
     code: string;
-    map: string | import("source-map").RawSourceMap | undefined;
+    map: string | import("@jridgewell/gen-mapping").EncodedSourceMap | undefined;
 }>;

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

@@ -19,7 +19,7 @@ export declare class Resolver {
     allExts: string[];
     constructor(graph: BaseGraph, root: string, extConf: ResolveExtConf);
     updateFileAndDirs(): void;
-    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string) => void;
+    onFileChange: (type: "unlink" | "unlinkDir" | "add" | "addDir" | "change", path: string) => void;
     resolve(source: string): ResolveFileInfo[];
     stat(path: string): IStat | undefined;
     private isCodeFile;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramDevtools, MiniProgramCore, ExtJSON } from '../../types';
 import { FileInfo } from './summer/graph/basegraph';
 import { EFilterCode } from '../../config/config';
@@ -6,6 +5,7 @@ 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;
@@ -24,27 +24,33 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     _status: MiniProgramDevtools.ICompilerStatus | undefined;
     private _eventAdded;
     private _locale;
+    private _initServiceForkId;
     private devCodeCacheByPath;
     constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub, analyzer: Analyzer | null, _filterFactory?: MiniProgramDevtools.IFilterFactory | undefined, onInitFinished?: ((e?: Error) => void) | undefined);
     get status(): MiniProgramDevtools.ICompilerStatus | undefined;
     protected init(): Promise<void>;
+    private initServiceAndLoadStatus;
+    private ensureInitService;
+    private safeRunTask;
     private loadStatus;
     destroy(): void;
     clearCache(): Promise<void>;
+    dumpWorkerTaskStats(): Promise<void>;
+    clearWorkerTaskStats(): Promise<void>;
     getProjectInfo(): MiniProgramDevtools.IDevtoolsProjectInfo;
     updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
     updateOptionsWithoutJudge(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
     updateOptionsWhenAttrNotChanged(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
     private addProjectListener;
     private removeProjectListener;
-    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
+    onFileChange: (type: "unlink" | "unlinkDir" | "add" | "addDir" | "change", targetPath: string) => void;
     onPreCompileOptionsChange: (data: any) => Promise<void>;
     private invalidCodeCache;
     private onProgressUpdate;
     private getConf;
     waitSubProcessReady(): Promise<void>;
     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[]>;
+    _getPackageFiles: (graphId: MiniProgramDevtools.GraphId, root: string, resultType?: MiniProgramCore.IResultType) => Promise<FileInfo[]>;
     private isMiniappPlatformInclude;
     filterUnusedFiles(isGame: boolean, abFilePath: string, resultType: MiniProgramCore.IResultType): Promise<EFilterCode>;
     private filterFactory;
@@ -156,4 +162,7 @@ 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/index.d.ts

@@ -32,7 +32,7 @@ export declare class Builder {
     private _originalCompiler;
     private _analyzer?;
     constructor(project: MiniProgramCI.IProject, opts: IBuilderOptions);
-    getCompiler(): Promise<any>;
+    getCompiler(): Promise<SummerCompiler>;
     getAnalyzer(): Promise<Analyzer | null>;
     getPreCompileProject(): Promise<PreCompileProject>;
     private _getPreCompileProject;

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

@@ -47,8 +47,8 @@ declare class buildCloudManager {
     copyResourcesToMainBundle(srcFrameworksPath: string, distFrameworkPath: string): void;
     prepareAppexProfileConfig(pluginDirList: IMiniApp.IIOSPluginDir[], iosMiniappJson: MiniProgramCore.IStringKeyMap, projectPath: string, miniappCacheDirPath: string, isPublish: boolean, CFBundleVersion: string, CFBundleShortVersionString: string, recorder: Recorder): false | {
         [appexName: string]: {
-            profilePath?: string | undefined;
-            bundleID?: string | undefined;
+            profilePath?: string;
+            bundleID?: string;
             enable: boolean;
         };
     } | undefined;

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

@@ -1,5 +1,5 @@
 import { MiniProgramDevtools } from '../../types';
 export declare function initHandler(message: MiniProgramDevtools.InitMsg): Promise<void>;
 export declare function destroy(): Promise<void>;
-export declare const onMessage: (fn: (...args: any[]) => any) => void;
+export declare const onMessage: (fn: (...args: any[]) => any) => Promise<void>;
 export declare function messageHandler(message: MiniProgramDevtools.SummerProcessMessage): Promise<void>;

package/dist/@types/modules/precompiler/conditioncompile/compiler/base.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore } from '../../../../types';
 import { PLATFORM } from '../../../../config/define';
 import { MacroDefine } from '../define';

package/dist/@types/modules/precompiler/conditioncompile/compiler/json.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MacroDefine } from '../define';
 import { BaseConditionCompiler } from './base';
 export declare class JSONConditionCompiler extends BaseConditionCompiler {

package/dist/@types/modules/precompiler/conditioncompile/compiler/macro.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore } from '../../../../types';
 import { MacroDefine } from '../define';
 import { BaseConditionCompiler } from './base';

package/dist/@types/modules/precompiler/conditioncompile/compiler/plant.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MacroDefine } from '../define';
 import { BaseConditionCompiler } from './base';
 export declare class PlantConditionCompiler extends BaseConditionCompiler {
@@ -6,5 +5,5 @@ export declare class PlantConditionCompiler extends BaseConditionCompiler {
         filePath: string;
         content: Buffer;
         macroDefine: MacroDefine;
-    }): Buffer;
+    }): Buffer<ArrayBufferLike>;
 }

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCI, MiniProgramCore } from '../../../types';
 import { BaseConditionCompiler } from './compiler/base';
 import { IConsoleDisplay, IMessageHub } from '../../../utils/messageHub';
@@ -18,7 +17,7 @@ export declare class ConditionCompiler {
     shouldCompile(filePath: string): boolean;
     compileFile(filePath: string, opts?: IConditionCompiler): Buffer;
     compileProject(opts?: IConditionCompiler): {
-        [key: string]: Buffer;
+        [key: string]: Buffer<ArrayBufferLike>;
     };
     filterResourceByPlatfrom(opts?: MiniProgramCore.IConditionCompileInfo): string[];
 }

package/dist/@types/project/advance/precompileProject.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore, MiniProgramDevtools, MiniProgramSummer, MiniProgramCI } from '../../types';
 import { BaseProject } from '../baseProject';
 import { ConditionCompiler } from '../../modules/precompiler/index';
@@ -26,7 +25,7 @@ export declare class PreCompileProject extends BaseProject implements MiniProgra
     get srcPath(): string;
     attr(): Promise<MiniProgramCI.IProjectAttr>;
     serialize(): Promise<MiniProgramCore.IPrecompileProjectSerializeInfo>;
-    getSrcFile(prefix: string | undefined, filePath: string): Buffer;
+    getSrcFile(prefix: string | undefined, filePath: string): Buffer<ArrayBufferLike>;
     getFile(prefix: string | undefined, filePath: string): Buffer;
     onFileChange: (type: MiniProgramCore.IWatchEventType, targetPath: string) => Promise<void>;
     notifyRefreshFileOrDirs(oldFiles: string[]): void;

package/dist/@types/project/advance/reactiveProject.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore } from '../../types';
 import { BaseProject } from '../baseProject';
 export declare class ReactiveProject extends BaseProject implements MiniProgramCore.IPreCompileProject {
@@ -32,7 +31,7 @@ export declare class ReactiveProject extends BaseProject implements MiniProgramC
         dirs: string[];
     };
     getExtAppid(): Promise<string | void>;
-    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => Promise<void>;
+    onFileChange: (type: "unlink" | "unlinkDir" | "add" | "addDir" | "change", targetPath: string) => Promise<void>;
     getFile(prefix: string, filePath: string): Buffer;
     stat(prefix: string, filePath: string): import("../../types").MiniProgramCI.IStat | undefined;
     attrSync(): import("../../types").MiniProgramCI.IProjectAttr;

package/dist/@types/project/baseProject.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore, MiniProgramDevtools, MiniProgramSummer, ProjectConfigJSON } from '../types';
 import WaitAble from '../utils/waitable';
 type FileChange = (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
@@ -29,6 +28,7 @@ export declare abstract class BaseProject extends WaitAble implements MiniProgra
     protected _fileSet: Set<string>;
     event: ProjectEventEmitter;
     get projectPath(): string;
+    get projectpath(): string;
     get injectedPages(): string[];
     get projectArchitecture(): import("../types").MiniProgramCI.IProjectArchitecture;
     get srcPath(): string;
@@ -47,7 +47,7 @@ export declare abstract class BaseProject extends WaitAble implements MiniProgra
     set nameMappingFromDevtools(mapping: MiniProgramCore.IStringKeyMap<string> | undefined);
     attr(): Promise<any>;
     ready(): Promise<void>;
-    protected getProjectType(attr: any, compileType: MiniProgramCore.ProjectType): import("../types").MiniProgramCI.ProjectType;
+    protected getProjectType(attr: any, compileType: MiniProgramCore.ProjectType): MiniProgramCore.ProjectType;
     getProjectConfig(): ProjectConfigJSON.IProjectConfigJSON;
     normalizeRootPath: (pathName?: string) => string;
     serialize(): Promise<MiniProgramCore.IProjectSerializeInfo>;
@@ -63,8 +63,9 @@ export declare abstract class BaseProject extends WaitAble implements MiniProgra
         dirs: string[];
     };
     exists(prefix?: string, filePath?: string): boolean;
+    statAsync(prefix?: string, filePath?: string): Promise<MiniProgramCore.IStat | undefined>;
     stat(prefix?: string, filePath?: string): MiniProgramCore.IStat | undefined;
-    getAllFileInfo(prefix?: string): MiniProgramCore.IFileInfos;
+    getAllFileInfo(prefix?: string): Promise<MiniProgramCore.IFileInfos>;
     getFileList(prefix?: string, extName?: string): string[];
     getSrcFile(prefix: string, filePath: string): Buffer;
     getFile(prefix: string, filePath: string): Buffer;

package/dist/@types/project/ciProjectWithMockBuffer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MiniProgramCore } from '../types';
 import { CIProject } from './ciProject';
 type IStat = MiniProgramCore.IStat;

package/dist/@types/services/accountcard/accountcard.d.ts

@@ -0,0 +1,18 @@
+export interface IAccountCardResources {
+    js: string;
+    wxss: string;
+    json: string;
+    wxml: string;
+    prependjs?: string;
+}
+export type ICardType = {
+    type: number;
+    displayName: string;
+};
+export interface IAccountCardService {
+    init: () => Promise<void>;
+    refresh: () => void;
+    getAvailableAccountCardTypes: () => ICardType[];
+    getAccountCardResources: (type: number) => IAccountCardResources;
+}
+export declare const IAccountCardService: import("../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IAccountCardService>;