miniprogram-ci 2.1.33 → 2.1.34

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-#### 2.1.33
+#### 2.1.34
  - `new` 支持 terser 升级为 5.27.1
 #### 2.1.32
  - `fix` 修复 多端构建不结束的问题

package/README.md

@@ -7,7 +7,7 @@ miniprogram-ci 是从[微信开发者工具](https://developers.weixin.qq.com/mi
 miniprogram-ci 从 1.0.28 开始支持第三方平台开发的上传和预览，调用方式与普通开发模式无异。[查看详情](#第三方平台开发)
 
 ## 最近变更
-#### 2.1.33
+#### 2.1.34
  - `new` 支持 terser 升级为 5.27.1
 #### 2.1.32
  - `fix` 修复 多端构建不结束的问题

package/dist/@types/build-server/constant.d.ts

@@ -0,0 +1,42 @@
+export declare const errors: {
+    1000: {
+        code: number;
+        msg: string;
+    };
+    1001: {
+        code: number;
+        msg: string;
+    };
+    1002: {
+        code: number;
+        msg: string;
+    };
+    1003: {
+        code: number;
+        msg: string;
+    };
+    10000: {
+        code: number;
+        errmsg: string;
+    };
+    10001: {
+        code: number;
+        errmsg: string;
+    };
+    10002: {
+        code: number;
+        errmsg: string;
+    };
+    10003: {
+        code: number;
+        errmsg: string;
+    };
+    10004: {
+        code: number;
+        errmsg: string;
+    };
+    10005: {
+        code: number;
+        errmsg: string;
+    };
+};

package/dist/@types/build-server/ctxManager.d.ts

@@ -0,0 +1,2 @@
+import { AsyncLocalStorage } from 'async_hooks';
+export declare const optionsStorage: AsyncLocalStorage<string>;

package/dist/@types/build-server/fileCacheManager.d.ts

@@ -0,0 +1,43 @@
+import type { RedisClientType } from 'redis';
+import type { EventEmitter } from 'events';
+type IFileCache = {
+    compileResult: string;
+    [importFilePath: string]: string;
+};
+declare class FileCacheManager {
+    redisClient: RedisClientType & EventEmitter;
+    cacheProjectInfo: Record<string, {
+        success: boolean;
+        fileList: {
+            name: string;
+            key: string;
+            lastModifiedTime: number;
+            size: number;
+            createTime: number;
+        }[];
+        message: string;
+    }>;
+    private autoDisConnectInterval;
+    transformFilePathToCacheKey: (projectId: string, versionId: string, filePath: string, taskLinks: string[], lastModifiedTime: number) => string;
+    getFileCache: (data: {
+        ticket: string;
+        projectId: string;
+        versionId: string;
+        snapshotId: string;
+        fileTask: {
+            filePath: string;
+            taskLinks: string[];
+        };
+    }) => Promise<{
+        success: boolean;
+        data: any;
+    }>;
+    constructor();
+    autoDisConnectRedis: () => void;
+    checkRedisConnected: () => Promise<void>;
+    get(fileKey: string): Promise<IFileCache | null>;
+    setCache(fileKey: string, fileCache: IFileCache, expireSeconds?: number): Promise<'OK' | null>;
+    justTestRedis(fileKey: string): Promise<any>;
+}
+declare const _default: FileCacheManager;
+export default _default;

package/dist/@types/build-server/fileTaskDriver.d.ts

@@ -0,0 +1,36 @@
+import type { ITaskResult, IBuildFileTaskList, IBuildFileTask, IReqOptions } from './type';
+import { TaskFactory } from './taskFactory';
+type IRespTask = {
+    result: string;
+    tasks: IBuildFileTask[];
+};
+type IRespTasks = IRespTask[];
+declare class TaskDriver {
+    taskResult: Record<string, IRespTasks>;
+    waitTaskList: Record<string, Function>;
+    formatErrorMsg(error: {
+        code: number;
+        errmsg: string;
+    }, msg: string): {
+        errmsg: string;
+        code: number;
+    };
+    registerWaitTask(taskId: string, task: Function): void;
+    finishWaitTask(taskId: string, taskResult: ITaskResult): void;
+    execTask(task: IBuildFileTask, resultFilePath: string, mainTaskId: string, taskId: string): Promise<{
+        taskId: string;
+        success: boolean;
+        result: string;
+        errmsg: string;
+    }>;
+    generateTaskFunc(task: IBuildFileTask, mainTaskId: string, resultFilePath: string, TaskClass: TaskFactory, fileTask: IRespTask): (resolve: Function, reject: Function) => Promise<void>;
+    doSubTask(tasks: IBuildFileTask[], mainTaskId: string, resultFilePath: string, TaskClass: TaskFactory, fileTask: IRespTask): Promise<void>;
+    formatTaskConfigToTaskList(options: IReqOptions, taskConfig: IBuildFileTaskList): IRespTasks;
+    checkTaskCompileType(task: IBuildFileTaskList): {
+        success: boolean;
+        errmsg?: string;
+    };
+    doTask(options: IReqOptions, taskConfig: IBuildFileTaskList, TaskClass: TaskFactory): void;
+}
+declare const _default: TaskDriver;
+export default _default;

package/dist/@types/build-server/subProcess.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/subTaskManager.d.ts

@@ -0,0 +1,8 @@
+import type { IFinishSubTask, IBuildServerAllowedTaskName } from './type';
+declare class SubTaskManager {
+    subTaskList: Record<string, Record<string, Function>>;
+    addSubTask(option: string, data: Record<string, any>, taskName: IBuildServerAllowedTaskName): Promise<unknown>;
+    onSubTaskFinish(payload: IFinishSubTask): Promise<void>;
+}
+declare const _default: SubTaskManager;
+export default _default;

package/dist/@types/build-server/taskDriver.d.ts

@@ -0,0 +1,68 @@
+import pm2 from 'pm2';
+import type { IBuildServerAllowedTaskName, ProcessDataType, IPacketData, IBuildTask, IBuildTaskList, ITaskResult, IReqOptions } from './type';
+import { TaskFactory } from './taskFactory';
+type Proc = pm2.ProcessDescription & {
+    taskNum: number;
+    pendingTask: Function[];
+    pm_id: number;
+};
+type IFinishFunc = (taskResult: ITaskResult) => void;
+declare class TaskDriver {
+    isTaskServerStart: boolean;
+    processList: Array<Proc>;
+    taskResult: Record<string, IBuildTaskList>;
+    waitTaskList: Record<string, Function>;
+    private taskCleanupTimers;
+    private memoryMonitorInterval;
+    constructor();
+    private startMemoryMonitor;
+    private stopMemoryMonitor;
+    initialize(): void;
+    addSubTask(data: {
+        pmId: number;
+        mainTaskId: string;
+        subTaskId: string;
+        data: Record<string, any>;
+        options?: IReqOptions;
+        taskName?: IBuildServerAllowedTaskName;
+    }): void;
+    listenSubProcessMsg(): void;
+    startAllProcess(): void;
+    killAllProcess(): void;
+    startProcess(instances: number, name: string): void;
+    formatErrorMsg(error: {
+        code: number;
+        errmsg: string;
+    }, msg: string): {
+        errmsg: string;
+        code: number;
+    };
+    private getMinimumTaskProcess;
+    sendTask(data: ProcessDataType, pmId?: number): Promise<{
+        success: boolean;
+        data: any;
+    }>;
+    registerWaitTask(taskId: string, task: Function): void;
+    finishWaitTask(taskId: string, taskResult: IPacketData): void;
+    doSendTask(task: IBuildTask, resultFilePath: string, mainTaskId: string, taskId: string, tryTime?: number): Promise<{
+        success: boolean;
+        data: any;
+    }>;
+    generateTaskFunc(task: IBuildTask, mainTaskId: string, taskInstance: TaskFactory, resultFilePath: string): (resolve: Function, reject: Function) => Promise<void>;
+    checkTaskCompileType(taskList: IBuildTaskList): {
+        success: true;
+    } | {
+        success: false;
+        errmsg: {
+            code: number;
+            errmsg: string;
+        };
+    };
+    doTask(data: {
+        options: IReqOptions;
+        taskList: IBuildTaskList;
+        finishFunc: IFinishFunc;
+    }): void;
+}
+declare const _default: TaskDriver;
+export default _default;

package/dist/@types/build-server/taskFactory.d.ts

@@ -0,0 +1,22 @@
+export declare class TaskFactory {
+    allTaskResult: any[];
+    tasks: {
+        result: any[];
+        taskStatus: 'doing' | 'success';
+        pendingTask: Function[];
+    }[];
+    allDone: number;
+    allDoneTask: undefined | Function;
+    finishFunc: Function;
+    constructor(finishFunc: Function);
+    doTask(taskId: number): void;
+    finishTask(taskId: number): void;
+    checkAllDone(): void;
+    remoteTask(func: Function, taskId?: number): this;
+    localTask(func: Function, taskId?: number): this;
+    newRemoteTask(func: Function): this;
+    newLocalTask(func: Function): this;
+    getTaskResult(callback: Function, taskId?: number): void;
+    waitAllTaskDone(callback: Function): void;
+    stopAllTask(): void;
+}

package/dist/@types/build-server/tasks/appserviceCompile/index.d.ts

@@ -0,0 +1 @@
+export declare function getAppserviceCore(project: IBackendProject): Promise<string>;

package/dist/@types/build-server/tasks/appserviceCompile/utils/appdevserver/getAppService.d.ts

@@ -0,0 +1,5 @@
+export declare function getInitJS(mainContentScript: string[]): void;
+export declare function getJSCodeBuild(project: any, mainContentScript: string[], hasAppJS: boolean, pageFiles: string[], componentFiles: string[], functionalPageFiles: string[], otherFiles: string[], allFiles: string[]): Promise<void>;
+export declare function getBabelCodeByName(project: any, modName: string): Promise<string>;
+export declare function getBabelHelperAndDepsCode(project: any, babelHelpers: any): Promise<Map<any, any>>;
+export declare function getAppCode(project: any, mainContentScript: string[], wxmlXCJS: any, componentFiles: string[], pageFiles: string[]): Promise<void>;

package/dist/@types/build-server/tasks/appserviceCompile/utils/appservice/getjsfile.d.ts

@@ -0,0 +1,19 @@
+interface IGetJSFileOptions {
+    force?: boolean;
+    noWarnings?: boolean;
+    injectHelpers?: boolean;
+    injectHelpersSync?: boolean;
+    isGame?: boolean;
+    isWorkerFile?: boolean;
+    sourceURL?: string;
+    noCache?: boolean;
+    forceSync?: boolean;
+}
+declare function getJsFile(project: IProject, fileName: string, options?: IGetJSFileOptions): Promise<{
+    code: string;
+    helpers: string[];
+    map: import("source-map").RawSourceMap | undefined;
+    mtime: number | undefined;
+    hasPersistJSCacheHit: boolean | undefined;
+}>;
+export = getJsFile;

package/dist/@types/build-server/tasks/appserviceCompile/utils/appservice/getmainpkgsortedjsfiles.d.ts

@@ -0,0 +1,10 @@
+declare const getMainPkgSortedJSFiles: (project: IProject) => Promise<{
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    functionalPageFiles: string[];
+    workerFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+}>;
+export = getMainPkgSortedJSFiles;

package/dist/@types/build-server/tasks/appserviceCompile/utils/appservice/getwxappcode.d.ts

@@ -0,0 +1,23 @@
+declare function getWxAppCode(project: IProject, requireDirectly?: boolean): Promise<any>;
+declare function getWxAppCodeOfPage(project: IProject, pathName: string, genFnName: string, requireDirectly?: boolean): Promise<string>;
+declare function getWxAppCodeJsonOfPage(project: IProject, pathName: string): Promise<string>;
+declare function getWxAppCodeWxmlOfPage(project: IProject, pathName: string, wxmlGenFnName: string): string;
+declare function getWxAppCodeRequireScriptOfPage(project: IProject, pathName: string): string;
+declare function getWxAppCodeForAddComponentStaticConfig(project: IProject, pathName: string): Promise<string>;
+declare function getWxAppCodeForBatchAddCompiledTemplate(glassEaselTemplateResult: Record<string, string>): string;
+declare function getWxAppCodeForBatchAddCompiledScripts(glassEaselScriptResult: string): string;
+declare function getWxAppCodeAddTemplateDependencies(wxmlDependencies: Record<string, string[]>): string;
+declare function getWxAppCodeForSetRuntimeGlobal(runtimeGlobal: string, gdcContent: string): string;
+declare const _default: {
+    getWxAppCode: typeof getWxAppCode;
+    getWxAppCodeOfPage: typeof getWxAppCodeOfPage;
+    getWxAppCodeJsonOfPage: typeof getWxAppCodeJsonOfPage;
+    getWxAppCodeWxmlOfPage: typeof getWxAppCodeWxmlOfPage;
+    getWxAppCodeRequireScriptOfPage: typeof getWxAppCodeRequireScriptOfPage;
+    getWxAppCodeForAddComponentStaticConfig: typeof getWxAppCodeForAddComponentStaticConfig;
+    getWxAppCodeForBatchAddCompiledTemplate: typeof getWxAppCodeForBatchAddCompiledTemplate;
+    getWxAppCodeForBatchAddCompiledScripts: typeof getWxAppCodeForBatchAddCompiledScripts;
+    getWxAppCodeAddTemplateDependencies: typeof getWxAppCodeAddTemplateDependencies;
+    getWxAppCodeForSetRuntimeGlobal: typeof getWxAppCodeForSetRuntimeGlobal;
+};
+export = _default;

package/dist/@types/build-server/tasks/baseFileCompiler/OTService.d.ts

@@ -0,0 +1,7 @@
+export declare const getFileContent: (data: {
+    projectId: string;
+    versionId: string;
+    filePath: string;
+    ticket: string;
+    snapshotId: string;
+}) => Promise<never>;

package/dist/@types/build-server/tasks/baseFileCompiler/enhance.d.ts

@@ -0,0 +1,29 @@
+import { AstType } from '~/config/config';
+import { ICompileResult } from './javascript';
+import { MiniProgramSummer } from '~/types';
+export declare function getEnhancePluginsList(opt: {
+    supportWorklet?: boolean;
+}): any[][];
+export declare const enhance: (source: MiniProgramSummer.SourceDescription, id: string) => Promise<{
+    sourceCode: string;
+    inputMap: MiniProgramSummer.SourceMap | undefined;
+    astInfo: {
+        readonly ast: import("@babel/types").File;
+        readonly type: AstType.Babel;
+    };
+}>;
+export declare function doTransform(source: MiniProgramSummer.SourceDescription, sourceId: string, babelRoot: string, disableUseStrict: boolean): Promise<MiniProgramSummer.SourceDescription>;
+export declare function shouldEnhance(targetPath: string, source: MiniProgramSummer.SourceDescription, isBabelIgnore: boolean): boolean;
+export declare function performEnhanceTransform(source: MiniProgramSummer.SourceDescription, sourcePath: string, targetPath: string, options: {
+    independentRoot?: string;
+    isBabelIgnore?: boolean;
+    disableUseStrict?: boolean;
+}, pluginName?: string): Promise<{
+    source: MiniProgramSummer.SourceDescription;
+    process: Array<{
+        cost: number;
+        pluginName: string;
+        action: string;
+    }>;
+}>;
+export declare const enhanceTask: (options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/es6module.d.ts

@@ -0,0 +1,44 @@
+import { MiniProgramCore, MiniProgramSummer } from '~/types';
+import { ICompileResult } from './javascript';
+export declare function getES6ModulePluginsList(allowTopLevelThis: boolean): any[][];
+export declare function getBabelRoot(independentRoot: string): string;
+export declare function transformES6ModuleAndGenCode(id: string, source: MiniProgramSummer.SourceDescription, options: {
+    babelRoot: string;
+    disableUseStrict: boolean;
+}): Promise<{
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    };
+    helpers: string[];
+}>;
+export declare function doGenerate(sourcePath: string, source: MiniProgramSummer.SourceDescription, options: {
+    babelRoot: string;
+    disableUseStrict: boolean;
+    resultType: MiniProgramCore.IResultType;
+}): Promise<MiniProgramSummer.GenerateDescription>;
+export declare function performES6ModuleGenerate(source: MiniProgramSummer.SourceDescription, sourcePath: string, targetPath: string, options: {
+    independentRoot?: string;
+    isBabelIgnore?: boolean;
+    disableUseStrict?: boolean;
+    resultType?: MiniProgramCore.IResultType;
+}, pluginName?: string, doGenerateFn?: (id: string, source: MiniProgramSummer.SourceDescription, options: {
+    babelRoot: string;
+    disableUseStrict: boolean;
+    resultType: MiniProgramCore.IResultType;
+}) => Promise<MiniProgramSummer.GenerateDescription>): Promise<{
+    target?: MiniProgramSummer.GenerateDescription;
+    process: Array<{
+        cost: number;
+        pluginName: string;
+        action: string;
+        options?: any;
+    }>;
+}>;
+export declare const es6moduleTask: (options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/index.d.ts

@@ -0,0 +1,3 @@
+import { IBuildFileTaskList } from '~/build-server/type';
+export declare const loadTask: (taskName: string) => Function | null;
+export declare const compileBaseFile: (tasks: IBuildFileTaskList) => Promise<unknown>;

package/dist/@types/build-server/tasks/baseFileCompiler/javascript.d.ts

@@ -0,0 +1,36 @@
+import { MiniProgramCore, MiniProgramSummer } from '~/types';
+export { MAX_CODE_LENGTH, } from '~/config/config';
+export interface ICompileResult {
+    targetPath: string;
+    source: {
+        sourceCode: string;
+        sourcePath: string;
+        inputMap: MiniProgramSummer.SourceMap | undefined;
+        astInfo: MiniProgramSummer.AstInfo | undefined;
+        largeFile: boolean;
+        mtime: number;
+    };
+    target: {
+        code: string;
+        map: MiniProgramSummer.SourceMap | undefined;
+        helpers: string[];
+        resultType: MiniProgramCore.IResultType;
+    };
+    process: MiniProgramSummer.IPluginProcessInfo[];
+}
+export declare function shouldLoadJavaScript(sourcePath: string): boolean;
+export declare function createJavaScriptLoadResult(code: string, sourcePath: string, targetPath: string, mtime?: number, pluginName?: string): Promise<{
+    targetPath: string;
+    source: MiniProgramSummer.SourceDescription;
+    process: MiniProgramSummer.IPluginProcessInfo[];
+}>;
+export declare function performJavaScriptLoad(sourcePath: string, targetPath: string, getFileContent: (relativePath: string) => string | Promise<string>, getFileStat?: (relativePath: string) => ({
+    mtimeMs?: number;
+} | undefined) | Promise<{
+    mtimeMs?: number;
+} | undefined>, pluginName?: string): Promise<{
+    targetPath: string;
+    source: MiniProgramSummer.SourceDescription;
+    process: MiniProgramSummer.IPluginProcessInfo[];
+} | undefined>;
+export declare const javascriptTask: (sourcePath: string, targetPath: string, options: any, result: ICompileResult) => Promise<ICompileResult | undefined>;

package/dist/@types/build-server/tasks/baseFileCompiler/less.d.ts

@@ -0,0 +1,43 @@
+import { ICompileResult } from './javascript';
+import { MiniProgramSummer } from '~/types';
+export declare const importWxssReg: RegExp;
+export declare const importWxssCssReg: RegExp;
+export declare function genServerFileManagerPlugin(options: {
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    ticket: string;
+}): {
+    install(less: LessStatic, pluginManager: Less.PluginManager): void;
+};
+export declare function processWxssImports(code: string): {
+    processedCode: string;
+    wxssImports: string[];
+};
+export declare function processLessOutput(output: Less.RenderOutput, wxssImports: string[], projectPath?: string): {
+    wxss: string;
+    map: any;
+};
+export declare function renderLessCode(code: string, sourcePath: string, options?: {
+    globalVars?: any;
+    plugins?: Less.Plugin[];
+    paths?: string[];
+    sourceMap?: boolean;
+}): Promise<Less.RenderOutput>;
+export declare function performLessLoad(targetPath: string, sourcePath: string, options: {
+    getFileContent: (relativePath: string) => string | Promise<string>;
+    getAppImport?: (relativePath: string) => string | Promise<string>;
+    globalVars?: any;
+    plugins?: Less.Plugin[];
+    paths?: string[];
+    projectPath?: string;
+    addWatchFile?: (file: string) => void;
+}, pluginName?: string): Promise<{
+    targetPath: string;
+    source: {
+        sourceCode: string;
+        inputMap: any;
+    };
+    process: MiniProgramSummer.IPluginProcessInfo[];
+} | undefined>;
+export declare const lessTask: (sourcePath: string, targetPath: string, options: any, result: ICompileResult) => Promise<any>;

package/dist/@types/build-server/tasks/baseFileCompiler/minifywxml.d.ts

@@ -0,0 +1,10 @@
+import { MiniProgramCore } from '~/types';
+import { ICompileResult } from './javascript';
+import { IMinifySetting } from '~/modules/corecompiler/original/workerThread/task/minifywxml';
+export interface IWxmlOptions {
+    minify: boolean;
+}
+export declare function doCompress(content: string, filePath: string, setting: IMinifySetting): Promise<string>;
+export declare function shouldCompressWxml(targetPath: string, minify: boolean, resultType: string): boolean;
+export declare function createMinifySettings(project?: MiniProgramCore.IPreCompileProject, targetPath?: string): IMinifySetting;
+export declare const minifywxmlTask: (options: any, result: ICompileResult) => Promise<ICompileResult | undefined>;

package/dist/@types/build-server/tasks/baseFileCompiler/readFile.d.ts

@@ -0,0 +1,2 @@
+import { ICompileResult } from './javascript';
+export declare const readFileTask: (sourcePath: string, targetPath: string, options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/sass.d.ts

@@ -0,0 +1,50 @@
+import { MiniProgramSummer } from '~/types';
+import { ICompileResult } from './javascript';
+export declare const sass: () => Promise<typeof import("sass")>;
+export declare function random(): string;
+export declare const importWxssReg: RegExp;
+export declare const importCssReg: RegExp;
+export declare function sassRender(options: any, cb: (err: any, result?: any) => void): Promise<void>;
+export declare function shouldLoadSass(sourcePath: string): boolean;
+export declare function processWxssImports(code: string): {
+    processedCode: string;
+    wxssImports: string[];
+};
+export declare function processSassOutput(result: any, wxssImports: string[], sourcePath: string, sourceRoot?: string): {
+    wxss: string;
+    map: any;
+};
+export declare function performSassLoad(targetPath: string, sourcePath: string, options: {
+    getFileContent: (relativePath: string) => string | Promise<string>;
+    getGlobalImport?: (relativePath: string) => string | Promise<string>;
+    includePaths?: string[];
+    addWatchFile?: (file: string) => void;
+    sourceRoot?: string;
+    [key: string]: any;
+}, pluginName?: string): Promise<{
+    targetPath: string;
+    source: {
+        sourceCode: string;
+        inputMap: any;
+    };
+    process: Array<{
+        cost: number;
+        pluginName: string;
+        action: MiniProgramSummer.AsyncPluginHooks;
+    }>;
+} | undefined>;
+export declare const sassTask: (sourcePath: string, targetPath: string, options: any, result: ICompileResult) => Promise<{
+    targetPath: string;
+    source: {
+        sourceCode: string;
+        inputMap: any;
+    };
+    target: {
+        code: string;
+    };
+    process: {
+        cost: number;
+        pluginName: string;
+        action: MiniProgramSummer.AsyncPluginHooks;
+    }[];
+} | undefined>;

package/dist/@types/build-server/tasks/baseFileCompiler/terser.d.ts

@@ -0,0 +1,20 @@
+import { MiniProgramCore } from '~/types';
+import { ICompileResult } from './javascript';
+export declare const terser: () => typeof import("terser");
+export declare const babelCodeFrame: () => typeof import("babel-code-frame");
+export declare function shouldRunTerser(options: MiniProgramCore.ICompileOptions, targetPath: string, minify?: boolean): boolean;
+export declare function buildSourceMapOptions(map: any, filename: string): {
+    includeSources: boolean;
+    content: any;
+    filename: string;
+};
+export declare function makeTerserProcessRecord(startTime: number, pluginName: string): {
+    cost: number;
+    pluginName: string;
+    action: "compress";
+};
+export declare function doCompress(content: string, sourceMapOptions: any): Promise<import("terser").MinifyOutput | {
+    error: any;
+}>;
+export declare function handleTerserError(error: any, content: string, id: string): void;
+export declare const terserTask: (options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/typescript.d.ts

@@ -0,0 +1,25 @@
+import { MiniProgramSummer } from '~/types';
+import { ICompileResult } from './javascript';
+export declare const babel7: () => typeof import("@babel/core");
+export declare const pluginTransformTypescript: () => any;
+export declare function shouldRunTypescript(sourcePath: string): boolean;
+export declare function makeTypescriptProcessRecord(startTime: number, pluginName: string): {
+    cost: number;
+    pluginName: string;
+    action: "load";
+};
+export declare function doLoad(code: string, file: string, inputMap?: any): Promise<MiniProgramSummer.SourceDescription>;
+export declare function doLoadSync(code: string, file: string, inputMap?: any): MiniProgramSummer.SourceDescription;
+export declare const pluginReplaceTsExportAssignment: (api: any) => {
+    name: string;
+    visitor: {
+        TSExportAssignment(path: any): void;
+    };
+};
+export declare const pluginReplaceTsImportEqualsDeclaration: (api: any) => {
+    name: string;
+    visitor: {
+        TSImportEqualsDeclaration(path: any): void;
+    };
+};
+export declare const typescriptTask: (sourcePath: string, targetPath: string, options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/worklet.d.ts

@@ -0,0 +1,13 @@
+import { MiniProgramSummer } from '~/types';
+import { ICompileResult } from './javascript';
+export declare const _pluginTransformWorklet: () => any;
+export declare const babel7: () => typeof import("@babel/core");
+export declare function shouldRunWorklet(targetPath: string, isBabelIgnore: boolean): boolean;
+export declare function hasWorkletCode(sourceCode: string): boolean;
+export declare function makeWorkletProcessRecord(startTime: number, pluginName: string): {
+    cost: number;
+    pluginName: string;
+    action: "transform";
+};
+export declare const worklet: (source: MiniProgramSummer.SourceDescription, id: string) => Promise<MiniProgramSummer.SourceDescription>;
+export declare const workletTask: (options: any, result: ICompileResult) => Promise<ICompileResult>;

package/dist/@types/build-server/tasks/baseFileCompiler/wxss.d.ts

@@ -0,0 +1,33 @@
+import { MiniProgramCore } from '~/types';
+import { ICompileResult } from './javascript';
+export interface IWxssOptions {
+    autoPrefix: boolean;
+    minify: boolean;
+}
+export declare const MAX_LINE_SHOW_LENGTH = 45;
+export declare function shortString(line: string, max: number, mid?: number): {
+    result: string;
+    marker: number;
+};
+export declare function formatPostcssError(content: string, error: any): any;
+export declare function shouldOptimizeWxss(targetPath: string, resultType: MiniProgramCore.IResultType, autoPrefix: boolean, minify: boolean): boolean;
+export declare function doOptimize(sourcePath: string, sourceContent: string, options?: {
+    autoPrefix?: boolean;
+    minify?: boolean;
+}): Promise<{
+    error: any;
+    content?: string;
+}>;
+export declare function performWxssOptimize(targetPath: string, code: string, options: {
+    resultType: MiniProgramCore.IResultType;
+    autoPrefix?: boolean;
+    minify?: boolean;
+}, pluginName?: string): Promise<{
+    code: string;
+    process: Array<{
+        cost: number;
+        pluginName: string;
+        action: string;
+    }>;
+} | undefined>;
+export declare const wxssTask: (options: any, result: ICompileResult) => Promise<ICompileResult>;