miniprogram-ci 1.9.26 → 2.0.0

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

@@ -0,0 +1,52 @@
+import { PreCompileProject } from '../project/advance/precompileProject';
+import { MiniProgramCI, MiniProgramCore, MiniProgramDevtools } from '../types';
+import { IMessageHub, IConsoleDisplay } from '../utils/messageHub';
+import { PreCompiler } from './precompiler/index';
+import { SummerCompiler } from './corecompiler/summerCompiler';
+import { FullCompiler } from './fullcompiler';
+import { NativeCompiler } from './nativecompiler';
+import { OriginalCompiler } from './corecompiler/originalCompiler';
+interface IBuilderOptions {
+    summerCompilerClass?: typeof SummerCompiler;
+    cachePath?: string;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+    projectInfo?: MiniProgramDevtools.IDevtoolsProjectInfo;
+    devtoolMessagehub?: IMessageHub;
+    consoleDisplay?: IConsoleDisplay;
+    targetPlatform?: MiniProgramCore.ITargetPlatform;
+    targetPlatformDefines?: MiniProgramCore.ITargetPlatformDefine;
+    outputDir?: string;
+}
+export declare class Builder {
+    originProject: MiniProgramCI.IProject;
+    private _precompileProject;
+    private _preCompiler;
+    private _summerCompiler;
+    private _fullCompiler;
+    private _nativeCompiler;
+    private _options;
+    private _checkReadyTask?;
+    private _originalCompiler;
+    constructor(project: MiniProgramCI.IProject, opts: IBuilderOptions);
+    getCompiler(): Promise<OriginalCompiler | SummerCompiler>;
+    getPreCompileProject(): Promise<PreCompileProject>;
+    getPreCompiler(): Promise<PreCompiler>;
+    getSummerCompiler(): Promise<SummerCompiler>;
+    ready(): Promise<any>;
+    init(): Promise<void>;
+    get summerCompiler(): SummerCompiler;
+    get nativeCompiler(): NativeCompiler;
+    get fullCompiler(): FullCompiler | undefined;
+    getNativeCompiler(): Promise<NativeCompiler>;
+    getFullCompiler(): Promise<FullCompiler>;
+    initNativeCompiler(opts: IBuilderOptions): Promise<void>;
+    getPreCompileOptions(): {
+        targetPlatform: MiniProgramCore.ITargetPlatform | undefined;
+        targetPlatformDefines: MiniProgramCore.ITargetPlatformDefine | undefined;
+    };
+    changePreCompileOptions(opts: MiniProgramCore.IConditionCompileInfo): Promise<void>;
+    setLocale(locale: string): Promise<void>;
+    destroy(): void;
+}
+export {};

package/dist/@types/modules/nativecompiler/android/adb.d.ts

@@ -0,0 +1,7 @@
+import { Recorder } from '../../../utils/progressRecorder';
+export declare function getAdbPath(): string;
+export declare function tryRunAdbReverse(data: {
+    packagerPort: number | string;
+    device?: string | void;
+    recorder: Recorder;
+}): void;

package/dist/@types/modules/nativecompiler/android/device.d.ts

@@ -0,0 +1,15 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp } from '../../../types';
+export declare const getEmulators: () => IMiniApp.AndroidDevice[];
+export declare const tryLaunchEmulator: (simulator: string | null, recorder: Recorder) => Promise<{
+    success: boolean;
+    error?: string;
+    device?: IMiniApp.AndroidDevice;
+}>;
+export declare function getDevices(): Promise<IMiniApp.AndroidDevice[]>;
+export declare function getAvailableCPUs(device: string): string[];
+export declare function getCPU(device: string): string | null;
+export declare function tryInstantBuild(androidProject: IMiniApp.ProjectConfig, variant: string, recorder: Recorder): Promise<void>;
+export declare function tryBuild(sourceDir: string, gradleArgs: string[], recorder: Recorder): Promise<void>;
+export declare function tryInstantInstall(androidProject: IMiniApp.ProjectConfig, variant: string, recorder: Recorder): Promise<void>;
+export declare function tryLaunchAppOnDevice(device: string | void, packageName: string, args: IMiniApp.IAndroidRunLocalArgs, recorder: Recorder): Promise<void>;

package/dist/@types/modules/nativecompiler/android/index.d.ts

@@ -0,0 +1,17 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp } from '../../../types';
+export declare class AndroidUtils {
+    private root;
+    private userConfig;
+    private miniappDirPath?;
+    private devtoolsVersion?;
+    constructor(root: string, userConfig?: IMiniApp.AndroidProjectParams, miniappDirPath?: string | undefined, devtoolsVersion?: string | undefined);
+    getProjectConfig(recorder: Recorder): IMiniApp.AndroidProjectConfig;
+    runLocal(args: IMiniApp.IAndroidRunLocalArgs, recorder: Recorder): Promise<void>;
+    runCloud(): Promise<void>;
+    buildLocal(args: IMiniApp.IAndroidBuildLocalArgs, recorder: Recorder): Promise<string>;
+    buildCloud(): Promise<void>;
+    runOnAllDevices(args: IMiniApp.IAndroidRunLocalArgs, androidProject: IMiniApp.AndroidProject, recorder: Recorder): Promise<void>;
+    runOnSpecificDevice(args: IMiniApp.IAndroidRunLocalArgs, androidProject: IMiniApp.AndroidProject, recorder: Recorder): Promise<void>;
+    buildPlugin(args: IMiniApp.IAndroidBuildPluginArgs, recorder: Recorder): Promise<string>;
+}

package/dist/@types/modules/nativecompiler/android/projectconfig.d.ts

@@ -0,0 +1,11 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp } from '../../../types';
+declare class ProjectConfigUtils {
+    getProjectConfig(root: string, userConfig: IMiniApp.AndroidProjectParams | undefined, recorder: Recorder): IMiniApp.AndroidProjectConfig | null;
+    findManifest(sourceDir: string): string | null;
+    getPackageName(manifestPath: string, recorder: Recorder): string;
+    validatePackageName(packageName: string): boolean;
+    getAppName(sourceDir: string, userConfigAppName: string | undefined): string;
+}
+declare const _default: ProjectConfigUtils;
+export = _default;

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

@@ -0,0 +1,32 @@
+import { MiniProgramCore, IMiniApp } from '../../types';
+import { SubProcessProxy } from '../../utils/subprocess/processManager';
+import { IMessageHub } from '../../utils/messageHub';
+interface IProps {
+    devtoolMessagehub: IMessageHub;
+    project: MiniProgramCore.IPreCompileProject;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+}
+export declare class NativeCompiler {
+    private _checkReadyTask?;
+    private messageHub;
+    private initedPromise;
+    project: MiniProgramCore.IPreCompileProject | undefined;
+    subProcessManager: SubProcessProxy | undefined;
+    miniappDirPath: string | undefined;
+    devtoolsVersion: string | undefined;
+    constructor(props: IProps);
+    ready(): Promise<any>;
+    init(): Promise<void>;
+    createSubProcessManager(): Promise<void>;
+    private onProgressUpdate;
+    runAndroid(opts: IMiniApp.IAndroidRunLocalSimpleArgs | IMiniApp.IAndroidRunCloudSimpleArgs): Promise<void>;
+    runIOS(opts: IMiniApp.IIOSRunLocalSimpleArgs | IMiniApp.IIOSRunCloudSimpleArgs): Promise<void>;
+    buildAndroidAPK(opts: IMiniApp.IAndroidBuildLocalSimpleArgs | IMiniApp.IAndroidBuildCloudSimpleArgs): Promise<string>;
+    buildIOSIPA(opts: IMiniApp.IIOSBuildLocalSimpleArgs | IMiniApp.IIOSBuildCloudSimpleArgs): Promise<string>;
+    buildAndroidPlugin(opts: IMiniApp.IAndroidBuildPluginArgs): Promise<void>;
+    buildIOSPlugin(opts: IMiniApp.IBuildPluginIOSFrameworkArgs): Promise<void>;
+    packIOSCloudBuildMaterial(opts: IMiniApp.IIOSBuildCloudGenMaterialArgs): Promise<string>;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp, MiniProgramCore } from '../../../types';
+import { IEntitlements } from '../../../utils/codesign';
+import II18NInfo = IMiniApp.II18NInfo;
+type ITheme = 'Light' | 'LightSpecial' | 'Dark' | 'DarkSpecial' | 'Default';
+export declare const remoteBuildProjectMaterialAbsoluteCacheDir = "__absoluteFile";
+export declare const privateDescriptions: string[];
+export interface IBuildCloudResult {
+    projectPath: string;
+    demoIpaPath: string;
+    opts: {
+        output: string;
+        entitlements?: IEntitlements;
+        bundleId?: string;
+    };
+    iosMiniappJson: any;
+    isPublish: boolean;
+}
+declare class buildCloudManager {
+    generateTempDemoIpaPath(demoIpaPath: string): string;
+    generateInfoPlistCFBundleURLTypesItem(miniappJsonCFBundleURLTypes: MiniProgramCore.IStringKeyMap): any;
+    updatePrivacyBackgroundImage(projectPath: string, demoIpaPath: string, recorder: Recorder, type: 'contentViewImage' | 'cancelButtonImage' | 'confirmButtonImage', imagePath: string): void;
+    updateIOSInfoPlistInfo(projectPath: string, bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, i18nInfo: II18NInfo): Promise<any>;
+    getBundleIdentifier(mobileapp_info: MiniProgramCore.IStringKeyMap): any;
+    useGDT(iosMiniappJson: MiniProgramCore.IStringKeyMap): any;
+    updateIOSAppConfigPlistInfo(projectPath: string, bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, sdkPath: string, isSimulator: boolean, recorder: Recorder, theme: ITheme | undefined, i18nInfo: II18NInfo): Promise<void>;
+    updateIOSAppexInfoPlistInfo(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, CFBundleVersion: number, recorder: Recorder): Promise<void>;
+    private updateBundleIcons;
+    updateIOSIcons(projectPath: string, demoIpaPath: string, miniappCacheDirPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, isPublish: boolean, recorder: Recorder): Promise<void>;
+    updateSplashScreen(projectPath: string, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, theme?: ITheme): Promise<false | undefined>;
+    genUseExtendedSdk(iosMiniappJson: MiniProgramCore.IStringKeyMap): MiniProgramCore.IStringKeyMap<any>;
+    updateExtendedSdk(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, sdkPath: string, arch: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;
+    updatePrivacyInfo(demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;
+    updatePlugin(demoIpaPath: string, pluginDirList: IMiniApp.IIOSPluginDir[], projectPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, miniappCacheDirPath: string, isPublish: boolean, CFBundleVersion: string, recorder: Recorder): Promise<void>;
+    copyUserResourcePathIntoPlugins(pluginId: string, projectPath: string, configResourcePath: string, distFrameworkPath: string, recorder: Recorder): void;
+    copyResourcesToMainBundle(srcFrameworksPath: string, distFrameworkPath: string): void;
+    prepareAppexProfileConfig(pluginDirList: IMiniApp.IIOSPluginDir[], iosMiniappJson: MiniProgramCore.IStringKeyMap, projectPath: string, miniappCacheDirPath: string, isPublish: boolean, CFBundleVersion: string, CFBundleShortVersionString: string, recorder: Recorder): false | {
+        [appexName: string]: {
+            profilePath?: string | undefined;
+            bundleID?: string | undefined;
+            enable: boolean;
+        };
+    } | undefined;
+    changeExtendSDKInfoplistBundleId(infoPlistPath: string, newBundleId: string, extendedName: string): any;
+    changeInfoplistBundleId(infoPlistPath: string, newBundleId: string): any;
+    changeInfoplistBundleVersion(infoPlistPath: string, bundleVersion: string, bundleShortVersion: string): any;
+    getEntitlements(bindAppInfo: MiniProgramCore.IStringKeyMap, _demoIpaPath: string, _iosMiniappJson: MiniProgramCore.IStringKeyMap, _recorder: Recorder): Promise<{
+        'com.apple.developer.associated-domains': any;
+    }>;
+    useTpush(iosMiniappJson: MiniProgramCore.IStringKeyMap): any;
+    buildCloud(args: IMiniApp.IIOSBuildCloudArgs, recorder: Recorder): Promise<IBuildCloudResult>;
+    writeI18NInfoFile(demoIpaPath: string, i18nInfo: II18NInfo, iosI18NField: Record<string, string>): Promise<void>;
+    getMaterialFilePath(projectPath: string, relativeTargetPath: string): string;
+}
+declare const _default: buildCloudManager;
+export default _default;

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

@@ -0,0 +1,24 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp } from '../../../types';
+export declare function parseXctraceIOSDevicesList(text: string): IMiniApp.IOSDevice[];
+export declare function getDevices(opts?: {
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+    recorder?: Recorder;
+}): Promise<IMiniApp.IOSDevice[]>;
+export declare function findMatchingSimulator(simulators: {
+    devices: {
+        [index: string]: IMiniApp.IOSDevice[];
+    };
+}, findOptions?: null | {
+    device?: string;
+    udid?: string;
+}): {
+    udid: string;
+    name: string;
+    booted: boolean;
+    version: string;
+} | null | undefined;
+export declare function matchingDevice(devices: IMiniApp.IOSDevice[], deviceName: string | true | undefined, recorder: Recorder): IMiniApp.IOSDevice | undefined;
+export declare function formattedDeviceName(simulator: IMiniApp.IOSDevice): string;
+export declare function printFoundDevices(devices: IMiniApp.IOSDevice[]): string;

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

@@ -0,0 +1,52 @@
+import { Recorder } from '../../../utils/progressRecorder';
+import { IMiniApp } from '../../../types';
+import II18NInfo = IMiniApp.II18NInfo;
+interface IProjectMaterialPathMap {
+    projectMiniappJson: string;
+    projectConfigJson: string;
+    appJson: string;
+    privacyJson: string;
+    privacyContentViewImage: string;
+    privacyCancelButtonImage: string;
+    privacyConfirmButtonImage: string;
+    icons: string[];
+    splashScreen: string;
+    p12: string;
+    profile: string;
+    tpnsProfile?: string;
+    i18nJson?: string;
+}
+export declare class IOSUtils {
+    private root;
+    private userConfig;
+    private miniappDirPath?;
+    private devtoolsVersion?;
+    constructor(root: string, userConfig?: IMiniApp.IOSProjectParams, miniappDirPath?: string | undefined, devtoolsVersion?: string | undefined);
+    getProjectConfig(): IMiniApp.IOSProjectConfig;
+    getBundleId(appPath: string): string;
+    private tryInstallPod;
+    runLocal(args: IMiniApp.IIOSRunLocalArgs, recorder: Recorder): Promise<void>;
+    runCloud(args: IMiniApp.IIOSRunCloudArgs, recorder: Recorder): Promise<void>;
+    buildLocal(args: IMiniApp.IIOSBuildLocalArgs, recorder: Recorder): Promise<string>;
+    buildCloud(args: IMiniApp.IIOSBuildCloudArgs, recorder: Recorder): Promise<void>;
+    genProjectMaterialMap(projectPath: string, matrialDistPath: string, buildArgs: IMiniApp.IIOSBuildCloudGenMaterialArgs, recorder: Recorder): Promise<IProjectMaterialPathMap>;
+    packIOSCloudBuildMaterial(args: IMiniApp.IIOSBuildCloudGenMaterialArgs, recorder: Recorder): Promise<void>;
+    private launchSimulator;
+    private runOnSimulatorCloud;
+    private runOnSimulatorLocal;
+    private runOnDeviceLocal;
+    private buildProjectApp;
+    private installAppOnSimulator;
+    private launchAppOnSimulator;
+    private buildProjectArchive;
+    private exportArchive;
+    private getTargetPaths;
+    private getBuildInfo;
+    private getPlatformName;
+    private getBuildProductDir;
+    private xcbeautifyAvailable;
+    private xcprettyAvailable;
+    buildPlugin(args: IMiniApp.IBuildPluginIOSFrameworkArgs, recorder: Recorder): Promise<void>;
+    writeI18NInfoFile(demoIpaPath: string, i18nInfo: II18NInfo, iosI18NField: Record<string, string>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { IMiniApp } from '../../../types';
+export declare function getProjectConfig(root: string, _userConfig?: IMiniApp.IOSProjectParams): IMiniApp.IOSProjectConfig | null;
+export declare function findAllPodfilePaths(cwd: string): string[];

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

@@ -0,0 +1,40 @@
+import { MiniProgramCore, IMiniApp } from '../../types';
+import { Recorder } from '../../utils/progressRecorder';
+import { AndroidUtils } from './android';
+import { IOSUtils } from './ios';
+interface INativeProjectInfo {
+    projectPath: string;
+}
+interface IProps {
+    projectInfo: INativeProjectInfo;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+}
+export declare class NativeCompiler {
+    projectPath: string;
+    processManager: any;
+    miniappDirPath: string | undefined;
+    devtoolsVersion: string | undefined;
+    constructor(props: IProps);
+    getHandler(targetPlatform?: string): AndroidUtils | IOSUtils | null;
+    validNativePlatform(targetPlatform: MiniProgramCore.ITargetPlatform): boolean;
+    getAndroidDevices(): Promise<any>;
+    getIOSDevices(): Promise<any>;
+    run(data: {
+        targetPlatform: MiniProgramCore.ITargetPlatform;
+        opts: IMiniApp.IIOSRunLocalSimpleArgs | IMiniApp.IAndroidRunLocalSimpleArgs;
+    }, recorder: Recorder): Promise<any>;
+    build(data: {
+        targetPlatform: MiniProgramCore.ITargetPlatform;
+        opts: IMiniApp.IAndroidBuildLocalSimpleArgs | IMiniApp.IAndroidBuildCloudSimpleArgs;
+    }, recorder: Recorder): Promise<any>;
+    buildPlugin(data: {
+        targetPlatform: MiniProgramCore.ITargetPlatform;
+        opts: IMiniApp.IBuildPluginIOSFrameworkArgs | IMiniApp.IAndroidBuildPluginArgs;
+    }, recorder: Recorder): Promise<any>;
+    packIOSCloudBuildMaterial(data: {
+        targetPlatform: MiniProgramCore.ITargetPlatform;
+        opts: IMiniApp.IIOSBuildCloudGenMaterialArgs;
+    }, recorder: Recorder): Promise<any>;
+}
+export {};

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

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

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

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+import { PLATFORM } from '../../../../config/define';
+import { MacroDefine } from '../define';
+type IPlaform = keyof typeof PLATFORM;
+interface IBaseConditionCompiler {
+    targetPlatform: MiniProgramCore.ITargetPlatform;
+    targetPlatformDefines: MiniProgramCore.ITargetPlatformDefine;
+    type: string;
+    verbose?: boolean;
+    tripleSlash?: boolean;
+}
+export declare abstract class BaseConditionCompiler {
+    targetPlatform: IPlaform;
+    targetPlatformDefines: {};
+    type: string;
+    verbose: boolean;
+    tripleSlash: boolean;
+    constructor({ targetPlatform, targetPlatformDefines, type, verbose, tripleSlash, }: IBaseConditionCompiler);
+    compile(filePath: string, content: Buffer): any;
+    abstract doCompile(opts: {
+        filePath: string;
+        content: Buffer;
+        macroDefine: MacroDefine;
+    }): any;
+}
+export {};

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { MacroDefine } from '../define';
+import { BaseConditionCompiler } from './base';
+export declare class JSONConditionCompiler extends BaseConditionCompiler {
+    doCompile(opts: {
+        filePath: string;
+        content: Buffer;
+        macroDefine: MacroDefine;
+    }): string;
+}

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+import { MacroDefine } from '../define';
+import { BaseConditionCompiler } from './base';
+declare enum IfType {
+    If = 0,
+    Elif = 1
+}
+declare class IfBlock {
+    startIx: number;
+    endIx: number;
+    elifIxs: number[];
+    elseIx: number | null;
+    innerIfs: IfBlock[];
+    constructor(startIx: number, endIx: number, elifIxs?: number[], elseIx?: number | null, innerIfs?: IfBlock[]);
+    getIfRange(): [number, number];
+    getElifRange(index: number): [number, number];
+    getElseRange(): [number, number];
+}
+export declare class MacroConditionCompiler extends BaseConditionCompiler {
+    getIFRegex: () => RegExp;
+    getELSERegex: () => RegExp;
+    getENDIFRegex: () => RegExp;
+    getFefineRegex: () => RegExp;
+    getFileDefines(content: string): MiniProgramCore.ITargetPlatformDefine;
+    matchDefine(line: string): boolean;
+    parseDefine(line: string): any;
+    applyDefines(lines: string[]): void;
+    findIFBlocks(lines: string[]): IfBlock[];
+    parseIFBlock(lines: string[], ifBlockStart: number): IfBlock;
+    matchIF(line: string, type?: IfType): boolean;
+    parseIF(line: string): string;
+    matchENDIF(line: string): boolean;
+    matchELSE(line: string): boolean;
+    applyIF(lines: string[], ifBlock: IfBlock, defines: MiniProgramCore.ITargetPlatformDefine, verbose?: boolean, filePath?: string): void;
+    evaluate(condition: string, defines: MiniProgramCore.ITargetPlatformDefine): boolean;
+    blankCode(lines: string[], start: number, end?: number): void;
+    doCompile(opts: {
+        filePath: string;
+        content: Buffer;
+        macroDefine: MacroDefine;
+    }): string;
+}
+export {};

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { MacroDefine } from '../define';
+import { BaseConditionCompiler } from './base';
+export declare class PlantConditionCompiler extends BaseConditionCompiler {
+    doCompile(opts: {
+        filePath: string;
+        content: Buffer;
+        macroDefine: MacroDefine;
+    }): Buffer;
+}

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

@@ -0,0 +1,18 @@
+import { MiniProgramCore } from '../../../types';
+interface IMacroDefineOpts {
+    filePath: string;
+    targetPlatform: MiniProgramCore.ITargetPlatform;
+    targetPlatformDefines?: MiniProgramCore.ITargetPlatformDefine;
+}
+export declare class MacroDefine {
+    private defaultConstants;
+    private customConstants;
+    constructor({ filePath, targetPlatform, targetPlatformDefines }: IMacroDefineOpts);
+    defines(defines: MiniProgramCore.ITargetPlatformDefine): void;
+    define(key: string, value: string | number | boolean): void;
+    isDefined(key: string): boolean;
+    getDefines(): {
+        [x: string]: any;
+    };
+}
+export {};

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { MiniProgramCI, MiniProgramCore } from '../../../types';
+import { BaseConditionCompiler } from './compiler/base';
+import { IMessageHub } from '../../../utils/messageHub';
+interface IConditionCompiler {
+    targetPlatform: MiniProgramCore.ITargetPlatform;
+    targetPlatformDefines?: MiniProgramCore.ITargetPlatformDefine;
+}
+export declare class ConditionCompiler {
+    extToCompiler: {
+        [ext: string]: BaseConditionCompiler;
+    };
+    project: MiniProgramCI.IProject;
+    devtoolMessagehub?: IMessageHub;
+    constructor(project: MiniProgramCI.IProject, devtoolMessagehub?: IMessageHub);
+    getCompiler(extname: string, opts: IConditionCompiler): BaseConditionCompiler;
+    shouldCompile(filePath: string): boolean;
+    compileFile(filePath: string, opts?: IConditionCompiler): Buffer;
+    compileProject(opts?: IConditionCompiler): {
+        [key: string]: Buffer;
+    };
+    filterResourceByPlatfrom(opts?: MiniProgramCore.IConditionCompileInfo): string[];
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { MiniProgramCI, MiniProgramCore } from '../../types';
+import { PreCompileProject } from '../../project/advance/precompileProject';
+import { IMessageHub } from '../../utils/messageHub';
+export declare class PreCompiler {
+    project: MiniProgramCI.IProject;
+    devtoolMessagehub?: IMessageHub;
+    constructor(project: MiniProgramCI.IProject, devtoolMessagehub?: IMessageHub);
+    getPreCompileProject(opts?: MiniProgramCore.IConditionCompileInfo): Promise<PreCompileProject>;
+}
+export { ConditionCompiler } from './conditioncompile';

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

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { MiniProgramCore, MiniProgramDevtools, MiniProgramSummer, MiniProgramCI } from '../../types';
+import { BaseProject } from '../baseProject';
+import { ConditionCompiler } from '../../modules/precompiler/index';
+type FileChange = (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
+type ProjectEventEmitter = MiniProgramSummer.TypedEventEmitter<{
+    fileChange: FileChange;
+    optionsChange: any;
+    precompileOptionsChange: any;
+}>;
+export declare class PreCompileProject extends BaseProject implements MiniProgramCore.IPreCompileProject {
+    project: MiniProgramCI.IProject;
+    event: ProjectEventEmitter;
+    targetPlatform: MiniProgramCore.ITargetPlatform;
+    targetPlatformDefines: MiniProgramCore.ITargetPlatformDefine;
+    runEnv?: MiniProgramCore.IPreRunEnv;
+    conditionCompiler: ConditionCompiler;
+    private _fileBufferCache;
+    constructor(project: MiniProgramCI.IProject, conditionCompiler: ConditionCompiler, opts: MiniProgramCore.IConditionCompileInfo);
+    ready(): Promise<void>;
+    init(): Promise<void>;
+    shouldConditionalCompile(): boolean;
+    updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
+    updateConditionCompileOptions(opts: MiniProgramCore.IConditionCompileInfo): void;
+    updateFileAndDirs(): void;
+    get srcPath(): string;
+    attr(): Promise<MiniProgramCI.IProjectAttr>;
+    serialize(): Promise<MiniProgramCore.IPrecompileProjectSerializeInfo>;
+    getSrcFile(prefix: string | undefined, filePath: string): Buffer;
+    getFile(prefix: string | undefined, filePath: string): Buffer;
+    onFileChange: (type: MiniProgramCore.IWatchEventType, targetPath: string) => Promise<void>;
+    notifyRefreshFileOrDirs(oldFiles: string[]): void;
+    clearCache(): void;
+}
+export {};

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

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../types';
+import { BaseProject } from '../baseProject';
+export declare class ReactiveProject extends BaseProject implements MiniProgramCore.IPreCompileProject {
+    project: MiniProgramCore.IPreCompileProject;
+    private fileBoxs;
+    private statBoxs;
+    private attrBox;
+    private appidBox;
+    private typeBox;
+    private miniprogramRootBox;
+    private pluginRootBox;
+    constructor(project: MiniProgramCore.IPreCompileProject);
+    get appid(): string;
+    get type(): import("../../types").MiniProgramCI.ProjectType;
+    get nameMappingFromDevtools(): import("../../types").MiniProgramCI.IStringKeyMap<string> | undefined;
+    get projectPath(): string;
+    get privateKey(): string;
+    get miniprogramRoot(): string;
+    set miniprogramRoot(val: string);
+    get pluginRoot(): string;
+    set pluginRoot(val: string);
+    init(): Promise<void>;
+    updateFileAndDirs(): void;
+    updateProject(): Promise<unknown>;
+    release(): void;
+    attr(): Promise<MiniProgramCore.IProjectAttr>;
+    getSrcFile(prefix: string, filePath: string): Buffer;
+    getFileList(prefix?: string, extName?: string): string[];
+    getFilesAndDirs(): {
+        files: string[];
+        dirs: string[];
+    };
+    getExtAppid(): Promise<string | void>;
+    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => Promise<void>;
+    getFile(prefix: string, filePath: string): Buffer;
+    stat(prefix: string, filePath: string): import("../../types").MiniProgramCI.IStat | undefined;
+    attrSync(): import("../../types").MiniProgramCI.IProjectAttr;
+}

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

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import { MiniProgramCore, MiniProgramDevtools, MiniProgramSummer, ProjectConfigJSON } from '../types';
+import WaitAble from '../utils/waitable';
+type FileChange = (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
+type ProjectEventEmitter = MiniProgramSummer.TypedEventEmitter<{
+    fileChange: FileChange;
+    optionsChange: any;
+    precompileOptionsChange: any;
+}>;
+export declare abstract class BaseProject extends WaitAble implements MiniProgramCore.IProject {
+    protected _nameMappingFromDevtools?: MiniProgramCore.IStringKeyMap<string> | undefined;
+    protected _projectPath: string;
+    protected _projectArchitecture: MiniProgramCore.IProjectArchitecture;
+    protected _miniprogramRoot: string;
+    protected _pluginRoot: string;
+    protected _appid: string;
+    protected _extAppid?: string | null;
+    protected _type: MiniProgramCore.ProjectType;
+    protected _privateKey: string;
+    ignores: string[];
+    protected _attr: any;
+    packOptions?: {
+        ignore: MiniProgramDevtools.IProjectConfigPackOption[];
+        include: MiniProgramDevtools.IProjectConfigPackOption[];
+    } | undefined;
+    setting: MiniProgramDevtools.IProjectSetting;
+    protected _dirSet: Set<string>;
+    protected _fileSet: Set<string>;
+    event: ProjectEventEmitter;
+    get projectPath(): string;
+    get projectArchitecture(): import("../types").MiniProgramCI.IProjectArchitecture;
+    get srcPath(): string;
+    get pluginSrcPath(): string;
+    get type(): import("../types").MiniProgramCI.ProjectType;
+    set type(type: import("../types").MiniProgramCI.ProjectType);
+    get appid(): string;
+    set appid(id: string);
+    get privateKey(): string;
+    set privateKey(key: string);
+    get miniprogramRoot(): string;
+    set miniprogramRoot(root: string);
+    get pluginRoot(): string;
+    set pluginRoot(root: string);
+    get nameMappingFromDevtools(): MiniProgramCore.IStringKeyMap<string> | undefined;
+    set nameMappingFromDevtools(mapping: MiniProgramCore.IStringKeyMap<string> | undefined);
+    attr(): Promise<any>;
+    ready(): Promise<void>;
+    protected getProjectType(attr: any, compileType: MiniProgramCore.ProjectType): import("../types").MiniProgramCI.ProjectType;
+    getProjectConfig(): ProjectConfigJSON.IProjectConfigJSON;
+    serialize(): Promise<MiniProgramCore.IProjectSerializeInfo>;
+    abstract init(...args: any[]): void;
+    abstract updateFileAndDirs(...args: any[]): void;
+    updateFiles(): void;
+    updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
+    protected cacheDirName(dirSet: Set<string>, dir: string): void;
+    deleteDirOrFileOfSet(dirSet: Set<string>, fileSet: Set<string>, targetPath: string): void;
+    getTargetPath(prefix?: string, filePath?: string): string;
+    getFilesAndDirs(): {
+        files: string[];
+        dirs: string[];
+    };
+    exists(prefix?: string, filePath?: string): boolean;
+    stat(prefix?: string, filePath?: string): MiniProgramCore.IStat | undefined;
+    getAllFileInfo(prefix?: string): MiniProgramCore.IFileInfos;
+    getFileList(prefix?: string, extName?: string): string[];
+    getSrcFile(prefix: string, filePath: string): Buffer;
+    getFile(prefix: string, filePath: string): Buffer;
+    getJson<T = any>(prefix?: string, filePath?: string): T;
+    getFileSize(prefix?: string, filePath?: string): number;
+    getExtAppid(): Promise<string | void>;
+    onFileChange(type: MiniProgramCore.IWatchEventType, targetPath: string): Promise<void>;
+    clearCache(): void;
+}
+export {};