miniprogram-ci 2.1.31 → 2.1.32

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

@@ -0,0 +1,3 @@
+import { vslib } from './librarybase';
+export { vslib as vsbase };
+export declare function setGetVsBaseBundle(getVsBaseBundleFunc: () => any): void;

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

@@ -0,0 +1,41 @@
+export interface IGlassEaselCompileResult {
+    templateResults: Record<string, string>;
+    wxmlDependencies: Record<string, string[]>;
+    scriptResult: string;
+    runtimeString: string;
+    runtimeGlobal: string;
+    gdcContent: string;
+    wxsEnvContent: string;
+}
+export interface ICompileWxmlToGlassEasel {
+    wxmlAndWxsFiles: Record<string, string>;
+}
+export interface ICompileWxmlOptions {
+    files: string[];
+    configContent: string;
+    configSplit: string;
+    isCut: boolean;
+    cwd: string;
+    genfuncName: string;
+    hasWxs?: boolean;
+    isPlugin?: boolean;
+    lazyloadConfig?: string;
+    replaceContent: Record<string, string>;
+    isMiniAppProject?: boolean;
+    debugWXS?: boolean;
+    debug?: boolean;
+}
+export interface INormalResult {
+    code: string;
+    name: string;
+}
+export interface ILazyResult {
+    pages: Record<string, string>;
+    names: Record<string, string>;
+}
+export type ICompileResult = INormalResult | ILazyResult;
+export interface ICompilewxmlService {
+    compileWxml: (options: ICompileWxmlOptions) => Promise<ICompileResult>;
+    compileWxmlToGlassEasel: (options: ICompileWxmlToGlassEasel) => Promise<IGlassEaselCompileResult>;
+}
+export declare const ICompilewxmlService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<ICompilewxmlService>;

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

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

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

@@ -0,0 +1,3 @@
+import { ICompileWxmlOptions, ICompileResult, ICompileWxmlToGlassEasel, IGlassEaselCompileResult } from '../common/compilewxmlService';
+export declare function compileUseWCC(options: Exclude<ICompileWxmlOptions, 'replaceContent'>): Promise<ICompileResult>;
+export declare function compileWxmlToGlassEasel(options: ICompileWxmlToGlassEasel): Promise<IGlassEaselCompileResult>;

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

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

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

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

package/dist/@types/services/compilewxml/webide/pageFrameWasm/wcc/runWcc.d.ts

@@ -0,0 +1,3 @@
+import type { ICompileWxmlOptions } from '~/services/compilewxml/common/compilewxmlService';
+export declare function runWcc(options: ICompileWxmlOptions): Promise<any>;
+export declare function testWcc(): Promise<void>;

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

@@ -0,0 +1,15 @@
+export interface ICompileWxssOptions {
+    files: string[];
+    pageCount: number;
+    cwd: string;
+    lazyload?: boolean;
+    subPackage?: string;
+    replaceContent: Record<string, string>;
+    isMiniAppProject?: boolean;
+    contents?: string[];
+}
+export type ICompileWxssResult = Record<string, string>;
+export interface ICompilewxssService {
+    compileWxss: (options: ICompileWxssOptions) => Promise<ICompileWxssResult>;
+}
+export declare const ICompilewxssService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<ICompilewxssService>;

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

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

package/dist/@types/services/compilewxss/node/compileUtils.d.ts

@@ -0,0 +1,2 @@
+import { ICompileWxssOptions, ICompileWxssResult } from '../common/compilewxssService';
+export declare function compileUseWCSC(options: Exclude<ICompileWxssOptions, 'replaceContent'>): Promise<ICompileWxssResult>;

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

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

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

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

package/dist/@types/services/compilewxss/webide/pageFrameWasm/wcsc/runWcsc.d.ts

@@ -0,0 +1,3 @@
+import type { ICompileWxssOptions } from '~/services/compilewxss/common/compilewxssService';
+export declare function runWcscWasm(options: ICompileWxssOptions): Promise<any>;
+export declare function runWcsc(options: ICompileWxssOptions): Promise<any>;

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

@@ -0,0 +1,5 @@
+export interface IConsoleDisplayService {
+    display: (arg: Record<string, any>) => void;
+    setDisplay?: (func: FN) => void;
+}
+export declare const IConsoleDisplayService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IConsoleDisplayService>;

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

@@ -0,0 +1,6 @@
+import { IConsoleDisplayService } from '../common/consoledisplay';
+export declare class NWConsoleDisplayService implements IConsoleDisplayService {
+    private _display?;
+    setDisplay(func: FN): void;
+    display(arg: Record<string, any>): void | undefined;
+}

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

@@ -0,0 +1,5 @@
+export interface IFileUtilsManagerService {
+    projectFileUtils(projectPath: string, options: Record<string, any>): Promise<any>;
+    setProjectFileUtils?: (func: FN) => void;
+}
+export declare const IFileUtilsManagerService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IFileUtilsManagerService>;

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

@@ -0,0 +1,6 @@
+import { IFileUtilsManagerService } from '../common/fileUtilsManager';
+export declare class NWFileUtilsManagerService implements IFileUtilsManagerService {
+    private _projectFileUtils;
+    setProjectFileUtils(func: FN): void;
+    projectFileUtils(projectPath: string, options: Record<string, any>): Promise<any>;
+}

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

@@ -0,0 +1,28 @@
+import { Stats } from 'fs';
+export type IReadFileOptions = {
+    encoding?: null | undefined | string;
+    flag?: string;
+} | null | string;
+export interface IBuilderFileServiceContext {
+    projectId: string;
+    versionId: string;
+    ticket: string;
+}
+export type IFileList = {
+    name: string;
+    key: string;
+    lastModifiedTime: number;
+    size: number;
+    createTime: number;
+    content?: string;
+}[];
+export interface IFileService {
+    readFile: (filePath: string, options: IReadFileOptions, ctx: IBuilderFileServiceContext) => Promise<Buffer | string>;
+    readFileList: (filePath: string[], ctx: IBuilderFileServiceContext) => Promise<{
+        [filePath: string]: string;
+    }>;
+    exists: (filePath: string, ctx: IBuilderFileServiceContext) => Promise<boolean>;
+    lstat: (filePath: string, ctx: IBuilderFileServiceContext) => Promise<Stats>;
+    fileList: (ctx: IBuilderFileServiceContext) => Promise<IFileList>;
+}
+export declare const IFileService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IFileService>;

package/dist/@types/services/genTempFile/common/genTempFile.devtools.d.ts

@@ -0,0 +1,4 @@
+import { IGenTempFile } from './genTempFileService';
+export declare class devtoolsGenTempFile implements IGenTempFile {
+    genPath(): Promise<string>;
+}

package/dist/@types/services/genTempFile/common/genTempFile.node.d.ts

@@ -0,0 +1,4 @@
+import { IGenTempFile } from './genTempFileService';
+export declare class nodeGenTempFile implements IGenTempFile {
+    genPath(): Promise<string>;
+}

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

@@ -0,0 +1,4 @@
+export interface IGenTempFile {
+    genPath(): Promise<string>;
+}
+export declare const IGenTempFile: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IGenTempFile>;

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+export type IBuildLogStatus = 'doing' | 'success' | 'error' | 'info' | 'warn';
+export interface IGlobalService {
+    isDev(): any;
+    setIsDev?: (func: FN) => void;
+    getAppVersion(): Promise<string>;
+    setGetAppVersion?: (func: FN) => void;
+    showBuildLog2(statusMsgId: string, type: 'compile', status: IBuildLogStatus, text: string): Promise<void>;
+    setShowBuildLog2?: (func: FN) => void;
+}
+export declare const IGlobalService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IGlobalService>;

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

@@ -0,0 +1,12 @@
+import { IGlobalService, IBuildLogStatus } from '../common/global';
+export declare class NWGlobalService implements IGlobalService {
+    private _isDev;
+    private _getAppVersion;
+    private _showBuildLog2;
+    setShowBuildLog2(func: FN): void;
+    setIsDev(func: FN): void;
+    setGetAppVersion(func: FN): void;
+    isDev(): Promise<any>;
+    getAppVersion(): Promise<any>;
+    showBuildLog2(statusMsgId: string, type: 'compile', status: IBuildLogStatus, text?: string): Promise<any>;
+}

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

@@ -0,0 +1,21 @@
+export declare enum EInitializeStepsStatus {
+    initializing = "initializing",
+    ready = "ready",
+    failed = "failed"
+}
+export declare enum EInitializeSteps {
+    BackendMessagecenterDone = "BackendMessagecenterDone",
+    RuntimeMessagecenterDone = "RuntimeMessagecenterDone",
+    EditorMessagecenterDone = "EditorMessagecenterDone",
+    BackendHasWorker = "BackendHasWorker",
+    BackendSummerWorkerLoaded = "BackendSummerWorkerLoaded",
+    BackendTaskWorkerLoaded = "BackendTaskWorkerLoaded",
+    BackendWCC = "BackendWCC",
+    BackendWCSC = "BackendWCSC",
+    DefaultCompileInFirstTime = "DefaultCompileInFirstTime",
+    RuntimeServiceWorker = "RuntimeServiceWorker"
+}
+export interface IInitializeCheck {
+    notifiedStatus(step: EInitializeSteps, status: EInitializeStepsStatus): void;
+}
+export declare const IInitializeCheck: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IInitializeCheck>;

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

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

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

@@ -0,0 +1,7 @@
+export interface ILocalesService {
+    getLocale(): any;
+    setLocale?: (func: FN) => void;
+    getLocales: () => Record<string, any>;
+    setGetLocales?: (func: FN) => void;
+}
+export declare const ILocalesService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<ILocalesService>;

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

@@ -0,0 +1,9 @@
+import { ILocalesService } from '../common/locales';
+export declare class NWLocalesService implements ILocalesService {
+    private _getLocale;
+    private _getLocales;
+    setGetLocales(func: FN): void;
+    setLocale(func: FN): void;
+    getLocale(): Promise<any>;
+    getLocales(): any;
+}

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

@@ -0,0 +1,9 @@
+export interface ILogService {
+    error: (...args: any) => void;
+    info: (...args: any) => void;
+    warn: (...args: any) => void;
+    log: (...args: any) => void;
+    debug: (...args: any) => void;
+    context: (ctx: string, consoleObj?: Omit<ILogService, 'context'>) => ILogService;
+}
+export declare const ILogService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<ILogService>;

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

@@ -0,0 +1,5 @@
+export interface IMiniappJson {
+    isMiniAppProject: (project?: IProject) => boolean;
+    setIsMiniAppProject?: (func: FN) => void;
+}
+export declare const IMiniappJson: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IMiniappJson>;

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

@@ -0,0 +1,6 @@
+import { IMiniappJson } from '../common/miniappjson';
+export declare class ElectronMiniappJson implements IMiniappJson {
+    private _isMiniAppProject;
+    setIsMiniAppProject(func: FN): void;
+    isMiniAppProject(project?: IProject): boolean;
+}

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

@@ -0,0 +1,6 @@
+import { IMiniappJson } from '../common/miniappjson';
+export declare class NWMiniappJson implements IMiniappJson {
+    private _isMiniAppProject;
+    setIsMiniAppProject(func: FN): void;
+    isMiniAppProject(project?: IProject): boolean;
+}

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

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

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

@@ -0,0 +1,9 @@
+export interface INativeModuleService {
+    setWXMLParsePath: (path: string) => Promise<void>;
+    getWXMLParsePath: () => Promise<string>;
+    setWXSSParsePath: (path: string) => Promise<void>;
+    getWXSSParsePath: () => Promise<string>;
+    setGlassEaselLazyModulePath: (path: string) => Promise<void>;
+    getGlassEaselLazyModulePath: () => 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

@@ -0,0 +1,12 @@
+import { INativeModuleService } from './nativeModule';
+export declare class nativeModuleImpl implements INativeModuleService {
+    private _WXMLParsePath;
+    private _WXSSParsePath;
+    private _GlassEaselLazyModulePath;
+    setWXMLParsePath(path: string): Promise<void>;
+    getWXMLParsePath(): Promise<string>;
+    setWXSSParsePath(path: string): Promise<void>;
+    getWXSSParsePath(): Promise<string>;
+    setGlassEaselLazyModulePath(path: string): Promise<void>;
+    getGlassEaselLazyModulePath(): Promise<string>;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+export interface IPerformanceReportService {
+    setReportPerf?: (fn: FN) => void;
+    setGetReportName?: (fn: FN) => void;
+    reportPerf: (name: string, hrTime: number) => Promise<void>;
+    getReportName(): {
+        [key: string]: string;
+    };
+}
+export declare const IPerformanceReportService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IPerformanceReportService>;

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

@@ -0,0 +1,9 @@
+import { IPerformanceReportService } from '../common/performance';
+export declare class NWPerformanceReportService implements IPerformanceReportService {
+    private _reportPerf;
+    private _getReportName;
+    setReportPerf: (fn: FN) => void;
+    setGetReportName: (fn: FN) => void;
+    reportPerf(name: string, hrTime: number): Promise<any>;
+    getReportName(): any;
+}

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

@@ -0,0 +1,7 @@
+import { IPerformanceReportService } from '../common/performance';
+export declare class WebidePerformanceReportService implements IPerformanceReportService {
+    reportPerf(name: string, hrTime: number): Promise<void>;
+    getReportName(): {
+        [key: string]: string;
+    };
+}

package/dist/@types/services/projectManager/common/buildServerProjectManager.d.ts

@@ -0,0 +1,5 @@
+import { IBuilderFileServiceContext } from '~/services/fs/common/fileService';
+export interface IBuildServerProjectManagerService {
+    getProject: (ctx: IBuilderFileServiceContext) => Promise<IBackendProject>;
+}
+export declare const IProjectManagerService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IBuildServerProjectManagerService>;

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

@@ -0,0 +1,7 @@
+export interface IProjectManagerService {
+    getAppIdAndAttr: () => Promise<Record<string, any>>;
+    setGetAppIdAndAttr?: (func: FN) => void;
+    getCurrentRuntimeConfig: () => IProjectAttr;
+    setGetCurrentRuntimeConfig?: (func: FN) => void;
+}
+export declare const IProjectManagerService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IProjectManagerService>;

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

@@ -0,0 +1,9 @@
+import { IProjectManagerService } from '../common/projectManager';
+export declare class NWProjectManagerService implements IProjectManagerService {
+    private _getAppIdAndAttr;
+    private _getCurrentRuntimeConfig;
+    setGetCurrentRuntimeConfig(func: FN): void;
+    setGetAppIdAndAttr(func: FN): void;
+    getAppIdAndAttr(): Promise<any>;
+    getCurrentRuntimeConfig(): any;
+}

package/dist/@types/services/root/common/createService.d.ts

@@ -0,0 +1,12 @@
+import { ServiceIdentifier } from '../../common/vs/platform/instantiation/common/instantiation';
+import { SyncDescriptor } from '../../common/vs/platform/instantiation/common/descriptors';
+import { vsbase } from '../../common/vsbase';
+type IInstantiationService = vsbase.vs.platform.instantiation.common.instantiation.$types.IInstantiationService;
+type ServiceCollection = vsbase.vs.platform.instantiation.common.serviceCollection.$types.ServiceCollection;
+declare const IInstantiationService: ServiceIdentifier<import("../../common/vs/platform/instantiation/common/instantiation").IInstantiationService>;
+declare const ServiceCollection: typeof import("../../common/vs/platform/instantiation/common/serviceCollection").ServiceCollection;
+export declare function createService(contributedServices: Array<[ServiceIdentifier<any>, SyncDescriptor<any>]>): {
+    instantiationService: IInstantiationService;
+    serviceCollection: ServiceCollection;
+};
+export {};

package/dist/@types/services/root/electron/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/electron/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/node/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/nw/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/staticConfig/common/staticConfigService.d.ts

@@ -0,0 +1,5 @@
+export interface IStaticConfigService {
+    get(key: string): any;
+    setGet?: (func: FN) => void;
+}
+export declare const IStaticConfigService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IStaticConfigService>;

package/dist/@types/services/staticConfig/nw/staticConfigService.d.ts

@@ -0,0 +1,6 @@
+import { IStaticConfigService } from '../common/staticConfigService';
+export declare class NWStaticConfigService implements IStaticConfigService {
+    private _get;
+    setGet(func: FN): void;
+    get(key: string): any;
+}

package/dist/@types/services/store/common/storeService.d.ts

@@ -0,0 +1,17 @@
+import { Event } from 'vs/base/common/event';
+export type GetValueType<T, Path extends unknown[]> = Path extends [infer K1, ...infer Rest] ? K1 extends keyof T ? GetValueType<T[K1], Rest> : undefined : T;
+type ThunkAction = (dispatch: FN<void>, getState: FN) => Promise<any>;
+export interface IStoreService {
+    createStore: () => any;
+    getState: () => any;
+    subscribe: (fn: FN<void>) => FN<void>;
+    unsubscribe: (fn: FN<void>) => FN<void>;
+    getValue: <Path extends string[]>(...args: Path) => Promise<(GetValueType<any, Path>)>;
+    getValueByRuntimeId: <Path extends string[]>(runtimeId: string, ...args: Path) => Promise<(GetValueType<any, Path>)>;
+    onStateChange: Event<any>;
+    dispatch(action: any | ThunkAction): any;
+    setDispatchEanInfoSetConfirmInfo?: (func: FN) => void;
+    dispatchEanInfoSetConfirmInfo?: (params: Record<string, any>) => void;
+}
+export declare const IStoreService: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IStoreService>;
+export {};

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

@@ -0,0 +1,5 @@
+export interface IUniApp {
+    setCopyMiniAppJson?: (func: FN) => void;
+    copyMiniAppJson: (project: IProject) => boolean;
+}
+export declare const IUniApp: import("../../common/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IUniApp>;

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

@@ -0,0 +1,9 @@
+import { IUniApp } from '../common/uniapp';
+import { IStoreService } from '~/services/store/common/storeService';
+export declare class NWUniApp implements IUniApp {
+    protected readonly storeService: IStoreService;
+    constructor(storeService: IStoreService);
+    private _copyMiniAppJson;
+    setCopyMiniAppJson(func: FN): void;
+    copyMiniAppJson(project: IProject): boolean;
+}

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

@@ -0,0 +1,4 @@
+import { IUniApp } from '../common/uniapp';
+export declare class WebideUniApp implements IUniApp {
+    copyMiniAppJson(project: IProject): boolean;
+}