miniprogram-ci 1.9.27 → 2.0.0

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

@@ -0,0 +1,25 @@
+import { MiniProgramCore } from '../types';
+import { BaseProject } from './baseProject';
+type ProjectType = MiniProgramCore.ProjectType;
+export interface ICreateProjectOptions {
+    projectPath: string;
+    type: ProjectType;
+    appid: string;
+    privateKey?: string;
+    privateKeyPath?: string;
+    ignores?: string[];
+    targetPlatform?: string;
+    compileDefines?: {
+        [key: string]: string;
+    };
+}
+export { getProjectAttr, } from '../ci/projectattr';
+export declare class CIProject extends BaseProject {
+    private _project;
+    constructor(options: ICreateProjectOptions);
+    get project(): BaseProject;
+    init(): Promise<void>;
+    updateFileAndDirs(): void;
+    attr(): Promise<any>;
+    getExtAppid(): Promise<string | void>;
+}

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../types';
+import { CIProject } from './ciProject';
+type IStat = MiniProgramCore.IStat;
+export declare class CIProjectWithMockBuffer extends CIProject {
+    private mockBuffer;
+    setMockFileCache(mockedProject: object): void;
+    getFile(prefix: string, filePath: string): Buffer;
+    stat(prefix: string, filePath: string): IStat | undefined;
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { BaseProject } from './baseProject';
+interface IOriginDevtoolsProject {
+    [key: string]: string;
+}
+export interface ICreateProjectOptions {
+    project: IOriginDevtoolsProject;
+}
+export declare abstract class DevtoolsProject extends BaseProject {
+    fileUtils: any;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { MiniProgramCore } from '../types';
+import { BaseProject } from './baseProject';
+export interface IStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    size?: number;
+}
+export type FileChange = (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', targetPath: string) => void;
+export declare class SummerCPProject extends BaseProject implements MiniProgramCore.IProject {
+    constructor(projectInfo: MiniProgramCore.IProjectSerializeInfo);
+    init(files: string[], dirs: string[]): Promise<void>;
+    updateFileAndDirs(files: string[], dirs: string[]): void;
+    private isIgnore;
+}

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

@@ -0,0 +1,10 @@
+import { CIProject } from './ciProject';
+export interface ICreateProjectOptions {
+    projectPath: string;
+    ignores?: any[];
+}
+export declare class WebProject extends CIProject {
+    constructor(options: ICreateProjectOptions);
+    get srcPath(): string;
+    attr(): Promise<any>;
+}

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

@@ -0,0 +1,182 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Analyzer } from '../common/code-analyse';
+import { EventEmitter } from 'stream';
+import { MiniProgramDevtools } from './devtools';
+export declare const CheckOption: {
+    PACKAGE_SIZE_LIMIT: number;
+    IMAGE_AND_AUDIO_LIMIT: number;
+    CONTAINS_OTHER_PKG_JS: number;
+    CONTAINS_OTHER_PKG_COMPONENTS: number;
+    CONTAINS_OTHER_PKG_PLUGINS: number;
+    JS_COMPRESS_OPEN: number;
+    WXML_COMPRESS_OPEN: number;
+    WXSS_COMPRESS_OPEN: number;
+    CONTAINS_UNUSED_PLUGINS: number;
+    PLUGIN_OVER_SIZE: number;
+    USE_EXTENDLIB_WITHOUT_DEFINED: number;
+    LAZYCODE_LOADING_OPEN: number;
+    CONTAINS_UNUSED_COMPONENTS: number;
+    CONTAINS_UNUSED_CODES: number;
+    CONTAINS_APPSECRET: number;
+};
+export declare enum EProjectType {
+    miniProgram = "miniProgram",
+    miniGame = "miniGame",
+    miniProgramPlugin = "miniProgramPlugin",
+    miniGamePlugin = "miniGamePlugin"
+}
+export declare enum EProjectArchitecture {
+    miniProgram = "miniProgram",
+    multiPlatform = "multiPlatform"
+}
+export declare namespace MiniProgramCI {
+    interface IStat {
+        isFile: boolean;
+        isDirectory: boolean;
+        size: number;
+        mtimeMs: number;
+    }
+    type ProjectType = 'miniProgram' | 'miniGame' | 'miniProgramPlugin' | 'miniGamePlugin';
+    type IProjectArchitecture = 'miniProgram' | 'multiPlatform';
+    interface IProject {
+        nameMappingFromDevtools?: IStringKeyMap<string>;
+        appid: string;
+        type: ProjectType;
+        projectPath: string;
+        privateKey: string;
+        miniprogramRoot: string;
+        pluginRoot: string;
+        attr(): Promise<IProjectAttr>;
+        stat(prefix: string, filePath: string): IStat | undefined;
+        getFile(prefix: string, filePath: string): Buffer;
+        getFileList(prefix?: string, extName?: string): string[];
+        getExtAppid(): Promise<string | void>;
+        updateFiles(): void;
+        getFilesAndDirs(): {
+            files: string[];
+            dirs: string[];
+        };
+        setting: MiniProgramDevtools.IProjectSetting;
+        projectArchitecture: IProjectArchitecture;
+        event?: EventEmitter;
+        clearCache?: () => void;
+        srcPath?: string;
+        ignores?: string[];
+        packOptions?: {
+            ignore: MiniProgramDevtools.IProjectConfigPackOption[];
+            include: MiniProgramDevtools.IProjectConfigPackOption[];
+        };
+    }
+    interface IStringKeyMap<T = any> {
+        [propName: string]: T;
+    }
+    interface IValidateResult {
+        warning: string;
+        error: Array<{
+            errorType: string;
+            errorProperty: string;
+            correctType?: Array<string>;
+            requireProperty?: string;
+        }>;
+    }
+    type FN<R = any> = (...args: any[]) => R;
+    type FN1<A = any, R = any> = (a: A) => R;
+    type FN2<A = any, B = any, R = any> = (a: A, b: B) => R;
+    type FN3<A = any, B = any, C = any, R = any> = (a: A, b: B, c: C) => R;
+    type FN4<A = any, B = any, C = any, D = any, R = any> = (a: A, b: B, c: C, d: D) => R;
+    interface IAnyObject {
+        [key: string]: any;
+    }
+    interface ICompileSettings {
+        useProjectConfig?: boolean;
+        es6?: boolean;
+        es7?: boolean;
+        minify?: boolean;
+        codeProtect?: boolean;
+        minifyJS?: boolean;
+        minifyWXML?: boolean;
+        minifyWXSS?: boolean;
+        autoPrefixWXSS?: boolean;
+        disableUseStrict?: boolean;
+        compileWorklet?: boolean;
+    }
+    interface ITaskStatus {
+        id: string;
+        message: string;
+        status: 'doing' | 'done' | 'fail';
+    }
+    interface IDevToolsCompileCache {
+        init: (project: IProject) => Promise<void>;
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        remove: (key?: string | undefined) => void;
+        getFile: (filePath: string, infoKey?: string) => Promise<any>;
+        setFile: (filePath: string, value: any, infoKey?: string) => void;
+        removeFile: (filePath: string) => void;
+        clean: () => void;
+        getAllCacheFiles: () => string[];
+    }
+    interface IDevtoolsDebugInfo {
+        from: 'devtools' | 'ci';
+        useNewCompileModule: boolean;
+        devtoolsVersion: string;
+        compileSetting: MiniProgramCI.IAnyObject;
+        ciVersion: string;
+    }
+    interface ICompileOptions {
+        nameMapping?: IStringKeyMap<string>;
+        setting?: MiniProgramDevtools.IProjectSetting;
+        onProgressUpdate?: (task: ITaskStatus) => void;
+        devToolsCompileCache?: IDevToolsCompileCache;
+        __compileDebugInfo__?: IDevtoolsDebugInfo;
+        compilePages?: string[];
+        analyzer?: Analyzer;
+    }
+    interface IProjectAttr {
+        platform: boolean;
+        appType: number;
+        gameApp?: boolean;
+        isSandbox: boolean;
+        released: boolean;
+        setting: {
+            MaxCodeSize: number;
+            MaxSubpackageSubCodeSize: number;
+            MaxSubpackageFullCodeSize: number;
+            NavigateMiniprogramLimit: number;
+            MaxSubPackageLimit: number;
+            MinTabbarCount: number;
+            MaxTabbarCount: number;
+            MaxCustomTabbarCount: number;
+            MaxTabbarIconSize: number;
+        };
+    }
+    interface IWarnItem {
+        jsPath: string;
+        code: string;
+        tips: string;
+        msg: string;
+        startLine?: number;
+        endLine?: number;
+    }
+    type ICheckOption = keyof typeof CheckOption;
+    interface ICheckItem {
+        name?: ICheckOption;
+        enabled: boolean;
+        desc: string;
+        descEn: string;
+        docURL?: string;
+        level: number;
+        handlerText?: string;
+        handlerTextEn?: string;
+        text?: string;
+        limit?: number;
+        detail?: any;
+        title: string;
+        titleEn: string;
+        typeName: string;
+        typeNameEn: string;
+        success?: boolean;
+    }
+    type ICheckResultItem = Pick<ICheckItem, 'name' | 'success' | 'text' | 'detail' | 'docURL'>;
+}

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

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+import type { Analyzer } from '../common/code-analyse';
+import { MiniProgramDevtools } from './devtools';
+import { MiniProgramCI } from './ci';
+export * from './miniprogram-json/index';
+export declare namespace MiniProgramCore {
+    type IStat = MiniProgramCI.IStat;
+    type ProjectType = MiniProgramCI.ProjectType;
+    type IProjectArchitecture = MiniProgramCI.IProjectArchitecture;
+    type ITargetPlatformDefine = {
+        [key: string]: any;
+    };
+    type ITargetPlatform = 'mini-android' | 'mini-ios' | 'mini-weixin';
+    type IPreRunEnv = 'main process' | 'summer cp' | 'worker cp';
+    interface IConditionCompileInfo {
+        targetPlatform?: ITargetPlatform;
+        targetPlatformDefines?: ITargetPlatformDefine;
+        runEnv?: IPreRunEnv;
+    }
+    interface IFileInfos {
+        [key: string]: IStat;
+    }
+    interface IProjectSerializeInfo {
+        appid: string;
+        attr: any;
+        type: ProjectType;
+        projectPath: string;
+        projectArchitecture: MiniProgramCore.IProjectArchitecture;
+        miniprogramRoot: string;
+        pluginRoot: string;
+        files: string[];
+        dirs: string[];
+        setting: any;
+    }
+    interface IPrecompileProjectSerializeInfo extends IProjectSerializeInfo {
+        targetPlatform: ITargetPlatform;
+        targetPlatformDefines: ITargetPlatformDefine;
+    }
+    interface IProject extends MiniProgramCI.IProject {
+        pluginSrcPath: string;
+        serialize: () => Promise<IProjectSerializeInfo>;
+        getTargetPath: (prefix: string, filePath: string) => string;
+        exists: (prefix: string, filePath: string) => boolean;
+        updateFileAndDirs: (...args: any[]) => void;
+        getAllFileInfo: (prefix?: string) => IFileInfos;
+        onFileChange?: any;
+    }
+    interface IPreCompileProject extends IProject {
+        project: MiniProgramCI.IProject;
+        targetPlatform?: ITargetPlatform;
+        targetPlatformDefines?: ITargetPlatformDefine;
+        conditionCompiler?: any;
+        getSrcFile(prefix: string, filePath: string): Buffer;
+    }
+    interface IStringKeyMap<T = any> {
+        [propName: string]: T;
+    }
+    interface IValidateResult {
+        warning: string;
+        error: Array<{
+            errorType: string;
+            errorProperty: string;
+            correctType?: string[];
+            requireProperty?: string;
+        }>;
+    }
+    type FN<R = any> = (...args: any[]) => R;
+    type FN1<A = any, R = any> = (a: A) => R;
+    type FN2<A = any, B = any, R = any> = (a: A, b: B) => R;
+    type FN3<A = any, B = any, C = any, R = any> = (a: A, b: B, c: C) => R;
+    type FN4<A = any, B = any, C = any, D = any, R = any> = (a: A, b: B, c: C, d: D) => R;
+    interface IAnyObject {
+        [key: string]: any;
+    }
+    type ICompileSettings = MiniProgramCI.ICompileSettings;
+    type IResultType = 'prod' | 'dev';
+    interface ITaskStatus {
+        id: string;
+        message: string;
+        status: 'doing' | 'fail' | 'done';
+    }
+    interface IDevToolsCompileCache {
+        init: (project: IProject) => Promise<void>;
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        remove: (key?: string | undefined) => void;
+        getFile: (filePath: string, infoKey?: string) => Promise<any>;
+        setFile: (filePath: string, value: any, infoKey?: string) => void;
+        removeFile: (filePath: string) => void;
+        clean: () => void;
+        getAllCacheFiles: () => string[];
+    }
+    interface IDevtoolsDebugInfo {
+        from: 'devtools' | 'ci' | 'inner';
+        useNewCompileModule: boolean;
+        devtoolsVersion: string;
+        compileSetting: MiniProgramCore.IAnyObject;
+        ciVersion?: string;
+    }
+    interface ICompileOptions {
+        nameMapping?: IStringKeyMap<string>;
+        setting?: MiniProgramDevtools.IProjectSetting;
+        onProgressUpdate?: (task: ITaskStatus) => void;
+        devToolsCompileCache?: IDevToolsCompileCache;
+        __compileDebugInfo__?: IDevtoolsDebugInfo;
+        compilePages?: string[];
+        analyzer?: Analyzer;
+        disableSpreadingUsingComponents?: boolean;
+        resultType?: IResultType;
+    }
+    type IProjectAttr = MiniProgramCI.IProjectAttr;
+    interface IWarnItem {
+        jsPath: string;
+        code: string;
+        tips: string;
+        msg: string;
+        startLine?: number;
+        endLine?: number;
+    }
+    interface IPackNpmOptions {
+        ignores?: string[];
+        reporter?: MiniProgramCore.FN<void>;
+    }
+    type IWatchEventType = 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change';
+}
+export type ProjectType = MiniProgramCore.ProjectType;
+export type IProject = MiniProgramCore.IProject;
+export type IStat = MiniProgramCore.IStat;
+export type IAnyObject = MiniProgramCore.IAnyObject;

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

@@ -0,0 +1,220 @@
+/// <reference types="node" />
+import { MiniProgramCore } from './core';
+import { MiniProgramSummer, IBasicCodeExt } from './summer';
+export declare namespace MiniProgramDevtools {
+    type IBuildLogType = 'doing' | 'success' | 'error' | 'info';
+    interface IAppConf {
+        app: any;
+        packages: Record<string, any>;
+        pages: Record<string, any>;
+        comps: Record<string, any>;
+        sitemap: any;
+        theme: any;
+    }
+    interface IGameConf {
+        app: any;
+        packages: Record<string, any>;
+    }
+    interface IPluginConf {
+        plugin: any;
+        pages: Record<string, any>;
+        comps: Record<string, any>;
+    }
+    interface IGamePluginConf {
+        plugin: any;
+    }
+    type IShowBuildLog = (msgId: string, type: IBuildLogType, text: string) => void;
+    type ProgressUpdate = (id: number, status: 'doing' | 'fail' | 'done', message: string) => void;
+    type ISummerPluginConfig = Array<string | [string, MiniProgramSummer.SummerPluginOptions]>;
+    type IBabelSetting = {
+        outputPath?: string;
+        ignore?: any[];
+    };
+    type ISWCSetting = {
+        ignore?: string[];
+        outputPath?: string;
+        rc?: Record<string, any>;
+    };
+    interface IDevtoolsProjectInfo {
+        appid: string;
+        attr: any;
+        compileType: MiniProgramCore.ProjectType;
+        projectArchitecture: MiniProgramCore.IProjectArchitecture;
+        miniprogramRoot: string;
+        pluginRoot: string;
+        summerPlugins: ISummerPluginConfig;
+        setting: MiniProgramDevtools.IProjectSetting;
+    }
+    type GraphId = MiniProgramCore.ProjectType;
+    type IGetConfOptions = {
+        graphId: GraphId;
+    };
+    type IGetPackageFilesOptions = {
+        graphId: GraphId;
+        root: string;
+    };
+    type ICompileSingleCodeOptions = {
+        graphId: GraphId;
+        filePath: string;
+        sourceCode?: string;
+    };
+    type IGetCodeOptions = {
+        graphId: GraphId;
+        cacheMd5: Record<string, string>;
+        package?: string;
+    };
+    interface IDevtoolsProject {
+        id: string;
+        appid: string;
+        projectid: string;
+        projectname: string;
+        miniprogramRoot: string;
+        pluginRoot?: string;
+    }
+    interface EventMsg {
+        type: 'event';
+        name: string;
+        data: any;
+    }
+    interface ProgressMsg {
+        type: 'progress';
+        id: number;
+        taskId: number;
+        status: 'doing' | 'done';
+        message: string;
+    }
+    interface RequestMsg {
+        type: 'request';
+        id: number;
+        name: string;
+        data: any;
+    }
+    interface ResponseMsg {
+        type: 'response';
+        id: number;
+        data: any;
+        error?: any;
+    }
+    interface ReadyMsg {
+        type: 'ready' | 'noReady';
+        data?: any;
+        error?: any;
+    }
+    interface InitMsg {
+        type: 'init';
+        data: any;
+    }
+    type SummerProcessMessage = InitMsg | RequestMsg | ResponseMsg | EventMsg | ProgressMsg;
+    type IPackageCodeOptions = {
+        package: string;
+        partialCompilePath?: string[];
+    };
+    interface CodeFile {
+        path: string;
+        md5: string;
+        code: string;
+        map?: MiniProgramSummer.SourceMap | string;
+        jsTag?: {
+            isLargeFile: boolean;
+            isBabelIgnore: boolean;
+            helpers: string[];
+        };
+    }
+    interface CodeError {
+        path: string;
+        error: any;
+    }
+    type CodeFiles = Record<string, CodeFile | CodeError>;
+    interface ICompilerStatus {
+        codeExts: string[];
+        codeConf: {
+            [key in IBasicCodeExt]: {
+                exts: string[];
+                template?: {
+                    ext: string;
+                    content: string;
+                };
+            };
+        };
+    }
+    type ICompileResult = Record<string, string | Buffer>;
+    interface ITask {
+        name?: string;
+        data?: any;
+        resolve: any;
+        reject: any;
+        progressUpdate?: ProgressUpdate;
+    }
+    interface IProjectConfigPackOption {
+        type: string;
+        value: string;
+    }
+    type Void<T> = T | undefined | null;
+    interface IProjectSetting {
+        localPlugins?: boolean;
+        autoAudits?: boolean;
+        condition?: boolean;
+        es6?: boolean;
+        minified?: boolean;
+        newFeature?: boolean;
+        postcss?: boolean;
+        urlCheck?: boolean;
+        scopeDataCheck?: boolean;
+        uglifyFileName?: boolean;
+        compileHotReLoad?: boolean;
+        uploadWithSourceMap?: boolean;
+        preloadBackgroundData?: boolean;
+        scriptsEnable?: boolean;
+        lazyloadPlaceholderEnable?: boolean;
+        skylineRenderEnable?: boolean;
+        compileWorklet?: boolean;
+        nodeModules?: boolean;
+        checkInvalidKey?: boolean;
+        checkSiteMap?: boolean;
+        enhance?: boolean;
+        swc?: boolean;
+        swcSetting?: ISWCSetting;
+        coverView?: boolean;
+        showShadowRootInWxmlPanel?: boolean;
+        babelSetting?: {
+            ignore: string[];
+            disablePlugins: string[];
+            outputPath: string;
+        };
+        bundle?: boolean;
+        userConfirmedBundleSwitch?: boolean;
+        useIsolateContext?: boolean;
+        userConfirmedUseIsolateContext?: boolean;
+        useCompilerModule?: boolean;
+        useMultiFrameRuntime?: boolean | string;
+        useApiHook?: boolean;
+        useApiHostProcess?: boolean;
+        userConfirmedUseCompilerModuleSwitch?: boolean;
+        skeletonGenerateFilesWithoutConfirm?: boolean;
+        packNpmManually?: boolean;
+        packNpmRelationList?: Array<{
+            packageJsonPath: string;
+            miniprogramNpmDistDir: string;
+        }>;
+        enableEngineNative?: boolean;
+        useStaticServer?: boolean;
+        minifyWXSS?: boolean;
+        disableUseStrict?: boolean;
+        minifyWXML?: boolean;
+        useLanDebug?: boolean;
+        showES6CompileOption?: boolean;
+        useCompilerPlugins?: false | Array<string | [string, {
+            [key in string]: any;
+        }]>;
+        useSummerCompiler?: false | Array<string | [string, {
+            [key in string]: any;
+        }]>;
+        ignoreUploadUnusedFiles?: boolean;
+        ignoreDevUnusedFiles?: boolean;
+        bigPackageSizeSupport?: boolean;
+    }
+    interface IPluginInfo {
+        provider: string;
+        version: string;
+    }
+}