miniprogram-ci 2.1.33 → 2.1.34

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    isFileIgnored: (file: string, ignoreRule: any, includeRule?: any) => any;
+    isFileIncluded: (file: string, ignoreRule: any, includeRule?: any) => any;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/getallrawfiles.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: string[];
+    errMsg?: undefined;
+} | {
+    success: boolean;
+    errMsg: any;
+    content: Map<any, any>;
+}>;

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/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/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/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/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<{}>;
+}

package/dist/@types/services/fs/server/fileService.d.ts

@@ -0,0 +1,27 @@
+import { Stats } from 'fs';
+import { IBuilderFileServiceContext, IFileService, IReadFileOptions, IFileList } from '../common/fileService';
+export declare class BuilderFileService implements IFileService {
+    private cache;
+    private getSessionId;
+    private getCacheKey;
+    private getValidCache;
+    private setCache;
+    private updateCacheWithContent;
+    private getCachedFileContent;
+    private getCachedFiles;
+    private fetchFileList;
+    private fetchFileContent;
+    readFile(filePath: string, options: IReadFileOptions | undefined, ctx: IBuilderFileServiceContext): Promise<Buffer | string>;
+    readFileList(filePaths: string[], ctx: IBuilderFileServiceContext): Promise<Record<string, string>>;
+    exists(filePath: string, ctx: IBuilderFileServiceContext): Promise<boolean>;
+    lstat(filePath: string, ctx: IBuilderFileServiceContext): Promise<Stats>;
+    fileList(ctx: IBuilderFileServiceContext): Promise<IFileList>;
+    preloadAllFiles(ctx: IBuilderFileServiceContext): Promise<{
+        success: boolean;
+        fileCount: number;
+        duration: number;
+    }>;
+    private handleEncoding;
+    private createEmptyStats;
+    private createStatsObject;
+}

package/dist/@types/services/genTempFile/server/genTempFileService.d.ts

@@ -0,0 +1,3 @@
+import { nodeGenTempFile } from '../common/genTempFile.node';
+export declare class GenTempFileService extends nodeGenTempFile {
+}

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

@@ -0,0 +1,6 @@
+import { IGlobalService } from '../common/global';
+export declare class ServerGlobalService implements IGlobalService {
+    isDev(): boolean;
+    getAppVersion(): Promise<string>;
+    showBuildLog2(): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+import { EInitializeSteps, EInitializeStepsStatus, IInitializeCheck } from '../common/initializeCheck';
+export declare class ServerInitializeCheck implements IInitializeCheck {
+    notifiedStatus(step: EInitializeSteps, status: EInitializeStepsStatus): void;
+}

package/dist/@types/services/locales/server/const.d.ts

@@ -0,0 +1,5 @@
+declare const formatConfig: any;
+declare const _default: {
+    readonly config: typeof formatConfig;
+};
+export default _default;

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

@@ -0,0 +1,5 @@
+import { ILocalesService } from '../common/locales';
+export declare class ServerLocalesService implements ILocalesService {
+    getLocale(): {};
+    getLocales(): Record<string, any>;
+}

package/dist/@types/services/log/server/logService.d.ts

@@ -0,0 +1,9 @@
+import { ILogService } from '~/services/log/common/logService';
+export declare class ServerLogService implements ILogService {
+    error(...args: any): void;
+    info(...args: any): void;
+    warn(...args: any): void;
+    log(...args: any): void;
+    debug(...args: any): void;
+    context(context: string, consoleObj?: Omit<ILogService, 'context'>): this;
+}

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

@@ -0,0 +1,4 @@
+import { IMiniappJson } from '../common/miniappjson';
+export declare class ServerMiniappJson implements IMiniappJson {
+    isMiniAppProject(): boolean;
+}

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

@@ -0,0 +1,5 @@
+import { MiniProgramCore } from "~/types";
+import { IMultiTaskManagerService } from "../common/multiTaskManager";
+export declare class ServerMultiTaskManagerService implements IMultiTaskManagerService {
+    runTask(taskName: string, data: any, onStatusUpdate: MiniProgramCore.FN<void>): Promise<any>;
+}

package/dist/@types/services/multiTaskManager/server/pm2TaskWorker.d.ts

@@ -0,0 +1 @@
+export declare function callMainProcess(funcName: string, ...args: any[]): Promise<any>;