miniprogram-ci 2.0.9 → 2.0.11

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+#### 2.0.11
+ - `fix` 修复 压缩wxml出现的问题
+ - `fix` 修复 独立分包entry文件被过滤的问题
+#### 2.0.10
+ - `fix` 修复 schema d.ts路径问题
 #### 2.0.9
  - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
 #### 2.0.8

package/README.md

@@ -8,6 +8,11 @@ miniprogram-ci 从 1.0.28 开始支持第三方平台开发的上传和预览，
 
 ## 最近变更
 
+#### 2.0.11
+ - `fix` 修复 压缩wxml出现的问题
+ - `fix` 修复 独立分包entry文件被过滤的问题
+#### 2.0.10
+ - `fix` 修复 schema d.ts路径问题
 #### 2.0.9
  - `fix` 修复 ts，sass 等文件在某些情况无法编译的问题
 #### 2.0.8

package/dist/@types/ci/upload.d.ts

@@ -9,7 +9,6 @@ interface IUploadOptions {
     threads?: number;
     useCOS?: boolean;
     onProgressUpdate?: (task: MiniProgramCI.ITaskStatus | string) => void;
-    allowIgnoreUnusedFiles?: boolean;
 }
 export interface IInnerUploadOptions extends IUploadOptions {
     test?: boolean;

package/dist/@types/ci/utils/progressupdate.d.ts

@@ -0,0 +1,2 @@
+import { MiniProgramCI, MiniProgramCore } from '../../types';
+export declare const transProgressUpdate: (progressUpdate: (taskStatus: MiniProgramCI.ITaskStatus | string) => void) => (coreTaskStatus: MiniProgramCore.ITaskStatus) => void;

package/dist/@types/common/code-analyse/index.d.ts

@@ -359,6 +359,7 @@ declare interface ISubpackageItem {
     useExtendedLib: {
         [index: string]: boolean | string;
     };
+    entry?: string;
 }
 
 /**

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

@@ -1,5 +1,5 @@
 import { IProject } from '../types';
-export declare const CI_VERSION = "2.0.9";
+export declare const CI_VERSION = "2.0.11";
 export declare const PARAM_ERROR = 10000;
 export declare const WXML_NOT_FOUND = 10007;
 export declare const JS_NOT_FOUND = 10008;

package/dist/@types/modules/corecompiler/baseCompiler.d.ts

@@ -31,6 +31,11 @@ export declare abstract class BaseCoreCompiler {
             disableUseStrict?: boolean;
             compileWorklet?: boolean;
         };
+        resultType?: MiniProgramCore.IResultType;
+    }): Promise<any>;
+    compileJSList(options: {
+        root: string;
+        fileList: string[];
     }): Promise<any>;
     compile(options: MiniProgramCore.ICompileOptions): any;
     clearCache(): void;

package/dist/@types/modules/corecompiler/original/validate/schemaValidate.d.ts

@@ -1,4 +1,4 @@
-import { ISchema, IValidateResult } from '../../../../../../schema/dist';
+import { ISchema, IValidateResult } from '../../../../schema/dist';
 export declare const config: {
     [key: string]: ISchema;
 };

package/dist/@types/modules/corecompiler/original/workerThread/task/minifywxml.d.ts

@@ -1,32 +1,34 @@
 /// <reference types="node" />
-import { MiniProgramDevtools } from '../../../../../types';
 interface ICompileData {
-    projectPath: string;
-    root: string;
+    code: string | Buffer;
     filePath: string;
-    setting: MiniProgramDevtools.IProjectSetting;
-    code: Buffer;
+    root?: string;
+    setting?: IMinifySetting;
 }
-declare enum TokenType {
-    ATTR = 0,
-    STRING1 = 1,
-    STRING2 = 2,
-    OTHERS = 3
+export interface IMinifySetting {
+    collapseWhitespace?: boolean;
+    conservativeCollapse?: boolean;
+    preserveLineBreaks?: boolean;
 }
-declare class Token {
-    type: TokenType;
-    value: string;
-    constructor(type: TokenType, value: string);
+export declare class TemplateTokenizer {
+    private tokens?;
+    constructor(src: string, path: string);
+    toString(): string;
+    private generateTokens;
+    private m_pSrc;
+    private path;
+    private machine;
 }
-declare class Tokenizer {
+export declare class StyleAttrValueTokenizer {
+    private tokens?;
     constructor(src: string, path: string);
-    generateTokens(output: Token[]): number;
+    toString(): string;
+    private generateTokens;
     private m_pSrc;
     private path;
     private machine;
 }
-declare function generateWXMLFromTokens(tokens: Token[]): string;
-declare function minifyWXML(data: ICompileData): Promise<{
+export declare function minifyWXML(data: ICompileData): Promise<{
     error: null;
     code: string;
 } | {
@@ -37,10 +39,4 @@ declare function minifyWXML(data: ICompileData): Promise<{
     };
     code?: undefined;
 }>;
-declare const _default: {
-    minifyWXML: typeof minifyWXML;
-    Tokenizer: typeof Tokenizer;
-    generateWXMLFromTokens: typeof generateWXMLFromTokens;
-    Token: typeof Token;
-};
-export = _default;
+export {};

package/dist/@types/modules/corecompiler/originalCompiler.d.ts

@@ -55,6 +55,7 @@ export declare class OriginalCompiler extends BaseCoreCompiler {
             compileWorklet?: boolean;
         };
         onProgressUpdate: any;
+        resultType?: MiniProgramCore.IResultType;
     }): Promise<{
         filePath: string;
         code: string;

package/dist/@types/modules/corecompiler/processHandler.d.ts

@@ -1,24 +1,5 @@
 import { MiniProgramDevtools } from '../../types';
-interface IProcessMsg {
-    type: 'progress';
-    id: number | string;
-    taskId: number;
-    status: string;
-    message: string;
-}
-interface IResponseMsg {
-    type: 'response';
-    id: number | string;
-    data: any;
-    error?: {
-        code: number;
-        message: string;
-        stack: string;
-        path: string;
-    };
-}
-type ICallbackMsg = IProcessMsg | IResponseMsg;
 export declare function initHandler(message: MiniProgramDevtools.InitMsg): Promise<void>;
 export declare function destroy(): Promise<void>;
-export declare function messageHandler(message: MiniProgramDevtools.SummerProcessMessage, onProgressUpdate?: MiniProgramDevtools.ProgressUpdate): Promise<ICallbackMsg | undefined>;
-export {};
+export declare const onMessage: (fn: (...args: any[]) => any) => void;
+export declare function messageHandler(message: MiniProgramDevtools.SummerProcessMessage): Promise<void>;

package/dist/@types/modules/corecompiler/summer/graph/basegraph.d.ts

@@ -83,6 +83,7 @@ export declare abstract class BaseGraph {
     }): Promise<MiniProgramDevtools.CodeFiles>;
     getProdCodeByFileList(recorder: Recorder, options: {
         fileList: string[];
+        resultType?: MiniProgramCore.IResultType;
     }): Promise<MiniProgramDevtools.CodeFiles>;
     abstract getDevCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
     abstract getProdCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;

package/dist/@types/modules/corecompiler/summer/module.d.ts

@@ -21,23 +21,29 @@ export default class Module {
     readonly path: string;
     readonly sourcePath: string;
     fileType: FileType;
-    md5: string;
-    json: any;
-    error?: CustomError | Error;
-    jsTag?: JsTag;
-    source?: MiniProgramSummer.SourceDescription;
-    target?: MiniProgramSummer.GenerateDescription;
-    processInfo?: MiniProgramSummer.IPluginProcessInfo[];
+    private _jsTag?;
+    private _error;
+    private loadResult?;
+    private generateResultPromise;
     depFiles: string[];
     independentRoot: string;
-    loadingPromise: Promise<Boolean> | undefined;
-    loadStart: number;
-    loadEnd: number;
+    isBabelIgnore: boolean;
+    private generatedTS;
     constructor(graph: BaseGraph, path: string, sourcePath: string, fileType: FileType);
-    setError(error: CustomError | Error): void;
-    setResult(generateResult: MiniProgramSummer.IGenerateResult): void;
-    toCodeFile(): MiniProgramDevtools.CodeFile | MiniProgramDevtools.CodeError;
-    toGenerateResult(): MiniProgramSummer.IGenerateResult;
+    private transResultType;
+    getGeneratedTS(resultType: MiniProgramCore.IResultType): number;
+    setError(resultType: MiniProgramCore.IResultType, error: CustomError | Error): void;
+    getError(resultType: MiniProgramCore.IResultType): Error | CustomError | undefined;
+    getJsTag(): Promise<JsTag | undefined>;
+    getSource(): Promise<MiniProgramSummer.SourceDescription>;
+    getMd5(): Promise<string>;
+    setLoadingPromise(promise: Promise<MiniProgramSummer.ILoadResult>): void;
+    getLoadingPromise(): Promise<MiniProgramSummer.ILoadResult> | undefined;
+    setGeneratingPromise(resultType: MiniProgramCore.IResultType, promise: Promise<MiniProgramSummer.IGenerateResult>): void;
+    getGeneratingPromise(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IGenerateResult> | undefined;
+    getProcessInfo(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IPluginProcessInfo[] | undefined>;
+    toCodeFile(resultType: MiniProgramCore.IResultType): Promise<MiniProgramDevtools.CodeFile | MiniProgramDevtools.CodeError>;
+    toGenerateResult(resultType: MiniProgramCore.IResultType): Promise<MiniProgramSummer.IGenerateResult | MiniProgramDevtools.CodeError>;
     toJSON(): MiniProgramSummer.ModuleJSON;
     addWatchFile(file: string): void;
 }

package/dist/@types/modules/corecompiler/summerCompiler.d.ts

@@ -15,14 +15,14 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     private _filterFactory?;
     readonly isSummer = true;
     subProcessManager: SubProcessProxy | undefined;
-    private codeCache;
     private promiseCache;
     private _taskCache;
     private messageHub;
+    private progressUpdateFromCompileOptions?;
     _status: MiniProgramDevtools.ICompilerStatus | undefined;
     private _eventAdded;
     private _locale;
-    private codeCacheByPath;
+    private devCodeCacheByPath;
     constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub, analyzer: Analyzer, _filterFactory?: MiniProgramDevtools.IFilterFactory | undefined);
     get status(): MiniProgramDevtools.ICompilerStatus | undefined;
     protected init(): Promise<void>;
@@ -41,7 +41,6 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     _getPackageFiles: (graphId: import("../../types").MiniProgramCI.ProjectType, root: string, resultType?: MiniProgramCore.IResultType) => Promise<FileInfo[]>;
     private filterFactory;
     private getCodeByFileList;
-    private getCode;
     getExtJSON(): Promise<ExtJSON.IExtJSON>;
     getAppJSON(): Promise<any>;
     getGameJSON(): Promise<any>;
@@ -88,7 +87,6 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     compileJSList(options: {
         root: string;
         fileList: string[];
-        babelRoot: string;
     }): Promise<{
         isLargeFile?: boolean | undefined;
         isBabelIgnore?: boolean | undefined;
@@ -96,6 +94,7 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         filePath: string;
         code: string;
         map: string | import("../../types").MiniProgramSummer.SourceMap | undefined;
+        mtime: number | undefined;
     }[]>;
     compileJS(options: {
         root: string;
@@ -103,6 +102,7 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         babelRoot: string;
         sourceCode?: string;
         setting: MiniProgramDevtools.IProjectSetting;
+        resultType?: MiniProgramCore.IResultType;
     }): Promise<{
         isLargeFile?: boolean | undefined;
         isBabelIgnore?: boolean | undefined;
@@ -110,6 +110,7 @@ export declare class SummerCompiler extends BaseCoreCompiler {
         filePath: string;
         code: string;
         map: string | import("../../types").MiniProgramSummer.SourceMap | undefined;
+        mtime: number | undefined;
     }>;
     compile(options: MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.ICompileResult>;
     private compileOther;

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

@@ -27,12 +27,14 @@ export declare class Builder {
     private _options;
     private _checkReadyTask?;
     private _getSummerCompilerTask?;
+    private _getPrecompileProjectTask?;
     private _originalCompiler;
     private _analyzer?;
     constructor(project: MiniProgramCI.IProject, opts: IBuilderOptions);
     getCompiler(): Promise<any>;
     getAnalyzer(): Promise<Analyzer>;
     getPreCompileProject(): Promise<PreCompileProject>;
+    private _getPreCompileProject;
     getPreCompiler(): Promise<PreCompiler>;
     getSummerCompiler(): Promise<any>;
     private _getSummerCompiler;

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

@@ -28,6 +28,7 @@ export declare class NativeCompiler {
     buildAndroidPlugin(opts: IMiniApp.IAndroidBuildPluginArgs): Promise<void>;
     buildIOSPlugin(opts: IMiniApp.IBuildPluginIOSFrameworkArgs): Promise<void>;
     packIOSCloudBuildMaterial(opts: IMiniApp.IIOSBuildCloudGenMaterialArgs): Promise<string>;
+    initUSBConnectionProcess(): Promise<void>;
     destroy(): void;
 }
 export {};

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

@@ -3,6 +3,12 @@ import { IMiniApp, MiniProgramCore } from '../../../types';
 import { IEntitlements } from '../../../utils/codesign';
 import II18NInfo = IMiniApp.II18NInfo;
 type ITheme = 'Light' | 'LightSpecial' | 'Dark' | 'DarkSpecial' | 'Default';
+type IOpenMimeTypes = {
+    CFBundleTypeName: string;
+    LSHandlerRank: 'Owner' | 'Default' | 'Alternate' | 'None';
+    CFBundleTypeRole: 'Editor' | 'Viewer' | 'Shell' | 'None';
+    LSItemContentTypes: string[];
+}[];
 export declare const remoteBuildProjectMaterialAbsoluteCacheDir = "__absoluteFile";
 export interface IBuildCloudResult {
     projectPath: string;
@@ -21,6 +27,7 @@ declare class buildCloudManager {
     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;
+    validateCFBundleDocumentTypes(openMimeTypes: IOpenMimeTypes, recorder: Recorder): boolean;
     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>;
@@ -28,8 +35,8 @@ declare class buildCloudManager {
     updateIOSIcons(projectPath: string, demoIpaPath: string, miniappCacheDirPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, isPublish: boolean, recorder: Recorder): Promise<void>;
     replaceLaunchScreenImage(storyboardPath: string, newScreenImagePath: string, oldScreenImageName: string, recorder: Recorder, projectPath: string, demoIpaPath: string): string | undefined;
     updateSplashScreen(projectPath: string, demoIpaPath: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder, theme: ITheme | undefined, i18nInfo: II18NInfo): Promise<void>;
-    genUseExtendedSdk(iosMiniappJson: MiniProgramCore.IStringKeyMap): MiniProgramCore.IStringKeyMap<any>;
-    updateExtendedSdk(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, sdkPath: string, arch: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, recorder: Recorder): Promise<void>;
+    genUseExtendedSdk(iosMiniappJson: MiniProgramCore.IStringKeyMap, debugInfo?: IMiniApp.IDebugInfo): MiniProgramCore.IStringKeyMap<any>;
+    updateExtendedSdk(bindAppInfo: MiniProgramCore.IStringKeyMap, demoIpaPath: string, sdkPath: string, arch: string, iosMiniappJson: MiniProgramCore.IStringKeyMap, debugInfo: IMiniApp.IDebugInfo | undefined, 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;

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

@@ -1,5 +1,6 @@
 import { Recorder } from '../../../utils/progressRecorder';
 import { IMiniApp } from '../../../types';
+import { IGetMiniAppBuilderOts } from '../../../utils/miniapp-builder';
 import II18NInfo = IMiniApp.II18NInfo;
 interface IProjectMaterialPathMap {
     projectMiniappJson: string;
@@ -32,6 +33,7 @@ export declare class IOSUtils {
     genProjectMaterialMap(projectPath: string, matrialDistPath: string, buildArgs: IMiniApp.IIOSBuildCloudGenMaterialArgs, recorder: Recorder): Promise<IProjectMaterialPathMap>;
     codesignIOSApp(args: IMiniApp.CodesignIpaArgs, recorder: Recorder): Promise<void>;
     packIOSCloudBuildMaterial(args: IMiniApp.IIOSBuildCloudGenMaterialArgs, recorder: Recorder): Promise<void>;
+    initUSBConnectionProcess(opts: IGetMiniAppBuilderOts, recorder: Recorder): Promise<void>;
     private launchSimulator;
     private runOnSimulatorCloud;
     private runOnSimulatorLocal;

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

@@ -36,6 +36,9 @@ export declare class NativeCompiler {
         targetPlatform: MiniProgramCore.ITargetPlatform;
         opts: IMiniApp.IIOSBuildCloudGenMaterialArgs;
     }, recorder: Recorder): Promise<any>;
+    initUSBConnectionProcess(data: {
+        targetPlatform: MiniProgramCore.ITargetPlatform;
+    }, recorder: Recorder): Promise<any>;
     codesignIOSApp(data: {
         targetPlatform: MiniProgramCore.ITargetPlatform;
         opts: IMiniApp.CodesignIpaArgs;

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { MiniProgramCI, MiniProgramCore } from '../../../types';
 import { BaseConditionCompiler } from './compiler/base';
-import { IMessageHub } from '../../../utils/messageHub';
+import { IConsoleDisplay, IMessageHub } from '../../../utils/messageHub';
 interface IConditionCompiler {
     targetPlatform: MiniProgramCore.ITargetPlatform;
     targetPlatformDefines?: MiniProgramCore.ITargetPlatformDefine;
@@ -12,7 +12,8 @@ export declare class ConditionCompiler {
     };
     project: MiniProgramCI.IProject;
     devtoolMessagehub?: IMessageHub;
-    constructor(project: MiniProgramCI.IProject, devtoolMessagehub?: IMessageHub);
+    consoleDisplay?: IConsoleDisplay;
+    constructor(project: MiniProgramCI.IProject, devtoolMessagehub: IMessageHub | undefined, consoleDisplay: IConsoleDisplay | undefined);
     getCompiler(extname: string, opts: IConditionCompiler): BaseConditionCompiler;
     shouldCompile(filePath: string): boolean;
     compileFile(filePath: string, opts?: IConditionCompiler): Buffer;

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

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

package/dist/@types/schema/@types/appjson.d.ts

@@ -0,0 +1,215 @@
+export interface IPluginConfig {
+    provider: string;
+    version: string;
+    path?: string;
+    export?: string;
+    genericsImplementation?: {
+        [pageName: string]: {
+            [componentName: string]: string;
+        };
+    };
+}
+export interface ISubPackageItem {
+    independent?: boolean;
+    name?: string;
+    entry?: string;
+    root: string;
+    pages: string[];
+    plugins?: {
+        [alias: string]: IPluginConfig;
+    };
+    useExtendedLib?: {
+        [key: string]: boolean | string;
+    };
+}
+export interface IWindow {
+    backgroundColorTop?: string;
+    backgroundColorBottom?: string;
+    backgroundColorContent?: string;
+    backgroundColor?: string;
+    enablePullDownRefresh?: boolean;
+    navigationBarTextStyle?: 'black' | 'white' | `@${string}`;
+    navigationBarTitleText?: string;
+    navigationStyle?: 'default' | 'custom';
+    backgroundTextStyle?: 'dark' | 'light' | `@${string}`;
+    onReachBottomDistance?: number;
+    pageOrientation?: 'portrait' | 'auto' | 'landscape';
+    navigationBarBackgroundColor?: string;
+    renderingMode?: 'seperated' | 'mixed';
+    restartStrategy?: 'homePage' | 'homePageAndLatestPage';
+    visualEffectInBackground?: 'hidden' | 'none';
+    initialRenderingCache?: 'static' | 'dynamic';
+    handleWebviewPreload?: 'static' | 'manual' | 'auto';
+    homeButton?: boolean;
+}
+export interface ITabBar {
+    custom?: boolean;
+    list: Array<{
+        pagePath: string;
+        text?: string;
+        iconPath?: string;
+        selectedIconPath?: string;
+        renderer?: 'skyline' | 'webview' | 'cover-view';
+    }>;
+    borderStyle?: 'black' | 'white' | `@${string}`;
+    position?: 'bottom' | 'top';
+    color?: string;
+    selectedColor?: string;
+    backgroundColor?: string;
+}
+export interface IAppBar {
+    custom?: boolean;
+}
+export interface ISkylineFeatures {
+    defaultContentBox?: boolean;
+    defaultDisplayBlock?: boolean;
+}
+export interface ISupportMaterial {
+    materialType: string;
+    name: string;
+    desc: string;
+    path: string;
+}
+export type IRequirePrivateInfos = Array<'getFuzzyLocation' | 'getLocation' | 'onLocationChange' | 'startLocationUpdate' | 'startLocationUpdateBackground' | 'chooseLocation' | 'choosePoi' | 'chooseAddress'>;
+type IPlatform = 'mini-ios' | 'mini-android' | 'mini-weixin';
+interface IAppJSONStaticConfig {
+    pattern: string;
+    platforms: IPlatform[];
+}
+interface IOriginAppJSON {
+    __warning__?: string;
+    window?: IWindow;
+    plugins?: {
+        [key: string]: IPluginConfig;
+    };
+    entryPagePath?: string;
+    permission?: {
+        'scope.userLocation'?: {
+            desc: string;
+        };
+        'scope.userFuzzyLocation'?: {
+            desc: string;
+        };
+    };
+    workers?: string | {
+        path: string;
+        isSubpackage: boolean;
+    };
+    subPackages?: Array<ISubPackageItem>;
+    subpackages?: Array<ISubPackageItem>;
+    preloadRule?: {
+        [key: string]: {
+            network?: 'all' | 'wifi';
+            packages: Array<string>;
+        };
+    };
+    usingComponents?: {
+        [key: string]: string;
+    };
+    componentPlaceholder?: {
+        [key: string]: string;
+    };
+    tabBar?: ITabBar;
+    appBar?: IAppBar;
+    requiredBackgroundModes?: Array<string>;
+    mimeTypeDeclarations?: {
+        [key: string]: Array<string>;
+    };
+    networkTimeout?: {
+        request?: number;
+        connectSocket?: number;
+        uploadFile?: number;
+        downloadFile?: number;
+    };
+    debug?: boolean;
+    resizable?: boolean;
+    displayMode?: 'mobile' | 'pad' | 'desktop';
+    frameset?: boolean;
+    functionalPages?: boolean | {
+        independent: boolean;
+    };
+    cloud?: boolean;
+    cloudVersion?: string;
+    cloudConfig?: {
+        gatewayDomain?: string;
+        publicKey?: string;
+        gatewayId?: string;
+    };
+    openDataContext?: string;
+    openLocationPagePath?: string;
+    sitemapLocation?: string;
+    serviceProviderTicket?: string;
+    style?: 'v2';
+    useExtendedLib?: {
+        [key: string]: boolean | string;
+    };
+    entranceDeclare?: {
+        locationMessage?: {
+            path?: string;
+            query?: string;
+        };
+    };
+    darkmode?: boolean;
+    themeLocation?: string;
+    theme?: string;
+    singlePage?: {
+        navigationBarFit?: 'float' | 'squeezed';
+    };
+    lazyCodeLoading?: 'requiredComponents';
+    enablePassiveEvent?: boolean | {
+        [key: string]: boolean;
+    };
+    supportedMaterials?: ISupportMaterial[];
+    requireBackgroundModes?: string[];
+    embeddedAppIdList?: string[];
+    renderer?: "skyline" | "webview";
+    resolveAlias?: {
+        [key: string]: string;
+    };
+    debugOptions?: {
+        enableFPSPanel?: boolean;
+    };
+    halfPage?: {
+        firstPageNavigationStyle?: 'default' | 'custom';
+    };
+    requiredPrivateInfos?: IRequirePrivateInfos;
+    rendererOptions?: {
+        defaultDisplayBlock?: boolean;
+        skyline?: {
+            disableABTest?: boolean;
+            sdkVersionBegin?: string;
+            sdkVersionEnd?: string;
+            iosVersionBegin?: string;
+            iosVersionEnd?: string;
+            androidVersionBegin?: string;
+            androidVersionEnd?: string;
+        } & ISkylineFeatures;
+    };
+    componentFramework?: 'glass-easel' | 'exparser';
+    accountCardPackage?: {
+        root: string;
+        cardList: Array<{
+            type: number;
+            componentPath: string;
+        }>;
+    };
+    xrEntryPagePath?: string;
+    miniApp?: {
+        useAuthorizePage?: boolean;
+    };
+    __usePrivacyCheck__?: boolean;
+}
+export interface IAppJSON extends IOriginAppJSON {
+    pages: Array<string>;
+    static?: IAppJSONStaticConfig[];
+    "mini-ios"?: IOriginAppJSON & {
+        pages?: Array<string>;
+    };
+    "mini-android"?: IOriginAppJSON & {
+        pages?: Array<string>;
+    };
+    "mini-weixin"?: IOriginAppJSON & {
+        pages?: Array<string>;
+    };
+}
+export {};