miniprogram-ci 2.1.32 → 2.1.33

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/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/summerCompiler.d.ts

@@ -5,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;
@@ -23,13 +24,19 @@ 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;
@@ -155,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/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/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/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/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/multiTaskManager/ci/multiTaskManager.d.ts

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

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

@@ -0,0 +1,5 @@
+import { MiniProgramCore } from '~/types';
+export interface IMultiTaskManagerService {
+    runTask(taskName: string, data: any, onStatusUpdate: MiniProgramCore.FN<void>): Promise<any>;
+}
+export declare const IMultiTaskManagerService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IMultiTaskManagerService>;

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

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

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

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

package/dist/@types/services/nativeModule/ci/nativeModule.d.ts

@@ -0,0 +1,3 @@
+import { nativeModuleImpl } from '../common/nativeModule.impl';
+export declare class CINativeModule extends nativeModuleImpl {
+}

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

@@ -3,7 +3,7 @@ export interface INativeModuleService {
     getWXMLParsePath: () => Promise<string>;
     setWXSSParsePath: (path: string) => Promise<void>;
     getWXSSParsePath: () => Promise<string>;
-    setGlassEaselLazyModulePath: (path: string) => Promise<void>;
-    getGlassEaselLazyModulePath: () => Promise<string>;
+    setGlassEaselTemplateCompilerPath: (path: string) => Promise<void>;
+    getGlassEaselTemplateCompilerPath: () => Promise<string>;
 }
 export declare const INativeModuleService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<INativeModuleService>;

package/dist/@types/services/nativeModule/common/nativeModule.impl.d.ts

@@ -3,10 +3,11 @@ export declare class nativeModuleImpl implements INativeModuleService {
     private _WXMLParsePath;
     private _WXSSParsePath;
     private _GlassEaselLazyModulePath;
+    private _GlassEaselTemplateCompilerPath;
     setWXMLParsePath(path: string): Promise<void>;
     getWXMLParsePath(): Promise<string>;
     setWXSSParsePath(path: string): Promise<void>;
     getWXSSParsePath(): Promise<string>;
-    setGlassEaselLazyModulePath(path: string): Promise<void>;
-    getGlassEaselLazyModulePath(): Promise<string>;
+    setGlassEaselTemplateCompilerPath(path: string): Promise<void>;
+    getGlassEaselTemplateCompilerPath(): Promise<string>;
 }

package/dist/@types/services/pluginFileReader/ci/pluginFileReader.d.ts

@@ -0,0 +1,3 @@
+import { BasePluginFileReaderService } from '../common/pluginFileReader.base';
+export declare class CIPluginFileReaderService extends BasePluginFileReaderService {
+}

package/dist/@types/services/pluginFileReader/common/pluginFileReader.base.d.ts

@@ -0,0 +1,9 @@
+import { MiniProgramCore } from '~/types';
+import { IPluginFileReaderService } from '~/services/pluginFileReader/common/pluginFileReader';
+export declare class BasePluginFileReaderService implements IPluginFileReaderService {
+    readFile(project: MiniProgramCore.IPreCompileProject, relativePath: string): string;
+    exists(project: MiniProgramCore.IPreCompileProject, basePath: string, fileName: string): boolean;
+    stat(project: MiniProgramCore.IPreCompileProject, relativePath: string): {
+        mtimeMs: number;
+    } | undefined;
+}

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

@@ -0,0 +1,12 @@
+import { PipeCPProject } from '~/modules/corecompiler/summer/pipeManager/pipeCPProject';
+import { MiniProgramCore } from '~/types';
+export interface IPluginFileReaderService {
+    readFile(project: MiniProgramCore.IPreCompileProject | PipeCPProject, relativePath: string): string | Promise<string>;
+    exists(project: MiniProgramCore.IPreCompileProject | PipeCPProject, basePath: string, fileName: string): boolean | Promise<boolean>;
+    stat(project: MiniProgramCore.IPreCompileProject | PipeCPProject, relativePath: string): {
+        mtimeMs: number;
+    } | undefined | Promise<{
+        mtimeMs: number;
+    } | undefined>;
+}
+export declare const IPluginFileReaderService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IPluginFileReaderService>;

package/dist/@types/services/pluginFileReader/electron/pluginFileReader.d.ts

@@ -0,0 +1,3 @@
+import { BasePluginFileReaderService } from '../common/pluginFileReader.base';
+export declare class ElectronPluginFileReaderService extends BasePluginFileReaderService {
+}

package/dist/@types/services/pluginFileReader/webide/pluginFileReader.d.ts

@@ -0,0 +1,9 @@
+import { MiniProgramCore } from '~/types';
+import { IPluginFileReaderService } from '~/services/pluginFileReader/common/pluginFileReader';
+export declare class WebIDEPluginFileReaderService implements IPluginFileReaderService {
+    readFile(project: MiniProgramCore.IPreCompileProject, relativePath: string): string;
+    exists(project: MiniProgramCore.IPreCompileProject, basePath: string, fileName: string): boolean;
+    stat(project: MiniProgramCore.IPreCompileProject, relativePath: string): {
+        mtimeMs: number;
+    } | undefined;
+}

package/dist/@types/services/root/ci/rootService.d.ts

@@ -0,0 +1,2 @@
+import { getSingletonServiceDescriptors as _get } from '../../common/extensions';
+export declare const getSingletonServiceDescriptors: typeof _get;

package/dist/@types/services/root/webide/root.d.ts

@@ -0,0 +1,11 @@
+import { IInstantiationService, ServiceIdentifier } from '../../common/vs/platform/instantiation/common/instantiation';
+export declare class Root {
+    private static _instance;
+    protected instantiationService: IInstantiationService;
+    constructor(instantiationService?: IInstantiationService);
+    static get instance(): Root;
+    static set instance(rootins: Root);
+    static get iis(): IInstantiationService;
+    static initIisWithServices(i: IInstantiationService): Root;
+    static getService<T>(a: ServiceIdentifier<T>): Promise<T>;
+}

package/dist/@types/services/root/webide/rootService.d.ts

@@ -0,0 +1,2 @@
+import { getSingletonServiceDescriptors as _get } from '../../common/extensions';
+export declare const getSingletonServiceDescriptors: typeof _get;

package/dist/@types/utils/colorutils.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    isHexColor: (hex: string) => boolean;
+};
+export = _default;

package/dist/@types/utils/debug.d.ts

@@ -1,3 +1,4 @@
 export declare function shouldInspectCompiler(): Promise<boolean>;
 export declare function shouldRunInMainProcess(): Promise<boolean>;
 export declare function shouldNotRunInWorker(): Promise<boolean>;
+export declare function shouldInspectWorker(): Promise<boolean>;

package/dist/@types/utils/error.d.ts

@@ -1,4 +1,4 @@
 export declare class CodeError extends Error {
-    private code;
+    code: number;
     constructor(msg: string, code: number);
 }

package/dist/@types/utils/fsagent.d.ts

@@ -1,3 +1,4 @@
+import { WriteFileOptions } from 'fs';
 export interface IFSAgent {
     stat: (path: string) => Promise<{
         isFile: () => boolean;
@@ -11,7 +12,7 @@ export interface IFSAgent {
     }>;
     readFile: (path: string) => Promise<Buffer>;
     exists: (path: string) => Promise<boolean>;
-    writeFile: (path: string, data: any, options: string | null) => Promise<void>;
+    writeFile: (path: string, data: any, options: WriteFileOptions) => Promise<void>;
     readdir: (path: string) => Promise<string[]>;
 }
 export declare class FSAgent implements IFSAgent {
@@ -29,7 +30,7 @@ export declare class FSAgent implements IFSAgent {
         birthtimeMs: number;
     }>;
     exists(target: string): Promise<boolean>;
-    readFile(target: string): Promise<Buffer>;
-    writeFile(target: string, data: any, options?: string | null): Promise<void>;
+    readFile(target: string): Promise<Buffer<ArrayBufferLike>>;
+    writeFile(target: string, data: any, options?: WriteFileOptions): Promise<void>;
     readdir(target: string): Promise<string[]>;
 }

package/dist/@types/utils/processBootstrap.d.ts

@@ -0,0 +1,7 @@
+interface IProcessBootstrapOptions {
+    baseDir: string;
+    hackRequirePath?: string;
+    moduleFallbackPath?: string;
+}
+export declare function installProcessBootstrap({ baseDir, hackRequirePath, moduleFallbackPath, }: IProcessBootstrapOptions): void;
+export {};

package/dist/@types/utils/subprocess/processManager.d.ts

@@ -9,6 +9,7 @@ export declare class SubProcessProxy {
     private process?;
     private taskMap;
     private taskId;
+    forkId: number;
     private _checkReadyTask?;
     private _cpPromise?;
     constructor(project: MiniProgramCore.IPreCompileProject, entryPath: string, passData: {

package/dist/@types/utils/wxapkg/pack.d.ts

@@ -2,5 +2,5 @@ export interface IFile {
     path: string;
     data: Buffer;
 }
-export declare function packCore(files: IFile[]): Buffer;
-export default function pack(file: string, distPath: string, cwd: string, ignores?: string[]): Promise<Buffer>;
+export declare function packCore(files: IFile[]): Buffer<ArrayBuffer>;
+export default function pack(file: string, distPath: string, cwd: string, ignores?: string[]): Promise<Buffer<ArrayBuffer>>;