miniprogram-ci 2.1.32 → 2.1.34

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

@@ -0,0 +1,11 @@
+import { MiniProgramCore } from '../../types';
+import { SummerCompiler } from '../corecompiler/summerCompiler';
+export default function (project: MiniProgramCore.IPreCompileProject, compiler: SummerCompiler): Promise<{
+    success: boolean;
+    content: Map<string, string>;
+    errMsg?: undefined;
+} | {
+    success: boolean;
+    errMsg: any;
+    content: Map<any, any>;
+}>;

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

@@ -0,0 +1,31 @@
+import { MiniProgramCore } from '../../types';
+import { SummerCompiler } from '../corecompiler/summerCompiler';
+import { IMiniappConnectType, IMiniappPkgType, ISubPkg } from './app/app';
+export declare function checkProjectOKForWeb(_project: MiniProgramCore.IPreCompileProject): boolean;
+interface IFullCompilerOpts {
+    summerCompiler: SummerCompiler;
+    outputDir?: string;
+}
+interface IComplileOpts {
+    outputDir?: string;
+    genWxapkg?: boolean;
+    genAppInfo?: boolean;
+}
+export declare class FullCompiler {
+    project: MiniProgramCore.IPreCompileProject;
+    summerCompiler: SummerCompiler;
+    outputDir?: string;
+    constructor(project: MiniProgramCore.IPreCompileProject, opts: IFullCompilerOpts);
+    compileFull(opts?: IComplileOpts): Promise<string>;
+    compileMulti(opts?: IComplileOpts): Promise<string>;
+    genSubPkgAppInfo(miniModuleId: string, subpkgs: ISubPkg[], outputJsonPath: string, buildVersion: number, contact: string, cpfWxaAttrSyncResponse: string, miniappPkgType: IMiniappPkgType, devtoolsLocalServerUrl?: string, remoteDebugConfig?: {
+        remoteDebugWsEndpoint?: string;
+        androidRemoteConfigForUSB?: {
+            appClientPortForotReloadServer: string;
+            appClientPortForRemoteDebugServer: string;
+            devtoolHotReloadServerPort: string;
+            devtoolRemoteDebugServerPort: string;
+        };
+    }, miniappConnectType?: IMiniappConnectType): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { AppJSON, MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+interface IGetPageFrameCoreOpts {
+    subpkgConfig: AppJSON.ISubpackageItem;
+}
+export default function getPageFrame(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, opts: IGetPageFrameCoreOpts): Promise<{
+    success: boolean;
+    content: any;
+}>;
+export {};

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

@@ -0,0 +1,13 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+export declare function getWxAppCodeWxmlOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pageName: string, genFnName: string): Promise<string[]>;
+export declare function getWxAppCodeWxssOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pageName: string): Promise<string[]>;
+export declare function getWxAppCodeJsonOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pageName: string): Promise<string[]>;
+interface IGetWxAppCodeOptions {
+    app?: boolean;
+    page?: string;
+    noJson?: boolean;
+    noWXSS?: boolean;
+}
+export declare function getPageFrameWxAppCode(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options?: IGetWxAppCodeOptions): Promise<string>;
+export {};

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

@@ -0,0 +1,10 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+interface IGetPageFrameCoreOpts {
+    multi: boolean;
+}
+export default function getPageFrame(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, opts: IGetPageFrameCoreOpts): Promise<{
+    success: boolean;
+    content: any;
+}>;
+export {};

package/dist/@types/modules/fullcompiler/trans/transwxmltojs.d.ts

@@ -0,0 +1,11 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+interface ITransWxmlOptions {
+    app?: boolean;
+    page?: string;
+}
+export declare function transWXMLToJS(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options: ITransWxmlOptions): Promise<{
+    code: string;
+    name: string;
+}>;
+export {};

package/dist/@types/modules/fullcompiler/trans/transwxsstojs.d.ts

@@ -0,0 +1,21 @@
+import { AppJSON, MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+interface ITransWxssOptions {
+    app?: boolean;
+    page?: string;
+}
+interface ITransWxssInnerOptions {
+    appConfig: AppJSON.IAppConfig;
+    config?: AppJSON.ISubpackageItem;
+    lazyload?: boolean;
+}
+interface IWxssReturn {
+    comm: string;
+    page?: string;
+}
+export declare function getWxssFilesAndContent(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options: ITransWxssInnerOptions): Promise<{
+    wxssFiles: string[];
+    content: Record<string, string>;
+}>;
+export declare function transWXSSToJS(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options?: ITransWxssOptions): Promise<IWxssReturn>;
+export {};

package/dist/@types/modules/fullcompiler/trans/wxml/compilewxml.d.ts

@@ -0,0 +1,18 @@
+interface ICompileWxmlOptions {
+    files: string[];
+    configContent: string;
+    configSplit: string;
+    isCut: boolean;
+    cwd: string;
+    genfuncName: string;
+    hasWxs?: boolean;
+    isPlugin?: boolean;
+    lazyloadConfig?: string;
+    replaceContent?: Record<string, string>;
+}
+interface INormalResult {
+    code: string;
+    name: string;
+}
+export declare function compileWxml(options: ICompileWxmlOptions): Promise<INormalResult>;
+export {};

package/dist/@types/modules/fullcompiler/trans/wxss/compilewxss.d.ts

@@ -0,0 +1,11 @@
+interface ICompileWxssOptions {
+    files: string[];
+    pageCount: number;
+    cwd: string;
+    lazyload?: boolean;
+    subPackage?: string;
+    replaceContent?: Record<string, string>;
+}
+type ICompileWxssResult = Record<string, string>;
+export declare function compileWxss(options: ICompileWxssOptions): Promise<ICompileWxssResult>;
+export {};

package/dist/@types/modules/fullcompiler/utils/appconfig/appconfig.d.ts

@@ -0,0 +1,12 @@
+import { AppJSON, MiniProgramCore } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+declare function checkLightAppConfig(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, cloneDeep?: boolean): Promise<AppJSON.IAppConfig>;
+declare function checkDarkmodeAppConfig(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, cloneDeep?: boolean): Promise<AppJSON.IAppConfig>;
+declare const _default: {
+    checkLightAppConfig: typeof checkLightAppConfig;
+    checkDarkmodeAppConfig: typeof checkDarkmodeAppConfig;
+    getAppConfig: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, cloneDeep?: boolean) => Promise<AppJSON.IAppConfig>;
+    checkIsInSubPackage: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pagePath: string) => Promise<AppJSON.ISubpackageItem | undefined>;
+    DealSubPackages: (appconfig: AppJSON.IAppConfig) => AppJSON.IAppConfig;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/utils/appconfig/appjson.d.ts

@@ -0,0 +1,3 @@
+import { MiniProgramCore } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+export default function getCompiledAppJSON(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler): Promise<any>;

package/dist/@types/modules/fullcompiler/utils/appconfig/checkcustomcomponent.d.ts

@@ -0,0 +1,14 @@
+import { AppJSON, MiniProgramCore, PageJSON } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+export declare function getWxmlCompileConfig(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, appConfig: AppJSON.IAppConfig, config?: AppJSON.ISubpackageItem): Promise<any[]>;
+export declare function getWxssCompileConfig(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, appConfig: AppJSON.IAppConfig, config?: AppJSON.ISubpackageItem): Promise<string[]>;
+export declare function getFileListJustInPack(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, appConfig: AppJSON.IAppConfig, config?: AppJSON.ISubpackageItem): Promise<string[]>;
+interface IComponentsConfigReturn {
+    [p: string]: {
+        file: string;
+        config: AppJSON.ISubpackageItem | undefined;
+        pageJSON: PageJSON.IPageJSON;
+    };
+}
+export declare function getCustomComponentsConfig(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, appConfig: AppJSON.IAppConfig): Promise<IComponentsConfigReturn>;
+export {};

package/dist/@types/modules/fullcompiler/utils/appconfig/pagejson.d.ts

@@ -0,0 +1,3 @@
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../../types';
+export default function getCompiledPageJSON(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pagePath: string): Promise<any>;

package/dist/@types/modules/fullcompiler/utils/appconfig/wxappcodejson.d.ts

@@ -0,0 +1,3 @@
+import { MiniProgramCore } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+export default function getWXAppCodeJSON(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pagePath: string): Promise<any>;

package/dist/@types/modules/fullcompiler/utils/filewriter/index.d.ts

@@ -0,0 +1,14 @@
+interface FileWriterOptions {
+    dist: string;
+    projectPath: string;
+    clearDist?: boolean;
+}
+declare class FileWriter {
+    projectPath: string;
+    dist: string;
+    constructor(options: FileWriterOptions);
+    getFinalPath(p: string): string;
+    writeFile(dist: string, content: string): void;
+    copyFile(dist: string, distPrefix?: string): void;
+}
+export default FileWriter;

package/dist/@types/modules/fullcompiler/utils/handleerror/errorconfig.d.ts

@@ -0,0 +1,9 @@
+export declare const 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;
+};

package/dist/@types/modules/fullcompiler/utils/handleerror/handleerror.d.ts

@@ -0,0 +1,3 @@
+import { IProject } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+export declare function handleError(project: IProject, compiler: SummerCompiler, e: any, shouldDisplay?: boolean): Promise<any>;

package/dist/@types/modules/fullcompiler/utils/handleerror/parseerr.d.ts

@@ -0,0 +1,42 @@
+import { IProject } from '../../../../types';
+import { SummerCompiler } from '../../../corecompiler/summerCompiler';
+interface IParseErrorInfo {
+    file: string;
+    msg: string;
+    reason?: string;
+}
+declare const _default: {
+    parseWXMLRuntimeErr: (project: IProject, compiler: SummerCompiler, event: {
+        message: string;
+    }) => Promise<{
+        file: string;
+        msg: string;
+    }>;
+    parseJsonFileErr: (event: {
+        file: string;
+    }) => {
+        file: string;
+        msg: string;
+    };
+    parseJsonParseErr: (project: IProject, event: {
+        fileName: string;
+        data: string;
+        error: string;
+        isPlugin?: boolean;
+    }) => string;
+    parsePluginWxmlErr: (project: IProject, compiler: SummerCompiler, err: string) => Promise<{
+        file: string;
+        msg: string;
+    }>;
+    parsePluginWxssErr: (project: IProject, compiler: SummerCompiler, data: string | {
+        msgForConsole: string;
+    }) => Promise<IParseErrorInfo>;
+    parseWxmlErr: (project: IProject, compiler: SummerCompiler, err: string) => Promise<{
+        file: string;
+        msg: string;
+    }>;
+    parseWxssErr: (project: IProject, compiler: SummerCompiler, data: string | {
+        msgForConsole: string;
+    }) => Promise<IParseErrorInfo>;
+};
+export = _default;

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

@@ -0,0 +1,4 @@
+import { AppJSON } from '../../../types';
+export declare function flatSubPackage(oldAppJSON: AppJSON.IAppJSON): false | AppJSON.IAppJSON;
+export declare function wrapCodeByEval(code: string): string;
+export declare function escapeByEval(code: string): string;

package/dist/@types/modules/fullcompiler/utils/taskmanager.d.ts

@@ -0,0 +1,23 @@
+interface ITaskProps {
+    poolLimit?: number;
+    breakWhenError?: boolean;
+}
+declare class TaskManager<R = any> {
+    private static _instance;
+    private _tasks;
+    private poolLimit;
+    private isRuning;
+    private taskPool;
+    private breakWhenError;
+    constructor(props?: ITaskProps);
+    static get shared(): TaskManager<any>;
+    addTask(task: () => R | Promise<R>): void;
+    addTask<A0, A extends any[]>(task: (arg0: A0, ...args: A) => R | Promise<R>, arg0: A0): void;
+    addTask<A0, A1, A extends any[]>(task: (arg0: A0, arg1: A1, ...args: A) => R | Promise<R>, arg0: A0, arg1: A1): void;
+    addTask<A0, A1, A2, A extends any[]>(task: (arg0: A0, arg1: A1, arg2: A2, ...args: A) => R | Promise<R>, arg0: A0, arg1: A1, arg2: A2): void;
+    addTask<A0, A1, A2, A3, A extends any[]>(task: (arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R | Promise<R>, arg0: A0, arg1: A1, arg2: A2, arg3: A3): void;
+    addTask<A0, A1, A2, A3, A4, A extends any[]>(task: (arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, ...args: A) => R | Promise<R>, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4): void;
+    runAllAsync(poolLimit?: number): Promise<R[]>;
+    runAllSerial(): Promise<R[]>;
+}
+export = TaskManager;

package/dist/@types/modules/fullcompiler/utils/theme/index.d.ts

@@ -0,0 +1,40 @@
+import { MiniProgramCore } from '../../../../types';
+export declare function checkTabbarListItemIconPath(prefix: string, absolutePath: string): string[];
+export declare function checkThemeRules(projectPath: string): {
+    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: MiniProgramCore.IStringKeyMap;
+    themeJSON: MiniProgramCore.IStringKeyMap;
+    rules: any[];
+    keyPrefix: string;
+    isPlugin?: boolean;
+}): void;

package/dist/@types/modules/fullcompiler/utils/tools.d.ts

@@ -0,0 +1,15 @@
+import { AppJSON, MiniProgramDevtools } from '../../../types';
+export declare function checkIsInSubPackage(appConfig: Readonly<AppJSON.IAppConfig>, pathName?: string): undefined | AppJSON.ISubpackageItem;
+export declare function checkPluginByAliasOrProvider(appConfig: Readonly<AppJSON.IAppConfig>, aliasOrProvider: string): {
+    alias: string;
+    provider: string;
+    version: string;
+    config?: AppJSON.ISubpackageItem;
+} | undefined;
+export declare function getPluginByAliasOrProvider(plugins: {
+    [alias: string]: MiniProgramDevtools.IPluginInfo;
+} | undefined, aliasOrProvider: string): {
+    alias: string;
+    provider: string;
+    version: string;
+} | undefined;

package/dist/@types/modules/fullcompiler/utils/transformsourcemap.d.ts

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

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/precompiler/conditioncompile/compiler/plant.d.ts

@@ -5,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

@@ -17,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

@@ -25,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/baseProject.d.ts

@@ -28,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;

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

@@ -0,0 +1,38 @@
+import { MiniProgramCore, MiniProgramDevtools, ProjectConfigJSON } from '../types';
+import { BaseProject } from './baseProject';
+type ProjectType = MiniProgramCore.ProjectType;
+export interface ICreateProjectOptions {
+    projectPath: string;
+    type: ProjectType;
+    appid: string;
+    ignores?: string[];
+    targetPlatform?: MiniProgramCore.ITargetPlatform;
+    compileDefines?: {
+        [key: string]: string;
+    };
+    packOptions?: {
+        ignore: MiniProgramDevtools.IProjectConfigPackOption[];
+        include: MiniProgramDevtools.IProjectConfigPackOption[];
+    };
+}
+export declare class ServerProject extends BaseProject {
+    private _project;
+    targetPlatform?: MiniProgramCore.ITargetPlatform;
+    private fileUtils;
+    private _preloadFileCache;
+    constructor(options: ICreateProjectOptions);
+    init(options: ICreateProjectOptions): Promise<void>;
+    initPreloadFileCache(): Promise<void>;
+    get project(): BaseProject;
+    existsAsync(prefix?: string, filePath?: string): Promise<boolean>;
+    exists(prefix?: string, filePath?: string): boolean;
+    getFile(prefix: string, filePath: string): Buffer;
+    statAsync(prefix?: string, filePath?: string): Promise<MiniProgramCore.IStat | undefined>;
+    stat(prefix?: string, filePath?: string): MiniProgramCore.IStat | undefined;
+    getProjectConfig(): Promise<ProjectConfigJSON.IProjectConfigJSON>;
+    updateFileAndDirs(): Promise<void>;
+    getExtAppid(): Promise<string | void>;
+    isMiniappProject(): boolean;
+    serialize(): Promise<MiniProgramCore.IPrecompileProjectSerializeInfo>;
+}
+export {};

package/dist/@types/services/app/ci/appDirService.d.ts

@@ -0,0 +1,6 @@
+import { IAppDirService, IDirConfig } from '../common/appDirService';
+export declare class CIAppDirService implements IAppDirService {
+    init(): Promise<IDirConfig>;
+    get<T extends keyof IDirConfig>(dirType: T): Promise<IDirConfig[T]>;
+    cleanDir(dirType: keyof IDirConfig): Promise<void>;
+}

package/dist/@types/services/app/server/appDirService.d.ts

@@ -0,0 +1,6 @@
+import { IAppDirService, IDirConfig } from '../common/appDirService';
+export declare class ServerAppDirDevtoolsService implements IAppDirService {
+    init(): Promise<IDirConfig>;
+    get<T extends keyof IDirConfig>(dirType: T): Promise<IDirConfig[T]>;
+    cleanDir(dirType: keyof IDirConfig): Promise<void>;
+}

package/dist/@types/services/builder/server/builder.d.ts

@@ -0,0 +1,4 @@
+import { IBuilder } from '../common/builder';
+import { NWBuilder } from '../nw/builder';
+export declare class ServerBuilder extends NWBuilder implements IBuilder {
+}

package/dist/@types/services/common/getservice.d.ts

@@ -3,7 +3,8 @@ export declare enum EServiceEnviroment {
     ELECTRON = "ELECTRON",
     SERVER = "SERVER",
     NW = "NW",
-    NODE = "NODE"
+    CI = "CI",
+    WEBIDE = "WEBIDE"
 }
 type ServiceIdentifier<T> = vsbase.vs.platform.instantiation.common.instantiation.$types.ServiceIdentifier<T>;
 interface IDevtoolsServiceOptions {
@@ -18,7 +19,9 @@ interface IDevtoolsServiceOptions {
 }
 interface INodeServiceOptions {
 }
-export declare function initServices(env: EServiceEnviroment.NODE | EServiceEnviroment.SERVER, serviceOptions: INodeServiceOptions, getVsBaseBundleFunc?: () => any): Promise<void>;
-export declare function initServices(env: EServiceEnviroment.NW | EServiceEnviroment.ELECTRON, serviceOptions: IDevtoolsServiceOptions, getVsBaseBundleFunc?: () => any): Promise<void>;
+export declare function initServices(env: EServiceEnviroment.CI | EServiceEnviroment.SERVER, serviceOptions: INodeServiceOptions, getVsBaseBundleFunc?: () => any): void;
+export declare function initServices(env: EServiceEnviroment.NW | EServiceEnviroment.ELECTRON, serviceOptions: IDevtoolsServiceOptions, getVsBaseBundleFunc?: () => any): void;
+export declare function getServicesEnv(): EServiceEnviroment.CI;
+export declare function initServicesByEnv(): void;
 declare const _default: <T>(id: ServiceIdentifier<T>) => T;
 export default _default;

package/dist/@types/services/compileCacheManager/common/compileCacheManager.d.ts

@@ -0,0 +1,23 @@
+import { ICompileResult } from '~/build-server/type';
+import { IFileList } from '~/services/fs/common/fileService';
+export interface ICompileCacheManagerService {
+    set: (key: string, value: string | Record<string, any>) => void;
+    get: (key: string) => any;
+    clear: (ket: string) => void;
+    clearBatch: (keys: string[]) => Promise<number>;
+    reporter: {
+        hitCache: (key: string) => void;
+        startGenCache: (key: string) => void;
+        finishGenCache: (key: string) => void;
+        hitFileCache: (filePath: string) => void;
+        startGenFileCache: (filePath: string) => void;
+        finishGenFileCache: (filePath: string) => void;
+    };
+    generateFilePesistCacheKey(project: IProject, otherSeeds: any[]): Promise<string>;
+    setFile(filePath: string, value: any, infoKey: string): Promise<void>;
+    getFile(projectpath: string, filePath: string, infoKey: string, useEngineIDE?: boolean): Promise<ICompileResult | undefined>;
+    removeFile(filePath: string, infoKey: string): Promise<void>;
+    getFileList(key?: string): Promise<IFileList | undefined>;
+    setFileList(fileList: IFileList): Promise<void>;
+}
+export declare const ICompileCacheManagerService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<ICompileCacheManagerService>;

package/dist/@types/services/compileCacheManager/nw/compileCacheManager.d.ts

@@ -0,0 +1,16 @@
+import { ICompileCacheManagerService } from '../common/compileCacheManager';
+import { ICompileResult } from '~/build-server/type';
+import { IFileList } from '~/services/fs/common/fileService';
+export declare class NWCompileCacheManagerService implements ICompileCacheManagerService {
+    reporter: any;
+    get: (key: string) => any;
+    set: (key: string, value: any) => void;
+    generateFilePesistCacheKey: (project: IProject, otherSeeds: any[]) => Promise<string>;
+    getFile: (projectpath: string, filePath: string, infoKey: string, useEngineIDE?: boolean) => Promise<ICompileResult | undefined>;
+    setFile: (filePath: string, value: any, infoKey: string) => Promise<void>;
+    removeFile(filePath: string, infoKey: string): Promise<void>;
+    clear(key: string): Promise<void>;
+    getFileList(key?: string): Promise<IFileList | []>;
+    setFileList(fileList: IFileList): Promise<void>;
+    clearBatch: (keys: string[]) => Promise<number>;
+}

package/dist/@types/services/compileCacheManager/server/compileCacheManager.d.ts

@@ -0,0 +1,26 @@
+import { ICompileCacheManagerService } from '../common/compileCacheManager';
+import { ICompileResult } from '~/build-server/type';
+import { IFileList } from '~/services/fs/common/fileService';
+export declare class ServerCompileCacheManagerService implements ICompileCacheManagerService {
+    private isUseCache;
+    reporter: {
+        hitCache: (key: string) => void;
+        startGenCache: (key: string) => void;
+        finishGenCache: (key: string) => void;
+        hitFileCache: (filePath: string) => void;
+        startGenFileCache: (filePath: string) => void;
+        finishGenFileCache: (filePath: string) => void;
+    };
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: string | Record<string, any>) => Promise<"OK" | null>;
+    generateFilePesistCacheKey: (project: IProject, otherSeeds: any[]) => Promise<string>;
+    getFile: (projectpath: string, filePath: string, infoKey?: string, useEngineIDE?: boolean) => Promise<ICompileResult | undefined>;
+    setFile: (filePath: string, value: ICompileResult, infoKey?: string) => Promise<void>;
+    clear: (key: string) => Promise<"OK" | null>;
+    clearBatch: (keys: string[]) => Promise<number>;
+    removeFile: (filePath: string, infoKey?: string) => Promise<void>;
+    setFileList: (fileList: IFileList) => Promise<void>;
+    getFileList: (key?: string) => Promise<IFileList | undefined>;
+    copyCache: (sourceProjectCacheKey: string, targetProjectCacheKey: string) => Promise<boolean>;
+    getProjectCacheKey(projectId?: string, versionId?: string): string | null;
+}

package/dist/@types/services/compilewxml/common/compilewxmlService.d.ts

@@ -3,8 +3,8 @@ export interface IGlassEaselCompileResult {
     wxmlDependencies: Record<string, string[]>;
     scriptResult: string;
     runtimeString: string;
-    runtimeGlobal: string;
-    gdcContent: string;
+    runtimeGlobal?: string;
+    gdcContent?: string;
     wxsEnvContent: string;
 }
 export interface ICompileWxmlToGlassEasel {

package/dist/@types/services/compilewxml/node/compileglasseasel.d.ts

@@ -0,0 +1,14 @@
+declare const _default: (content: {
+    wxmlParserPath: string;
+    tempCompileConfigFilePath: string;
+    wxmlAndWxsFiles: Record<string, string>;
+    glassEaselTemplateCompilerPath: string;
+}) => Promise<{
+    templateResults: Record<string, string>;
+    wxmlDependencies: Record<string, string[]>;
+    scriptResult: string;
+    runtimeString: string;
+    runtimeGlobals: string;
+    wxsEnvContent: string;
+}>;
+export = _default;

package/dist/@types/services/compilewxml/server/compilewxmlService.d.ts

@@ -0,0 +1,5 @@
+import { ICompileWxmlOptions, ICompileResult, ICompilewxmlService, ICompileWxmlToGlassEasel, IGlassEaselCompileResult } from '../common/compilewxmlService';
+export declare class ServerCompilewxmlService implements ICompilewxmlService {
+    compileWxml(options: ICompileWxmlOptions): Promise<ICompileResult>;
+    compileWxmlToGlassEasel(options: ICompileWxmlToGlassEasel): Promise<IGlassEaselCompileResult>;
+}

package/dist/@types/services/compilewxml/server/wccWorker.d.ts

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

package/dist/@types/services/compilewxss/server/compilewxssService.d.ts

@@ -0,0 +1,4 @@
+import { ICompileWxssOptions, ICompileWxssResult, ICompilewxssService } from '../common/compilewxssService';
+export declare class ServerCompilewxssService implements ICompilewxssService {
+    compileWxss(options: ICompileWxssOptions): Promise<ICompileWxssResult>;
+}

package/dist/@types/services/compilewxss/server/wcscWorker.d.ts

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

package/dist/@types/services/consoledisplay/server/consoledisplay.d.ts

@@ -0,0 +1,4 @@
+import { IConsoleDisplayService } from '../common/consoledisplay';
+export declare class ServerConsoleDisplayService implements IConsoleDisplayService {
+    display(): void;
+}

package/dist/@types/services/fileUtilsManager/server/fileUtilsManager.d.ts

@@ -0,0 +1,4 @@
+import { IFileUtilsManagerService } from '../common/fileUtilsManager';
+export declare class ServerFileUtilsManagerService implements IFileUtilsManagerService {
+    projectFileUtils(projectPath: string, options: Record<string, any>): Promise<{}>;
+}