miniprogram-ci 1.9.26 → 2.0.0

package/dist/@types/types/summer.d.ts

@@ -0,0 +1,161 @@
+/// <reference types="node" />
+import type { RawSourceMap } from 'source-map';
+import * as BabelTypes from '@babel/types';
+import { ICompileOptions } from '..';
+import { MiniProgramCore } from './core';
+export type IBasicCodeExt = 'js' | 'wxml' | 'wxss' | 'json' | 'wxs';
+export declare const BasicCodeExts: readonly ["js", "wxml", "wxss", "json", "wxs"];
+export declare namespace MiniProgramSummer {
+    interface ModuleJSON {
+        code: string | null;
+        map?: SourceMap;
+        path: string;
+        sourcePath?: string;
+        depFileIds?: string[];
+    }
+    interface SummerCache {
+        modules: ModuleJSON[];
+    }
+    interface SummerBuild {
+        cache: SummerCache | undefined;
+        output: {
+            [key in string]: string;
+        };
+        watchFiles: string[];
+    }
+    interface PluginContext {
+        addWatchFile: (absFilePath: string) => void;
+        error: (err: any) => never;
+        runWorkerMethod: (method: string, ...args: any[]) => Promise<any>;
+        rootPath?: string;
+    }
+    type SourceMap = Omit<RawSourceMap, 'version'> & {
+        version: number | string;
+    };
+    enum AstType {
+        Babel = "babel",
+        Acorn = "acorn"
+    }
+    type AstInfo = {
+        ast: AcornNode;
+        type: AstType.Acorn;
+    } | {
+        ast: BabelTypes.File;
+        type: AstType.Babel;
+    };
+    type SourceDescription = {
+        sourceCode: string;
+        inputMap?: SourceMap;
+        astInfo?: AstInfo;
+        largeFile?: boolean;
+    };
+    type GenerateDescription = {
+        code: string;
+        map?: SourceMap | string;
+        helpers?: string[];
+        wrappedByDefine?: boolean;
+        resultType?: MiniProgramCore.IResultType;
+    };
+    interface IPluginProcessInfo {
+        pluginName: string;
+        action: AsyncPluginHooks;
+        options?: Record<string, any>;
+    }
+    interface ILoadResult {
+        targetPath: string;
+        source: SourceDescription;
+        process: IPluginProcessInfo[];
+    }
+    type ITransformResult = ILoadResult;
+    type AsyncPluginHooks = 'load' | 'transform' | 'optimize' | 'generate' | 'compress' | 'sealed';
+    type FirstPluginHooks = 'load' | 'generate';
+    type SequentialPluginHooks = 'transform' | 'optimize' | 'compress';
+    type ParallelPluginHooks = 'sealed';
+    type LoadHook = (this: PluginContext, targetPath: string, sourcePath: string, options: {
+        independentRoot: string;
+        isBabelIgnore: boolean;
+    }) => Promise<ILoadResult | undefined>;
+    type TransformHook = (this: PluginContext, loadResult: ILoadResult, targetPath: string, sourcePath: string, options: {
+        independentRoot: string;
+        isBabelIgnore: boolean;
+    } & ICompileOptions) => Promise<ITransformResult>;
+    interface IGenerateResult extends ITransformResult {
+        target: GenerateDescription;
+    }
+    type GenerateHook = (this: PluginContext, transformResult: ITransformResult, targetPath: string, sourcePath: string, options: {
+        independentRoot: string;
+        isBabelIgnore: boolean;
+    } & ICompileOptions) => Promise<IGenerateResult | undefined>;
+    type OptimizeHook = (this: PluginContext, generatedResult: IGenerateResult, options: ICompileOptions) => Promise<IGenerateResult>;
+    type CompressHook = (this: PluginContext, generatedResult: IGenerateResult, options: ICompileOptions) => Promise<IGenerateResult>;
+    type SealedHook = (this: PluginContext, content: Record<string, string | Buffer>) => Promise<void>;
+    interface PluginHooks {
+        load: LoadHook;
+        transform: TransformHook;
+        generate: GenerateHook;
+        optimize: OptimizeHook;
+        compress: CompressHook;
+        sealed: SealedHook;
+    }
+    interface ResolveExt {
+        json?: string | string[];
+        wxml?: string | string[];
+        wxss?: string | string[];
+        js?: string | string[];
+        wxs?: string | string[];
+    }
+    interface SummerPlugin extends Partial<PluginHooks> {
+        name: string;
+        supportWorker?: boolean;
+        workerMethods?: Record<string, Function>;
+        resolveExt?: ResolveExt;
+    }
+    type SummerPluginOptions = Record<string, any>;
+    interface TypedEventEmitter<T extends {
+        [event: string]: (...args: any) => any;
+    }> {
+        addListener<K extends keyof T>(event: K, listener: T[K]): this;
+        emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): boolean;
+        eventNames(): Array<keyof T>;
+        getMaxListeners(): number;
+        listenerCount(type: keyof T): number;
+        listeners<K extends keyof T>(event: K): Array<T[K]>;
+        off<K extends keyof T>(event: K, listener: T[K]): this;
+        on<K extends keyof T>(event: K, listener: T[K]): this;
+        once<K extends keyof T>(event: K, listener: T[K]): this;
+        prependListener<K extends keyof T>(event: K, listener: T[K]): this;
+        prependOnceListener<K extends keyof T>(event: K, listener: T[K]): this;
+        rawListeners<K extends keyof T>(event: K): Array<T[K]>;
+        removeAllListeners<K extends keyof T>(event?: K): this;
+        removeListener<K extends keyof T>(event: K, listener: T[K]): this;
+        setMaxListeners(n: number): this;
+    }
+    type ChangeEvent = 'create' | 'update' | 'delete';
+    type SummerWatcherEvent = {
+        code: 'START';
+    } | {
+        code: 'BUILD_END';
+        duration: number;
+        output: SummerBuild['output'];
+    } | {
+        code: 'END';
+    };
+    interface SummerWatcher extends TypedEventEmitter<{
+        change: (id: string, change: {
+            event: ChangeEvent;
+        }) => void;
+        close: () => void;
+        event: (event: SummerWatcherEvent) => void;
+        restart: () => void;
+    }> {
+        close(): void;
+    }
+    interface WatcherOptions {
+        buildDelay?: number;
+    }
+    interface AcornNode {
+        end: number;
+        start: number;
+        type: string;
+    }
+}

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

@@ -1,7 +1,11 @@
-import { MiniProgramCI } from '../types';
+import { MiniProgramDevtools } from '../types';
+export declare function getBabelHelperVersion(): string;
+export declare function getBabelHelperDepMap(): {
+    [key: string]: string[];
+};
 export declare function getDefaultPlugins(): Map<any, number | object>;
 export declare function getCustomPlugins(disableList?: string[]): any[];
-export declare function getHelperDeps(helpers: string[], babelRoot: string): any;
+export declare function getHelperDeps(helpers: string[] | object, babelRoot: string): any;
 export declare function getHelperContent(mod: string, babelRoot: string): Promise<string>;
 export declare function isIgnore(babelIgnore: any[], filePath: any): boolean;
 export declare function searchBabelModule(code: string, babelRoot: string): string[];
@@ -15,5 +19,4 @@ export declare function collectBabelHelpers(code: string): {
     [key: string]: boolean;
 };
 export declare function isValidBabelHelperFunc(funcName: string): boolean;
-export declare function getBabelOutputPath(project: any): string;
-export declare function appendBabelHelpers(helperSet: Set<string>, root: string, babelRoot: string, resultMap: MiniProgramCI.IAnyObject): Promise<void[]>;
+export declare function getBabelOutputPath(setting: MiniProgramDevtools.IProjectSetting): string;

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

@@ -4,7 +4,6 @@ declare const hash: any;
 declare const transformSync: any;
 declare const traverse: any;
 declare const parse: any;
-declare const nodePath: any;
 declare const buildBindFunc: (func: any) => any;
 declare const buildWorkletFunc: (func: any) => any;
 declare const globals: Set<string>;

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

@@ -0,0 +1,19 @@
+import { Recorder } from './progressRecorder';
+export interface IEntitlements {
+    'com.apple.developer.associated-domains'?: string;
+}
+export declare function codesignAndExport(projectPath: string, demoIpaPath: string, miniappCacheDir: string, opts: {
+    output: string;
+    entitlements?: IEntitlements;
+    bundleId?: string;
+    certificate?: string;
+    profile?: string;
+    tpnsProfile?: string;
+}, recorder: Recorder, isUsingTpush: boolean, _inLandun?: boolean): Promise<{
+    success: boolean;
+    errMsg?: undefined;
+} | {
+    success: boolean;
+    errMsg: any;
+}>;
+export declare function checkXcodeEnv(recorder?: Recorder): Promise<void>;

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

@@ -1,12 +1,12 @@
 /// <reference types="node" />
-import { AppJSON, IProject, MiniProgramCI } from '../types';
+import { AppJSON, IProject, MiniProgramCore } from '../types';
 export interface IPageInfo {
     path: string;
     root: string;
     name?: string;
 }
 export declare const getAllPages: (appJSON: AppJSON.IAppJSON) => string[];
-export declare const getAllPagesInfo: (appJSON: MiniProgramCI.IAnyObject) => IPageInfo[];
+export declare const getAllPagesInfo: (appJSON: MiniProgramCore.IAnyObject) => IPageInfo[];
 export declare function throwError(options: {
     code?: number;
     msg: string;
@@ -25,5 +25,3 @@ export declare function checkPath(options: {
     checkPathType?: string;
 }): void;
 export declare function getAllTargetTypeFilesWithOtherTypeFilesOfSameName(project: IProject, targetType: string, otherTypes: string[], filter: string): string[];
-export declare function getMiniprogramRoot(projectPath: string): Promise<string>;
-export declare function getRawProjectConfigJson(projectPath: string): Promise<any>;

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

@@ -0,0 +1,3 @@
+import { Recorder } from './progressRecorder';
+export declare function spawnSync(cmd: string, args: string[], opts: any, recorder?: Recorder): Promise<unknown>;
+export declare function spawnSyncExecShell(cmd: string, args: string[], opts: any, recorder?: Recorder): Promise<unknown>;

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

@@ -0,0 +1,22 @@
+export declare class CustomError extends Error {
+    code?: number | string;
+    path?: string;
+    plugin?: string;
+    hook?: string;
+    constructor(error: any);
+    toString(): string;
+    toJSON(): {
+        type: string;
+        message: string;
+        stack: string | undefined;
+        code: string | number | undefined;
+        path: string | undefined;
+        plugin: string | undefined;
+        hook: string | undefined;
+    };
+}
+export declare const CustomErrors: {
+    readonly SUMMER_PLUGIN_ERR: 10045;
+    readonly SUMMER_PLUGIN_CODE_ERR: 10046;
+};
+export declare function makeCustomError(error: string | Error, code?: string | number, path?: string): CustomError;

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

@@ -0,0 +1 @@
+export declare function downloadLargeFile(url: string, savePath: string): Promise<any>;

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

@@ -0,0 +1,2 @@
+export declare function getProcessEnv(): any;
+export declare const isWin: boolean;

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

@@ -0,0 +1,61 @@
+declare class Expression {
+    constructor(content: any);
+    lex(): ({
+        index: number;
+        constant: boolean;
+        text: string;
+        value: string;
+        identifier?: undefined;
+        operator?: undefined;
+    } | {
+        index: number;
+        constant: boolean;
+        text: string;
+        value: number;
+        identifier?: undefined;
+        operator?: undefined;
+    } | {
+        index: number;
+        text: any;
+        identifier: boolean;
+        constant?: undefined;
+        value?: undefined;
+        operator?: undefined;
+    } | {
+        index: number;
+        text: any;
+        constant?: undefined;
+        value?: undefined;
+        identifier?: undefined;
+        operator?: undefined;
+    } | {
+        index: number;
+        text: any;
+        operator: boolean;
+        constant?: undefined;
+        value?: undefined;
+        identifier?: undefined;
+    })[];
+    parse(): (data: any) => any;
+    expect(text: any): any;
+    consume(text: any): any;
+    expression(): any;
+    ternary(): any;
+    binary(left: any, op: any, right: any): (data: any) => any;
+    unary(): any;
+    logicalOR(): any;
+    logicalAND(): any;
+    equality(): any;
+    relational(): any;
+    additive(): any;
+    multiplicative(): any;
+    primary(): any;
+    fieldAccess(object: any): (data: any) => any;
+    objectIndex(object: any): (data: any) => any;
+    functionCall(func: any, context: any): (data: any) => any;
+    array(): (data: any) => any[];
+    object(): (data: any) => {};
+    identifier(): (data: any) => any;
+    constant(): (data: any) => any;
+}
+export default Expression;

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

@@ -1,3 +1,3 @@
-import { FSAgent } from './fsagent';
-declare const _default: FSAgent;
-export default _default;
+import { FSAgent, IFSAgent } from './fsagent';
+export declare const fsAgent: FSAgent;
+export declare function setFSAgent(agent: IFSAgent): void;

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 export interface IFSAgent {
-    stat(path: string): Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
+    stat: (path: string) => Promise<{
+        isFile: () => boolean;
+        isDirectory: () => boolean;
         mode: number;
         size: number;
         atimeMs: number;
@@ -10,18 +10,18 @@ export interface IFSAgent {
         ctimeMs: number;
         birthtimeMs: number;
     }>;
-    readFile(path: string): Promise<Buffer>;
-    exists(path: string): Promise<boolean>;
-    writeFile(path: string, data: any, options: string | null): Promise<void>;
-    readdir(path: string): Promise<string[]>;
+    readFile: (path: string) => Promise<Buffer>;
+    exists: (path: string) => Promise<boolean>;
+    writeFile: (path: string, data: any, options: string | null) => Promise<void>;
+    readdir: (path: string) => Promise<string[]>;
 }
 export declare class FSAgent implements IFSAgent {
     private _agent;
     constructor(agent?: IFSAgent);
     setAgent(agent: IFSAgent): void;
     stat(target: string): Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
+        isFile: () => boolean;
+        isDirectory: () => boolean;
         mode: number;
         size: number;
         atimeMs: number;

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

@@ -0,0 +1,2 @@
+import { Recorder } from './progressRecorder';
+export declare function generateIpa(demoIpaPath: string, recorder?: Recorder): Promise<string>;

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

@@ -0,0 +1,11 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../types';
+interface IProjectLike {
+    setting: MiniProgramDevtools.IProjectSetting;
+}
+export declare function getHelperOutputPath(setting: MiniProgramDevtools.IProjectSetting): string;
+export declare function getHelperContent(setting: MiniProgramDevtools.IProjectSetting, mod: string): Promise<string>;
+export declare function getHelperDeps(setting: MiniProgramDevtools.IProjectSetting, helpers: Set<string>): string[];
+export declare function appendHelpers(project: IProjectLike, helperSet: Set<string>, root: string, resultMap: MiniProgramCore.IAnyObject): Promise<void[]>;
+export declare function isValidHelperFunc(funcName: string): "swc" | "babel" | undefined;
+export declare function getHelperName(setting: MiniProgramDevtools.IProjectSetting, mod: string): string;
+export {};

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

@@ -1,6 +1,6 @@
-import { MiniProgramCI } from '../types';
+import { MiniProgramCore } from '../types';
 export type InterruptiblePromise<T> = Promise<T> & {
-    abort: MiniProgramCI.FN<void>;
+    abort: MiniProgramCore.FN<void>;
 };
 export declare const AbortEvent = "abort";
 export declare abstract class InterruptibleTask {
@@ -8,8 +8,8 @@ export declare abstract class InterruptibleTask {
     protected _args: any[];
     protected _promise: Promise<any>;
     constructor(...args: any[]);
-    then(onResolve: MiniProgramCI.FN<void>, onReject?: MiniProgramCI.FN<void>): Promise<void>;
-    catch(onReject: MiniProgramCI.FN<void>): Promise<any>;
+    then(onResolve: MiniProgramCore.FN<void>, onReject?: MiniProgramCore.FN<void>): Promise<void>;
+    catch(onReject: MiniProgramCore.FN<void>): Promise<any>;
     abort(): void;
     abstract run(...args: any[]): Promise<any>;
 }

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

@@ -1,6 +1,6 @@
-import { MiniProgramCI } from "../types";
+import { MiniProgramCore } from "../types";
 declare const _default: {
-    parser: MiniProgramCI.IAnyObject;
+    parser: MiniProgramCore.IAnyObject;
     parse: () => any;
 };
 export = _default;

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

@@ -13,6 +13,7 @@ declare const _default: {
         JSON_SHOULD_NOT_START_WITH: import("./fomatable_string").FormatableString;
         JSON_SHOULD_NOT_CONTAIN: import("./fomatable_string").FormatableString;
         NOT_FOUND: import("./fomatable_string").FormatableString;
+        COMPONENT_NOT_FOUND: import("./fomatable_string").FormatableString;
         NOT_FOUND_IN_ROOT_DIR: import("./fomatable_string").FormatableString;
         MINIPROGRAM_APP_JSON_NOT_FOUND: import("./fomatable_string").FormatableString;
         PLUGIN_JSON_NOT_FOUND: import("./fomatable_string").FormatableString;
@@ -36,7 +37,12 @@ declare const _default: {
         JSON_RESOLVE_ALIAS_INCLUDE_STAR: import("./fomatable_string").FormatableString;
         JSON_RESOLVE_ALIAS_SHOULD_NOT_START_WITH: import("./fomatable_string").FormatableString;
         JSON_REQUIRED_PRIVATE_INFOS_MUTUALLY_EXCLUSIVE: import("./fomatable_string").FormatableString;
+        APP_JSON_SKYLINE_WINDOW_TIPS: import("./fomatable_string").FormatableString;
         APP_JSON_SHOULD_SET_LAZYCODELOADING: import("./fomatable_string").FormatableString;
+        APP_JSON_SHOULD_SET_RENDEREROPTIONS: import("./fomatable_string").FormatableString;
+        JSON_SHOULD_SET_RENDEREROPTIONS: import("./fomatable_string").FormatableString;
+        JSON_SHOULD_SET_RENDEREROPTIONS_SKYLINE: import("./fomatable_string").FormatableString;
+        JSON_SHOULD_SET_COMPONENTFRAMEWORK_SKYLINE: import("./fomatable_string").FormatableString;
         PAGE_JSON_SHOULD_SET_DISABLESCROLL_TRUE: import("./fomatable_string").FormatableString;
         PAGE_JSON_SHOULD_SET_NAVIGATIONSTYLE_CUSTOM: import("./fomatable_string").FormatableString;
         CONTENT_EXIST: import("./fomatable_string").FormatableString;
@@ -87,7 +93,19 @@ declare const _default: {
         SUMMER_COMPILE_PLUGIN_PAGE_JSON: import("./fomatable_string").FormatableString;
         SUMMER_COMPILE: import("./fomatable_string").FormatableString;
         SUMMER_COMPILE_MINIPROGRAM: import("./fomatable_string").FormatableString;
+        SUMMER_COMPILE_MINIGAME: import("./fomatable_string").FormatableString;
         SUMMER_COMPILE_PLUGIN: import("./fomatable_string").FormatableString;
+        FILE_EXT_FORMAT_ERROR: import("./fomatable_string").FormatableString;
+        THEME_JSON_VALUE_SHOULD_BE: import("./fomatable_string").FormatableString;
+        JSON_VARIABLE_VALUE_NOT_FOUND: import("./fomatable_string").FormatableString;
+        THEME_JSON_SHOULD_EXIST: import("./fomatable_string").FormatableString;
+        PARSEERR_ENTRANCE_PAGE_ERROR: import("./fomatable_string").FormatableString;
+        PARSEERR_ENTRANCE_FILE_ERROR: import("./fomatable_string").FormatableString;
+        COMPILE_WXML_ERROR_CONSOLE: import("./fomatable_string").FormatableString;
+        COMPILE_WXSS_ERROR_CONSOLE: import("./fomatable_string").FormatableString;
+        RELATED_NODE_MODULES_NOT_FOUND: import("./fomatable_string").FormatableString;
+        PACKAGE_JSON_PATH_IN_VALID: import("./fomatable_string").FormatableString;
+        ACCOUNT_CARD_PACKAPGE_IN_VALID: import("./fomatable_string").FormatableString;
     };
     setLocale: (tag: string) => void;
     getLocale: () => string;

package/dist/@types/utils/locales/zh.d.ts

@@ -13,6 +13,7 @@ declare const _default: {
     JSON_SHOULD_NOT_START_WITH: FormatableString;
     JSON_SHOULD_NOT_CONTAIN: FormatableString;
     NOT_FOUND: FormatableString;
+    COMPONENT_NOT_FOUND: FormatableString;
     NOT_FOUND_IN_ROOT_DIR: FormatableString;
     MINIPROGRAM_APP_JSON_NOT_FOUND: FormatableString;
     PLUGIN_JSON_NOT_FOUND: FormatableString;
@@ -36,7 +37,12 @@ declare const _default: {
     JSON_RESOLVE_ALIAS_INCLUDE_STAR: FormatableString;
     JSON_RESOLVE_ALIAS_SHOULD_NOT_START_WITH: FormatableString;
     JSON_REQUIRED_PRIVATE_INFOS_MUTUALLY_EXCLUSIVE: FormatableString;
+    APP_JSON_SKYLINE_WINDOW_TIPS: FormatableString;
     APP_JSON_SHOULD_SET_LAZYCODELOADING: FormatableString;
+    APP_JSON_SHOULD_SET_RENDEREROPTIONS: FormatableString;
+    JSON_SHOULD_SET_RENDEREROPTIONS: FormatableString;
+    JSON_SHOULD_SET_RENDEREROPTIONS_SKYLINE: FormatableString;
+    JSON_SHOULD_SET_COMPONENTFRAMEWORK_SKYLINE: FormatableString;
     PAGE_JSON_SHOULD_SET_DISABLESCROLL_TRUE: FormatableString;
     PAGE_JSON_SHOULD_SET_NAVIGATIONSTYLE_CUSTOM: FormatableString;
     CONTENT_EXIST: FormatableString;
@@ -87,6 +93,18 @@ declare const _default: {
     SUMMER_COMPILE_PLUGIN_PAGE_JSON: FormatableString;
     SUMMER_COMPILE: FormatableString;
     SUMMER_COMPILE_MINIPROGRAM: FormatableString;
+    SUMMER_COMPILE_MINIGAME: FormatableString;
     SUMMER_COMPILE_PLUGIN: FormatableString;
+    FILE_EXT_FORMAT_ERROR: FormatableString;
+    THEME_JSON_VALUE_SHOULD_BE: FormatableString;
+    JSON_VARIABLE_VALUE_NOT_FOUND: FormatableString;
+    THEME_JSON_SHOULD_EXIST: FormatableString;
+    PARSEERR_ENTRANCE_PAGE_ERROR: FormatableString;
+    PARSEERR_ENTRANCE_FILE_ERROR: FormatableString;
+    COMPILE_WXML_ERROR_CONSOLE: FormatableString;
+    COMPILE_WXSS_ERROR_CONSOLE: FormatableString;
+    RELATED_NODE_MODULES_NOT_FOUND: FormatableString;
+    PACKAGE_JSON_PATH_IN_VALID: FormatableString;
+    ACCOUNT_CARD_PACKAPGE_IN_VALID: FormatableString;
 };
 export default _default;

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

@@ -1,20 +1,14 @@
-declare const _default: {
-    info: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    log: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    warn: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    error: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
+export interface ILogger {
+    success: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
     debug: (...args: any[]) => void;
-};
-export default _default;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+export declare const success: (...args: any[]) => void;
+export declare const info: (...args: any[]) => void;
+export declare const log: (...args: any[]) => void;
+export declare const debug: (...args: any[]) => void;
+export declare const warn: (...args: any[]) => void;
+export declare const error: (...args: any[]) => void;

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

@@ -0,0 +1,17 @@
+import { MiniProgramCore } from '../types';
+export type IBuildLogType = 'doing' | 'success' | 'error';
+export interface IMessageHub {
+    showStatus?: (id: number, message: string, type?: 'info' | 'success' | 'fail') => void;
+    hideStatus?: (id: number) => void;
+    showBuildLog: (msgId: string, type: IBuildLogType, text: string) => void;
+}
+export declare class MessageHub {
+    private devtoolMessagehub;
+    constructor(devtoolMessagehub: IMessageHub);
+    showStatus(id: number, message: string, type?: string): void;
+    hideStatus(id: number): void;
+    showBuildLog(id: string, type: IBuildLogType, message: string): void;
+}
+export interface IConsoleDisplay {
+    display: MiniProgramCore.FN<void>;
+}

package/dist/@types/utils/miniapp-builder.d.ts

@@ -0,0 +1,68 @@
+import { IMiniApp } from '../types';
+import { Recorder } from './progressRecorder';
+import { IEntitlements } from './codesign';
+export declare const DEFAULT_BUNDLE_ID = "com.tencent.devtoolssaaademo.db";
+export declare const miniappSinTypes: {
+    appleId: {
+        type: string;
+    };
+    certificate: {
+        type: string;
+    };
+};
+interface IAppleIdSignAndInstall {
+    bundleId?: string;
+    projectPath: string;
+    ipaPath: string;
+    deviceId?: string;
+    appleId?: string;
+    password?: string;
+    entitlements?: IEntitlements;
+    install?: boolean;
+    output?: string;
+    udid?: string;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+}
+interface ICertificateSignAndInstall {
+    projectPath: string;
+    ipaPath: string;
+    miniappCacheDirPath: string;
+    deviceId?: string;
+    entitlements?: IEntitlements;
+    install?: boolean;
+    output?: string;
+    udid?: string;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+}
+interface ISignAndInstallResult {
+    success: boolean;
+    errMsg?: string;
+}
+interface IGetMiniAppBuilderOts {
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+    recorder?: Recorder;
+}
+interface IGetDevicesOpts {
+    projectPath?: string;
+    miniappDirPath?: string;
+    devtoolsVersion?: string;
+    recorder?: Recorder;
+}
+type IClearCacheOpts = IGetDevicesOpts & {
+    type: 'appleId' | 'certificate';
+};
+export declare function getIOSDevices(opts: IGetDevicesOpts): Promise<IMiniApp.IOSDevice[]>;
+export declare function clearCache(opts: IClearCacheOpts): Promise<void>;
+export declare function doAppleIdSignAndInstallOrExport(opts: IAppleIdSignAndInstall, otherOpts: IGetMiniAppBuilderOts): Promise<ISignAndInstallResult>;
+export declare function doCertificateSignAndInstallOrExport(opts: ICertificateSignAndInstall, otherOpts: IGetMiniAppBuilderOts): Promise<ISignAndInstallResult>;
+export declare function signAndInstallOrExport(projectPath: string, demoIpaPath: string, miniappCacheDirPath: string, certificateInfo: IMiniApp.ISignCertficateInfo, opts: {
+    deviceId?: string;
+    install?: boolean;
+    output?: string;
+    entitlements?: IEntitlements;
+    bundleId?: string;
+}, otherOpts: IGetMiniAppBuilderOts): Promise<void>;
+export {};