miniprogram-ci 2.1.32 → 2.1.34

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/compileWxssPipe.d.ts

@@ -0,0 +1,3 @@
+import { ICompileWxssOptions } from '~/services/compilewxss/common/compilewxssService';
+import { IPipeDefinition } from '../types';
+export declare const compileWxssPipe: IPipeDefinition<ICompileWxssOptions>;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/index.d.ts

@@ -0,0 +1,2 @@
+import { IPipeDefinition } from '../types';
+export declare const allPipes: IPipeDefinition[];

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/pageInitSourcePipe/index.d.ts

@@ -0,0 +1,4 @@
+import { IPipeContext, IPipeDefinition } from '../../types';
+export declare const getPageInitResource: (context: IPipeContext, filepath: string) => Promise<string>;
+export declare const getPageInitResourceCore: (context: IPipeContext, filepath: string) => Promise<string>;
+export declare const pageInitSourcePipe: IPipeDefinition;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/pageframePipe/index.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext, IPipeDefinition } from '../../types';
+export declare function getPageframeCore(context: IPipeContext, isMultiPkg?: boolean): Promise<string>;
+export declare const pageframePipe: IPipeDefinition;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appdevserver/getAppService.d.ts

@@ -0,0 +1,6 @@
+import { IPipeContext } from '../../../types';
+export declare function getInitJS(mainContentScript: string[]): void;
+export declare function getJSCodeBuild(context: IPipeContext, mainContentScript: string[], hasAppJS: boolean, pageFiles: string[], componentFiles: string[], functionalPageFiles: string[], otherFiles: string[], allFiles: string[]): Promise<void>;
+export declare function getBabelCodeByName(context: IPipeContext, modName: string): Promise<string>;
+export declare function getBabelHelperAndDepsCode(context: IPipeContext, babelHelpers: any): Promise<Map<any, any>>;
+export declare function getAppCode(context: IPipeContext, mainContentScript: string[], wxmlXCJS: any, componentFiles: string[], pageFiles: string[]): Promise<void>;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appdevserver/getwxappcode.d.ts

@@ -0,0 +1,9 @@
+import { IPipeContext } from '../../../types';
+interface IGetWxAppCodeOptions {
+    app?: boolean;
+    page?: string;
+    noJson?: boolean;
+    noWXSS?: boolean;
+}
+export declare function getPageFrameWxAppCode(context: IPipeContext, options?: IGetWxAppCodeOptions): Promise<string>;
+export {};

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getjsfile.d.ts

@@ -0,0 +1,12 @@
+import { RawSourceMap } from 'source-map';
+import { IPipeContext } from '../../../types';
+declare function getJsFile(context: IPipeContext, fileName: string, options?: {
+    injectHelpers?: boolean;
+    injectHelpersSync?: boolean;
+}): Promise<{
+    code: string;
+    helpers: string[];
+    map: RawSourceMap | undefined;
+    mtime: number | undefined;
+}>;
+export = getJsFile;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getmainpkgsortedjsfiles.d.ts

@@ -0,0 +1,11 @@
+import { IPipeContext } from '../../../types';
+declare const getMainPkgSortedJSFiles: (context: IPipeContext) => Promise<{
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    functionalPageFiles: string[];
+    workerFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+}>;
+export = getMainPkgSortedJSFiles;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/appservice/getwxappcode.d.ts

@@ -0,0 +1,8 @@
+import { IPipeContext } from '../../../types';
+declare function getWxAppCode(context: IPipeContext, requireDirectly?: boolean): Promise<any>;
+declare function getWxAppCodeOfPage(context: IPipeContext, pathName: string, genFnName: string, requireDirectly?: boolean): Promise<string>;
+declare const _default: {
+    getWxAppCode: typeof getWxAppCode;
+    getWxAppCodeOfPage: typeof getWxAppCodeOfPage;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/common/apperrcode.config.d.ts

@@ -0,0 +1,92 @@
+declare const appErrCode: {
+    APP_JSON_READ_ERR: number;
+    APP_JSON_PARSE_ERR: number;
+    APP_JSON_PAGES_ERR: number;
+    APP_JSON_ENTRANCE_NOT_FOUND_ERR: number;
+    APP_JSON_CONTENT_ERR: number;
+    PAGES_JSON_PARSE_ERR: number;
+    APP_JSON_WXML_NOT_FOUND: number;
+    APP_JSON_JS_NOT_FOUND: number;
+    JSON_CONTENT_ERR: number;
+    EXT_JSON_PARSE_ERR: number;
+    EXT_JSON_PAGES_ERR: number;
+    EXT_JSON_CONTENT_ERR: number;
+    APPSERVICE_LOSE_WXML: number;
+    APPSERVICE_LOSE_JS: number;
+    FILE_NOT_UTF8: number;
+    BABEL_TRANS_JS_ERR: number;
+    UGLIFY_JS_ERR: number;
+    BABILI_JS_ERR: number;
+    JS_ES6_ERR: number;
+    FILE_FLAT_ERR: number;
+    POST_WXSS_ERR: number;
+    TRANS_WXML_JS_ERR: number;
+    TRANS_WXSS_JS_ERR: number;
+    SUMMER_PLUGIN_ERR: number;
+    SUMMER_PLUGIN_CODE_ERR: number;
+    VENDOR_MD5_NOT_MATCH: number;
+    VENDOR_WCC_FILE_NOT_FOUND: number;
+    VENDOR_WCSC_FILE_NOT_FOUND: number;
+    CODE_SIZE_EXCEED: number;
+    GET_GEO_LOCATION_ERR: number;
+    QCLOUD_SVR_NO_FOUND_ERR: number;
+    QCLOUD_SVR_POLL_TIMEOUT: number;
+    QCLOUD_SVR_POLL_DOING: number;
+    QCLOUD_SVR_UP_DIR_CHECK: number;
+    PLUGIN_JSON_READ_ERR: number;
+    PLUGIN_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_CONTENT_ERR: number;
+    PLUGIN_PAGE_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_FILE_NOT_FOUND: number;
+    PLUGIN_PAGE_JSON_CONTENT_ERR: number;
+    PLUGIN_TRANS_WXML_JS_ERR: number;
+    PLUGIN_TRANS_WXSS_JS_ERR: number;
+    PLUGIN_JS_ES6_ERR: number;
+    PLUGIN_ONLINE_CODE_UNPACK_ERR: number;
+    PAGE_JSON_PARSE_ERR: number;
+    SITE_MAP_JSON_CONTENT_ERROR: number;
+    CHECK_UPLOAD_STATUS_ERR: number;
+    CLEAR_SESSION_ERR: number;
+    GAME_CODE_LIB_MD5_ERR: number;
+    LOAD_QRCODE_OTHER_ERR: number;
+    JUMP_QCLOUD_PAGE_ERR: number;
+    PACK_NPM_ERR: number;
+    GET_PROJECT_CONFIG_ERR: number;
+    MINI_PROGRAM_CONSUME_TIMING: number;
+    MINI_GAME_CONSUME_TIMING: number;
+    UPLOAD_PROGRESS_FAIIL: number;
+    UPLOAD_PLUGIN_ERR: number;
+    UPLOAD_FAIILED: number;
+    COMPILE_CONDITION_APPID_ERR: number;
+    COMPILE_CONDITION_PROGRAM_ERR: number;
+    COMPILE_CONDITION_ERR: number;
+    COMPILE_CONDITION_ERR_WITH_DETAIL: number;
+    WIDGET_GET_SEARCH_QUERY_ERROR: number;
+    QCLOUD_CHOOSE_ENVIRONMENT_ERROR: number;
+    QCLOUD_UPLOAD_FAIL: number;
+    TOOLBAR_REMOTE_DEBUG_ERROR: number;
+    PREPROCESS_UPLOAD_ERROR: number;
+    DOWNLOAD_SOURCEMAP_ERROR: number;
+    SOURCEMAP_WRITE_ERROR: number;
+    CLEAN_USER_AUTH_ERROR: number;
+    JUMP_WXGIT_ERROR: number;
+    TCB_DELETE_FAILED: number;
+    FETCH_REMOTE_SETTING_ERROR: number;
+    UPLOAD_LOCAL_SETTING_ERROR: number;
+    UPLOAD_SOURCE_CODE_ERROR: number;
+    UPLOAD_EXCEED_SIZE_LIMIT: number;
+    PROJECT_CONFIG_JSON_ERROR: number;
+    TEST_CODE_RUN_ERROR: number;
+    AUTO_UPLOAD_ERROR: number;
+    CLOUD_UPLOAD_OPEN_ERROR: number;
+    CLOUD_BUILD_OPEN_ERROR: number;
+    WEBVIEW_NETWORK_ERROR: number;
+    APPSERVICE_NETWORK_ERROR: number;
+    PLUGIN_ERROR: number;
+    ONLINE_CODE_UNPACK_ERR: number;
+    URL_SCHEME_INVALID_ERROR: number;
+    URL_SCHEME_OTHER_ERROR: number;
+    APP_UPGRADE_ERROR: number;
+    APP_ADD_AUTHO_PAGE_ERROR: number;
+};
+export = appErrCode;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/common/tools.d.ts

@@ -0,0 +1 @@
+export declare function wrapCodeByEval(code: string): string;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/appconfig.d.ts

@@ -0,0 +1,6 @@
+import { IPipeContext } from '../../../types';
+declare function getAppConfig(context: IPipeContext, forceDarkMode?: boolean): Promise<DR<AppConfig.IAppConfig>>;
+declare const _default: {
+    getAppConfig: typeof getAppConfig;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/appjson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare const getCompiledAppJSON: (context: IPipeContext) => Promise<any>;
+export = getCompiledAppJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/customcomponent.d.ts

@@ -0,0 +1,21 @@
+import { IPipeContext } from '../../../types';
+interface IComponentsConfigReturn {
+    [p: string]: {
+        file: string;
+        config: DR<AppConfig.ISubpackageItem> | undefined;
+        pageJSON: IPageJSON;
+    };
+}
+declare function getFileListJustInPack(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare function getWxssCompileConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare function getWxmlCompileConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<any[]>;
+declare function getWxmlCompileLazyConfig(context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>, config?: DR<AppConfig.ISubpackageItem>): Promise<string[]>;
+declare const _default: {
+    getFileListJustInPack: typeof getFileListJustInPack;
+    getWxssCompileConfig: typeof getWxssCompileConfig;
+    getWxmlCompileConfig: typeof getWxmlCompileConfig;
+    getWxmlCompileLazyConfig: typeof getWxmlCompileLazyConfig;
+    getCustomComponentsConfig: (context: IPipeContext, appConfig: DR<AppConfig.IAppConfig>) => Promise<IComponentsConfigReturn>;
+    findSubpackageForFile: (file: string, appConfig: DR<AppConfig.IAppConfig>) => DR<AppConfig.ISubpackageItem> | undefined;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/helper/theme.d.ts

@@ -0,0 +1,40 @@
+import { PipeCPProject } from '../../../../pipeCPProject';
+export declare function checkTabbarListItemIconPath(prefix: string, absolutePath: string, project: PipeCPProject): any[];
+export declare function checkThemeRules(projectPath: string, project?: PipeCPProject): {
+    windowConfigRules: ({
+        key: string;
+        valids: string[];
+        hexColor?: undefined;
+    } | {
+        key: string;
+        hexColor: boolean;
+        valids?: undefined;
+    })[];
+    tabbarRules: ({
+        key: string;
+        hexColor: boolean;
+        valids?: undefined;
+    } | {
+        key: string;
+        valids: string[];
+        hexColor?: undefined;
+    })[];
+    tabbarListItemRules: {
+        key: string;
+        validate: (key: string, value: string) => void;
+    }[];
+};
+export declare function getDefaultWindowConfig(isDarkMode: boolean): {
+    backgroundColor: string;
+    backgroundTextStyle: string;
+};
+export declare function checkVariables(options: {
+    isDarkMode: boolean;
+    themeLocation: string;
+    filePath: string;
+    windowConfig: IStringKeyMap;
+    themeJSON: IStringKeyMap;
+    rules: any[];
+    keyPrefix: string;
+    isPlugin?: boolean;
+}): void;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/pagejson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare const getCompiledPageJSON: (context: IPipeContext, pagePath: string) => Promise<any>;
+export = getCompiledPageJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/project/wxappcodejson.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext } from '../../../types';
+declare function getWXAppCodeJSON(context: IPipeContext, pagePath: string): Promise<any>;
+export = getWXAppCodeJSON;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/trans/transwxmltojs.d.ts

@@ -0,0 +1,19 @@
+import { IPipeContext } from '../../../types';
+interface ITransWxmlOptions {
+    app?: boolean;
+    page?: string;
+    cut?: boolean;
+    hotReloadFile?: string;
+}
+interface IWXMLReturn {
+    name: string;
+    comm?: string;
+    code: string;
+    names?: AnyObject;
+    pages?: AnyObject;
+}
+declare function transWXMLToJS(context: IPipeContext, options?: ITransWxmlOptions): Promise<IWXMLReturn>;
+declare const _default: {
+    transWXMLToJS: typeof transWXMLToJS;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/trans/transwxsstojs.d.ts

@@ -0,0 +1,15 @@
+import { IPipeContext } from '../../../types';
+interface ITransWxssOptions {
+    app?: boolean;
+    page?: string;
+    hotReloadFile?: string;
+}
+interface IWxssReturn {
+    comm: string;
+    page?: string;
+}
+declare function transWXSSToJS(context: IPipeContext, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare const _default: {
+    transWXSSToJS: typeof transWXSSToJS;
+};
+export = _default;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/utils/web/processPath.d.ts

@@ -0,0 +1,9 @@
+interface INormalizePathOptions {
+    leading?: string;
+    noLeading?: string;
+    trailing?: string;
+    noTrailing?: string;
+}
+export declare function normalizePath(pathName?: string, options?: INormalizePathOptions): string;
+export declare function isLeftSubPathOfRight(child: string, parent: string): boolean;
+export {};

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/wccPipe.d.ts

@@ -0,0 +1,3 @@
+import { ICompileWxmlOptions } from '~/services/compilewxml/common/compilewxmlService';
+import { IPipeDefinition } from '../types';
+export declare const wccPipe: IPipeDefinition<ICompileWxmlOptions>;

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

@@ -0,0 +1,100 @@
+import { ICompileResult, ICompileWxmlOptions, ICompileWxmlToGlassEasel, IGlassEaselCompileResult } from '~/services/compilewxml/common/compilewxmlService';
+import { ICompileWxssOptions, ICompileWxssResult } from '~/services/compilewxss/common/compilewxssService';
+import { vsbase } from '../../../../services/common/vsbase';
+import { MiniProgramCore } from '../../../../types';
+import { PipeCPProject } from './pipeCPProject';
+import type { IBackendContextFromWeb } from '~/types/type';
+type ServiceIdentifier<T> = vsbase.vs.platform.instantiation.common.instantiation.$types.ServiceIdentifier<T>;
+export declare enum EPipeCMD {
+    WCC = "WCC",
+    TRANS_WXML_TO_GLASS_EASEL = "TRANS_WXML_TO_GLASS_EASEL",
+    COMPILE_WXSS = "COMPILE_WXSS",
+    PAGEFRAME = "PAGEFRAME",
+    PAGE_INIT_SOURCE = "PAGE_INIT_SOURCE",
+    APPSERVICE = "APPSERVICE"
+}
+export interface IPipiInputOutputType<T, P> {
+    input: T;
+    output: P;
+}
+export type IPipeParamOutputTypeMap = {
+    [EPipeCMD.WCC]: IPipiInputOutputType<ICompileWxmlOptions, ICompileResult>;
+    [EPipeCMD.TRANS_WXML_TO_GLASS_EASEL]: IPipiInputOutputType<ICompileWxmlToGlassEasel, IGlassEaselCompileResult>;
+    [EPipeCMD.COMPILE_WXSS]: IPipiInputOutputType<ICompileWxssOptions, ICompileWxssResult>;
+    [EPipeCMD.PAGEFRAME]: IPipiInputOutputType<{
+        isMultiPkg?: boolean;
+    }, string>;
+    [EPipeCMD.PAGE_INIT_SOURCE]: IPipiInputOutputType<{
+        filepath: string;
+    }, string>;
+    [EPipeCMD.APPSERVICE]: IPipiInputOutputType<Record<string, never>, string>;
+};
+export interface IPipeDefinition<TParams = any, TOutput = unknown> {
+    name: string;
+    timeout?: number;
+    execute(context: IPipeContext, params: TParams): Promise<TOutput>;
+}
+export interface IPipeContext {
+    requestPipe<T = unknown>(pipeName: string, params?: Record<string, unknown>): Promise<T>;
+    callCompiler<T = unknown>(method: string, ...args: unknown[]): Promise<T>;
+    project: PipeCPProject;
+    getService<T>(id: ServiceIdentifier<T>): T;
+}
+export interface IPipeProjectSerializeInfo {
+    appid: string;
+    attr: any;
+    type: MiniProgramCore.ProjectType;
+    projectPath: string;
+    projectArchitecture: MiniProgramCore.IProjectArchitecture;
+    miniprogramRoot: string;
+    pluginRoot: string;
+    setting: any;
+    backendProjectContext?: IBackendContextFromWeb;
+    projectContext?: {
+        projectId: string;
+        versionId: string;
+        ticket: string;
+        sessionId: string;
+    };
+}
+export type IPipeRequest = {
+    type: 'pipe';
+    requestId: string;
+    name: string;
+    params?: Record<string, unknown>;
+} | {
+    type: 'compiler';
+    requestId: string;
+    method: string;
+    args: unknown[];
+};
+export interface IPipeResponse {
+    requestId: string;
+    data?: any;
+    error?: {
+        code: number;
+        message: string;
+        stack: string;
+    };
+}
+export interface IPipeTaskData {
+    pipeName: string;
+    params?: Record<string, unknown>;
+    projectInfo: IPipeProjectSerializeInfo;
+}
+export interface IPipeTaskResult {
+    error?: any;
+    result?: any;
+}
+export interface IExecutePipeData {
+    pipeName: string;
+    params?: Record<string, unknown>;
+    backendProjectContext?: IBackendContextFromWeb;
+    projectContext?: {
+        projectId: string;
+        versionId: string;
+        ticket: string;
+        sessionId: string;
+    };
+}
+export {};

package/dist/@types/modules/corecompiler/summer/plugins/script_task/minify_script_task.d.ts

@@ -1,5 +1,5 @@
 import { MiniProgramSummer } from '../../../../../types';
 export declare function doCompress(targetPath: string, target: Pick<MiniProgramSummer.GenerateDescription, 'code' | 'map'>): Promise<{
     code: string;
-    map: string | import("source-map").RawSourceMap | undefined;
+    map: string | import("@jridgewell/gen-mapping").EncodedSourceMap | undefined;
 }>;

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

@@ -23,13 +23,19 @@ export declare class SummerCompiler extends BaseCoreCompiler {
     _status: MiniProgramDevtools.ICompilerStatus | undefined;
     private _eventAdded;
     private _locale;
+    private _initServiceForkId;
     private devCodeCacheByPath;
     constructor(project: MiniProgramCore.IPreCompileProject, cachePath: string, projectInfo: MiniProgramDevtools.IDevtoolsProjectInfo, devtoolMessagehub: IMessageHub, analyzer: Analyzer | null, _filterFactory?: MiniProgramDevtools.IFilterFactory | undefined, onInitFinished?: ((e?: Error) => void) | undefined);
     get status(): MiniProgramDevtools.ICompilerStatus | undefined;
     protected init(): Promise<void>;
+    private initServiceAndLoadStatus;
+    private ensureInitService;
+    private safeRunTask;
     private loadStatus;
     destroy(): void;
     clearCache(): Promise<void>;
+    dumpWorkerTaskStats(): Promise<void>;
+    clearWorkerTaskStats(): Promise<void>;
     getProjectInfo(): MiniProgramDevtools.IDevtoolsProjectInfo;
     updateOptions(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;
     updateOptionsWithoutJudge(options: MiniProgramDevtools.IDevtoolsProjectInfo): void;

package/dist/@types/modules/fullcompiler/appservice/appservice.config.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    noBrowser: string;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/appservice/generatecode.utils.d.ts

@@ -0,0 +1,12 @@
+import { RawSourceMap } from 'source-map';
+declare function inlineSourceMap(sourceCode: string, sourceMap?: string | RawSourceMap, sourceURL?: string): string;
+declare function inlineSourceMapFile(sourceCode: string, sourceMapPath?: string): string;
+declare function wrapSourceCodeInDefine(filename: string, sourceCode: string, inject?: string): string;
+declare function wrapGameSourceCodeInDefine(filename: string, sourceCode: string, inject?: string): string;
+declare const _default: {
+    inlineSourceMap: typeof inlineSourceMap;
+    inlineSourceMapFile: typeof inlineSourceMapFile;
+    wrapSourceCodeInDefine: typeof wrapSourceCodeInDefine;
+    wrapGameSourceCodeInDefine: typeof wrapGameSourceCodeInDefine;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/appservice/getappservice.d.ts

@@ -0,0 +1,9 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+export default function getAppService(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler): Promise<{
+    success: boolean;
+    content: any;
+}>;
+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: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, mainContentScript: string[], wxmlXCJS: any, componentFiles: string[], pageFiles: string[]): Promise<void>;

package/dist/@types/modules/fullcompiler/appservice/getcompiledjs.d.ts

@@ -0,0 +1,32 @@
+import { RawSourceMap } from 'source-map';
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+export type CompileResultType = 'production' | 'dev';
+export interface ICompileResult {
+    map?: RawSourceMap;
+    mapString?: string;
+    basenameMapString?: string;
+    code: string;
+    helpers: MiniProgramCore.IStringKeyMap;
+    customTranslated: boolean;
+    isLargeFile: boolean;
+    needCompile: boolean;
+    isBabelIgnore: boolean;
+    filePath?: string;
+    fromCache?: boolean;
+    cacheKey?: string;
+    mtime?: number;
+}
+interface IGetCompiledJSOptions {
+    relativePath: string;
+    fileName: string;
+    resultType: CompileResultType;
+    nameMapping?: MiniProgramCore.IStringKeyMap;
+    type: 'game' | 'gamePlugin' | 'miniProgram' | 'miniProgramPlugin';
+    onAfterRun?: MiniProgramCore.FN<void>;
+    sourceCode?: string;
+    useEngineIDE?: boolean;
+}
+export declare const getCompiledJS: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, options: IGetCompiledJSOptions) => Promise<ICompileResult>;
+export declare const compileMiniProgramJS: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, fileName: string) => Promise<ICompileResult>;
+export {};

package/dist/@types/modules/fullcompiler/appservice/getjsfile.d.ts

@@ -0,0 +1,18 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+import { ICompileResult } from './getcompiledjs';
+interface IGetJSFileOptions {
+    force?: boolean;
+    noWarnings?: boolean;
+    injectHelpers?: boolean;
+    injectHelpersSync?: boolean;
+    isGame?: boolean;
+    isWorkerFile?: boolean;
+    sourceURL?: string;
+    formatResult?: (result: ICompileResult) => ICompileResult;
+}
+declare function getJsFile(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, fileName: string, options?: IGetJSFileOptions): Promise<{
+    code: string;
+    helpers: string[];
+}>;
+export = getJsFile;

package/dist/@types/modules/fullcompiler/appservice/getmainpkgsortedjsfiles.d.ts

@@ -0,0 +1,12 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+declare const getMainPkgSortedJSFiles: (project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler) => Promise<{
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    functionalPageFiles: string[];
+    workerFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+}>;
+export = getMainPkgSortedJSFiles;

package/dist/@types/modules/fullcompiler/appservice/getsubpackage.d.ts

@@ -0,0 +1,7 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { AppJSON, MiniProgramCore } from '../../../types';
+export default function getSubpackageAppServiceBuild(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, subPackConfig: AppJSON.ISubpackageItem): Promise<{
+    success: boolean;
+    content: any;
+}>;
+export declare function getSubpackageAppServiceBuildCore(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, subPackConfig: AppJSON.ISubpackageItem): Promise<string>;

package/dist/@types/modules/fullcompiler/appservice/getsubpkgsortedjsfiles.d.ts

@@ -0,0 +1,10 @@
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+import { MiniProgramCore } from '../../../types';
+declare const getSubPkgSortedJSFiles: (project: MiniProgramCore.IPreCompileProject, compiler: SummerCompiler, rootPath: string) => Promise<{
+    allFiles: string[];
+    pageFiles: string[];
+    componentFiles: string[];
+    otherFiles: string[];
+    extendedLibFiles: string[];
+}>;
+export = getSubPkgSortedJSFiles;

package/dist/@types/modules/fullcompiler/appservice/getwxappcode.d.ts

@@ -0,0 +1,13 @@
+import { MiniProgramCore } from '../../../types';
+import { SummerCompiler } from '../../corecompiler/summerCompiler';
+declare function getWxAppCode(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, requireDirectly?: boolean): Promise<string>;
+declare function getWxAppCodeOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pathName: string, genFnName: string, requireDirectly?: boolean): Promise<string>;
+declare function getWxAppCodeJsonOfPage(project: MiniProgramCore.IPreCompileProject, summerCompiler: SummerCompiler, pathName: string): Promise<string>;
+declare function getWxAppCodeWxmlOfPage(project: MiniProgramCore.IPreCompileProject, pathName: string, wxmlGenFnName: string, requireDirectly?: boolean): string;
+declare const _default: {
+    getWxAppCode: typeof getWxAppCode;
+    getWxAppCodeOfPage: typeof getWxAppCodeOfPage;
+    getWxAppCodeJsonOfPage: typeof getWxAppCodeJsonOfPage;
+    getWxAppCodeWxmlOfPage: typeof getWxAppCodeWxmlOfPage;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/config/apperrcode.config.d.ts

@@ -0,0 +1,48 @@
+export declare const appErrCode: {
+    APP_JSON_READ_ERR: number;
+    APP_JSON_PARSE_ERR: number;
+    APP_JSON_PAGES_ERR: number;
+    APP_JSON_ENTRANCE_NOT_FOUND_ERR: number;
+    APP_JSON_CONTENT_ERR: number;
+    PAGES_JSON_PARSE_ERR: number;
+    APP_JSON_WXML_NOT_FOUND: number;
+    APP_JSON_JS_NOT_FOUND: number;
+    JSON_CONTENT_ERR: number;
+    EXT_JSON_PARSE_ERR: number;
+    EXT_JSON_PAGES_ERR: number;
+    EXT_JSON_CONTENT_ERR: number;
+    APPSERVICE_LOSE_WXML: number;
+    APPSERVICE_LOSE_JS: number;
+    FILE_NOT_UTF8: number;
+    BABEL_TRANS_JS_ERR: number;
+    UGLIFY_JS_ERR: number;
+    BABILI_JS_ERR: number;
+    JS_ES6_ERR: number;
+    FILE_FLAT_ERR: number;
+    POST_WXSS_ERR: number;
+    TRANS_WXML_JS_ERR: number;
+    TRANS_WXSS_JS_ERR: number;
+    SUMMER_PLUGIN_ERR: number;
+    SUMMER_PLUGIN_CODE_ERR: number;
+    VENDOR_MD5_NOT_MATCH: number;
+    VENDOR_WCC_FILE_NOT_FOUND: number;
+    VENDOR_WCSC_FILE_NOT_FOUND: number;
+    CODE_SIZE_EXCEED: number;
+    GET_GEO_LOCATION_ERR: number;
+    QCLOUD_SVR_NO_FOUND_ERR: number;
+    QCLOUD_SVR_POLL_TIMEOUT: number;
+    QCLOUD_SVR_POLL_DOING: number;
+    QCLOUD_SVR_UP_DIR_CHECK: number;
+    PLUGIN_JSON_READ_ERR: number;
+    PLUGIN_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_CONTENT_ERR: number;
+    PLUGIN_PAGE_JSON_PARSE_ERR: number;
+    PLUGIN_JSON_FILE_NOT_FOUND: number;
+    PLUGIN_PAGE_JSON_CONTENT_ERR: number;
+    PLUGIN_TRANS_WXML_JS_ERR: number;
+    PLUGIN_TRANS_WXSS_JS_ERR: number;
+    PLUGIN_JS_ES6_ERR: number;
+    PLUGIN_ONLINE_CODE_UNPACK_ERR: number;
+    PAGE_JSON_PARSE_ERR: number;
+    SITE_MAP_JSON_CONTENT_ERROR: number;
+};

package/dist/@types/modules/fullcompiler/filerules.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    isFileIgnored: (file: string, ignoreRule: any, includeRule?: any) => any;
+    isFileIncluded: (file: string, ignoreRule: any, includeRule?: any) => any;
+};
+export = _default;

package/dist/@types/modules/fullcompiler/getallrawfiles.d.ts

@@ -0,0 +1,11 @@
+import { MiniProgramCore } from '../../types';
+import { SummerCompiler } from '../corecompiler/summerCompiler';
+export default function (project: MiniProgramCore.IPreCompileProject, compiler: SummerCompiler): Promise<{
+    success: boolean;
+    content: string[];
+    errMsg?: undefined;
+} | {
+    success: boolean;
+    errMsg: any;
+    content: Map<any, any>;
+}>;