miniprogram-ci 1.9.26 → 2.0.0

package/dist/@types/modules/corecompiler/original/json/signaturejson.d.ts

@@ -0,0 +1,21 @@
+import { MiniProgramCore } from '../../../../types';
+export interface IPluginWithPathInfo {
+    alias: string;
+    path: string;
+    friendlyPath: string;
+    provider: string;
+    version: string;
+}
+export declare const trailing: (str: string, tr: string) => string;
+export declare const friendlyPathMake: (rPath: string, pth: string) => string;
+export declare function getAllPluginsWithPath(project: MiniProgramCore.IPreCompileProject): Promise<IPluginWithPathInfo[]>;
+export declare function isPathValid(srcPath: string, str: string): boolean;
+export interface IPluginWithPathSignature {
+    provider: string;
+    signature: Array<{
+        fullPath: string;
+        md5: string;
+    }>;
+    fullPath: string;
+}
+export declare function getAllPluginSignatures(project: MiniProgramCore.IPreCompileProject): Promise<IPluginWithPathSignature[]>;

package/dist/@types/modules/corecompiler/original/json/sitemap.d.ts

@@ -0,0 +1,3 @@
+import { SiteMapJSON } from '../../../../types';
+import { ReactiveProject } from './reactiveCache';
+export declare const getSiteMapJSON: (project: ReactiveProject) => SiteMapJSON.ISiteMapJSON;

package/dist/@types/modules/corecompiler/original/json/theme.d.ts

@@ -0,0 +1,18 @@
+import { MiniProgramCore, AppJSON, PageJSON, ThemeJSON } from '../../../../types';
+import { ReactiveProject } from './reactiveCache';
+export declare const getThemeLocation: (project: ReactiveProject) => string | null;
+export declare function getPluginThemeLocation(project: MiniProgramCore.IPreCompileProject): Promise<string | null>;
+interface ITheme {
+    themeLocation: string;
+    isPlugin?: boolean;
+}
+export declare function checkThemeJSON(project: MiniProgramCore.IPreCompileProject, options: ITheme): ThemeJSON.IThemeJSON;
+export declare function mergeThemeJSONToAppJSON(themeJson: Readonly<ThemeJSON.IThemeJSON>, appJson: Readonly<AppJSON.IAppJSON>): {
+    appJSONLight: AppJSON.IAppJSON;
+    appJSONDark: AppJSON.IAppJSON;
+};
+export declare function mergeThemeJSONToPageJSON(themeJson: ThemeJSON.IThemeJSON, pageJSON: PageJSON.IPageJSON, pageJSONFilePath: string): {
+    pageJSONLight: PageJSON.IPageJSON;
+    pageJSONDark: PageJSON.IPageJSON;
+};
+export {};

package/dist/@types/modules/corecompiler/original/npm/packnpm.d.ts

@@ -0,0 +1,13 @@
+import { MiniProgramCore } from '../../../../types';
+export declare function packNpm(project: MiniProgramCore.IPreCompileProject, opts?: MiniProgramCore.IPackNpmOptions): Promise<MiniProgramCore.IWarnItem[]>;
+interface IPackNpmManuallyResult {
+    miniProgramPackNum: number;
+    otherNpmPackNum: number;
+    warnList: MiniProgramCore.IWarnItem[];
+}
+export declare function packNpmManually(options: {
+    packageJsonPath: string;
+    miniprogramNpmDistDir: string;
+    ignores?: string[];
+}): Promise<IPackNpmManuallyResult>;
+export {};

package/dist/@types/modules/corecompiler/original/protect/uglifyfilenames.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { IGameJSON, MiniProgramCore } from '../../../../types';
+interface INameMapping {
+    [origin: string]: string;
+}
+export declare const getNameMapping: (project: MiniProgramCore.IPreCompileProject, root: string) => Promise<INameMapping>;
+export declare const getGameNameMapping: (project: MiniProgramCore.IPreCompileProject, gameJSON: IGameJSON, fileList: string[]) => Promise<INameMapping>;
+export declare function uglifyFileNames(project: MiniProgramCore.IPreCompileProject, prevResult: MiniProgramCore.IStringKeyMap<string | Buffer>, nameMapping?: INameMapping): Promise<MiniProgramCore.IAnyObject>;
+export {};

package/dist/@types/modules/corecompiler/original/utils/env.d.ts

@@ -0,0 +1,7 @@
+type ProcessEnv = 'main' | 'childprocess' | 'workerthread' | 'workerprocess';
+type HostEnv = 'devtools' | 'ci';
+export declare const processEnv: ProcessEnv;
+export declare const hostEnv: HostEnv;
+export declare const summerProcess: boolean;
+export declare const nativeProcess: boolean;
+export {};

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,8 @@
+import { ISchema, IValidateResult } from '../../../../../../schema/dist';
+export declare const config: {
+    [key: string]: ISchema;
+};
+export type FILE = 'app' | 'ext' | 'game' | 'page' | 'plugin' | 'pluginpage' | 'projectconfig' | 'sitemap' | 'theme';
+export declare function schemaValidate(file: FILE, instance: any): IValidateResult;
+export declare function transValidateResult(filePath: string, validateResult: IValidateResult, dontThrow?: boolean): string;
+export declare const NEW_CHECK_JSON_WAY = true;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,3 @@
+import T from './validate';
+declare const _default: T;
+export = _default;

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

@@ -0,0 +1,16 @@
+import { MiniProgramCore } from '../../../../types';
+export declare class ChildProcessCrashedError extends Error {
+    type: 'ERR_WORKER_OUT_OF_MEMORY';
+    constructor(type: 'ERR_WORKER_OUT_OF_MEMORY', message: string);
+}
+declare class TaskManager {
+    private _taskQueue;
+    private _instance;
+    runTask(name: string, data: any, onStatusUpdate?: MiniProgramCore.FN<void>): Promise<unknown>;
+    private _run;
+    private allocChildProcess;
+    private onChildProcessExit;
+    private onTaskDone;
+}
+export declare const childProcessManager: TaskManager;
+export {};

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

@@ -0,0 +1,4 @@
+import { MiniProgramCore } from '../../../../types';
+export * from './config';
+export declare function runTask(taskName: string, data: any, onUpdate?: MiniProgramCore.FN<void>): Promise<any>;
+export declare function abortTask(taskName: string): void;

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

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { MiniProgramDevtools } from '../../../../../types';
+interface ICompileData {
+    projectPath: string;
+    root: string;
+    filePath: string;
+    code: Buffer | String;
+    setting: MiniProgramDevtools.IProjectSetting;
+    babelRoot: string;
+    babelIgnore: any[];
+}
+declare function compileJS(data: ICompileData): Promise<{
+    error: null;
+    isLargeFile: boolean;
+    isBabelIgnore: boolean;
+    map: string | undefined;
+    code: string;
+    helpers: never[];
+} | {
+    error: {
+        path: string;
+        name: string;
+        message: string;
+        stack?: string | undefined;
+    } | {
+        path: string;
+        message: string;
+        code: number;
+    };
+    isLargeFile?: undefined;
+    isBabelIgnore?: undefined;
+    map?: undefined;
+    code?: undefined;
+    helpers?: undefined;
+} | {
+    error: null;
+    isLargeFile: false;
+    isBabelIgnore: false;
+    map: string;
+    code: string;
+    helpers: string[];
+}>;
+export = compileJS;

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { MiniProgramDevtools } from '../../../../../types';
+interface ICompileData {
+    projectPath: string;
+    root: string;
+    filePath: string;
+    setting: MiniProgramDevtools.IProjectSetting;
+    code: Buffer;
+}
+declare function compileWXSS(data: ICompileData): Promise<{
+    error: null;
+    code: string;
+} | {
+    error: {
+        code: number;
+        path: string;
+        message: any;
+    };
+    code?: undefined;
+}>;
+export = compileWXSS;

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

@@ -0,0 +1,2 @@
+declare function processTask(taskName: string, data: any): Promise<any>;
+export = processTask;

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

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

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

@@ -0,0 +1,19 @@
+import { MiniProgramCore } from '../../../../types';
+export declare const AbortEvent = "WorkerTaskAborted";
+declare class WorkerManager {
+    private _taskQueue;
+    private _workerPool;
+    private _max_pool_size;
+    constructor(size: number, isDevtools?: boolean);
+    runTask(name: string, data: any, onStatusUpdate?: MiniProgramCore.FN<void>): Promise<unknown>;
+    abort(name: string): void;
+    private _run;
+    private allocWorker;
+    private workerCount;
+    private onWorkerExit;
+    private _actualWorkerPoolSize;
+    private _doneThreadSet;
+    private onTaskDone;
+}
+export declare const getWorkerManager: (isDevtools?: boolean) => WorkerManager;
+export {};

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

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+import { MiniProgramCore, PluginJSON, ExtJSON, MiniProgramDevtools } from '../../types';
+import { BaseCoreCompiler } from './baseCompiler';
+import { OriginalCompileManager } from './original';
+import { FileInfo } from './summer/graph/basegraph';
+export declare class OriginalCompiler extends BaseCoreCompiler {
+    readonly isSummer = false;
+    compileManager: OriginalCompileManager | undefined;
+    constructor(project: MiniProgramCore.IPreCompileProject);
+    destroy(): void;
+    init(): Promise<void>;
+    isGameApp(): Promise<boolean | undefined>;
+    protected checkProject(): void;
+    getExtJSON(): Promise<ExtJSON.IExtJSON>;
+    getAppJSON(): Promise<any>;
+    getSiteMapJSON(): Promise<import("../../types").SiteMapJSON.ISiteMapJSON>;
+    getPageJSON(pagePath: string): Promise<import("../../types").PageJSON.IPageJSON>;
+    getGameJSON(): Promise<import("../../types").IGameJSON>;
+    getPluginJSON(localPath?: string): Promise<PluginJSON.IPluginJSON>;
+    getPluginPageJSON(pagePath: string): Promise<import("../../types").PageJSON.IPageJSON>;
+    getPluginComponents(): Promise<string[]>;
+    getWxssMap(_graphId: string, _wxssPath: string): void;
+    getPluginJSFiles(): Promise<{
+        jsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPluginWxssFiles(): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPluginWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getMPFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    getPluginFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    checkThemeJSON(options: {
+        themeLocation: string;
+        isPlugin?: boolean;
+    }): Promise<import("../../types").ThemeJSON.IThemeJSON>;
+    compile(options: MiniProgramCore.ICompileOptions): Promise<{
+        [x: string]: string | Buffer;
+    }>;
+    compileJS(options: {
+        root: string;
+        filePath: string;
+        babelRoot: string;
+        sourceCode?: string;
+        setting: {
+            es6: boolean;
+            es7: boolean;
+            minify: boolean;
+            disableUseStrict?: boolean;
+            compileWorklet?: boolean;
+        };
+        onProgressUpdate: any;
+    }): Promise<{
+        filePath: string;
+        code: string;
+        helpers: string[];
+        map: string | import("source-map").RawSourceMap;
+    }>;
+    setLocale(locale: string): void;
+    clearCache(): void;
+    getPackageWxssFiles(_packagePath: string): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getPackageWxmlAndWxsFiles(_packagePath: string): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getAllWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    getAllSortedJSFiles(): Promise<{
+        otherJsFiles: string[];
+        jsPagesFiles: string[];
+        components: string[];
+    }>;
+    getMainPkgSortedJSFiles(): Promise<{
+        hasAppJS: boolean;
+        allFiles: string[];
+        pageFiles: string[];
+        functionalPageFiles: string[];
+        workerFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string): Promise<FileInfo[]>;
+    getSubPkgSortedJSFiles(_rootPath: string): Promise<{
+        allFiles: string[];
+        pageFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    getCompAndPagesOfConf(): Promise<{
+        pages: Record<string, any>;
+        comps: Record<string, any>;
+    }>;
+    getAllPageAndComponent(): Promise<string[]>;
+}

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

@@ -0,0 +1,36 @@
+import { MiniProgramBaseConf } from './baseconf';
+import { Recorder } from '../../../../utils/progressRecorder';
+export declare class AppConf extends MiniProgramBaseConf {
+    private app;
+    private packages;
+    private pages;
+    private comps;
+    private sitemap;
+    private theme;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<{
+        app: any;
+        packages: {
+            [k: string]: any;
+        };
+        pages: {
+            [k: string]: any;
+        };
+        comps: {
+            [k: string]: any;
+        };
+        sitemap: any;
+        theme: any;
+    }>;
+    buildPagesAndCompsForUpload(recorder: Recorder, disabelSpreadingUsingComponent?: boolean): Promise<{
+        pageResults: Record<string, string>;
+        componentResults: Record<string, string>;
+    }>;
+    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string) => void;
+    protected resetState(): Promise<void>;
+    protected load(recorder: Recorder): Promise<void>;
+    protected loadPage(path: string): Promise<void>;
+    protected loadComp(resolvedPath: string, literalPath: string, from: string): Promise<void>;
+    private loadTheme;
+    private isExtendedLibComp;
+}

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

@@ -0,0 +1,24 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../../types';
+import { Recorder } from '../../../../utils/progressRecorder';
+import { BaseGraph, IGraphOptions } from './basegraph';
+export declare class AppGraph extends BaseGraph {
+    private appConf;
+    protected conf: MiniProgramDevtools.IAppConf | undefined;
+    constructor(options: IGraphOptions);
+    protected getWhiteListConfig(): Promise<Set<string>>;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<MiniProgramDevtools.IAppConf>;
+    compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    getDevCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    getProdCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    protected getLocalCodeFileList(): string[];
+    protected onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
+    protected getIndependentRoot(targetPath: string): string;
+    protected checkFilePackage(path: string): string;
+    protected compileJSON(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<{
+        conf: MiniProgramDevtools.IAppConf;
+        jsons: {
+            [x: string]: string;
+        };
+    }>;
+}

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

@@ -0,0 +1,16 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { MiniProgramCore } from '../../../../types';
+export declare abstract class BaseConf {
+    protected proxyProject: MiniProgramCore.IPreCompileProject;
+    protected root: string;
+    constructor(proxyProject: MiniProgramCore.IPreCompileProject, root: string);
+    protected abstract resetState(): Promise<void>;
+    protected abstract load(recorder: Recorder): Promise<void>;
+    protected build(recorder: Recorder): Promise<void>;
+    abstract destroy(): void;
+    abstract getConf(recorder: Recorder): Promise<Record<string, any>>;
+}
+export declare abstract class MiniProgramBaseConf extends BaseConf {
+    protected abstract loadPage(path: string): Promise<void>;
+    protected abstract loadComp(resolvedPath: string, literalPath: string, from: string): Promise<void>;
+}

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

@@ -0,0 +1,88 @@
+import { PluginDriver } from '../pluginDriver';
+import { MiniProgramSummer, MiniProgramDevtools, MiniProgramCore } from '../../../../types';
+import Module from '../module';
+import { SummerCompiler } from '../summer';
+import { ResolveFileInfo, Resolver } from '../resolver';
+import { Recorder } from '../../../../utils/progressRecorder';
+import PersistCache from '../persistCache';
+export declare enum FileType {
+    JSON = "json",
+    WXML = "wxml",
+    WXSS = "wxss",
+    WXS = "wxs",
+    JS = "js"
+}
+export declare enum JSONType {
+    APP = "app",
+    Page = "page",
+    EXT = "ext",
+    SITEMAP = "sitemap",
+    THEME = "theme"
+}
+type GraphType = 'miniprogram' | 'plugin' | 'other' | 'minigame';
+export type FileInfo = ResolveFileInfo & {
+    independentRoot: string;
+    isBabelIgnore: boolean;
+};
+export interface IGraphOptions {
+    type: GraphType;
+    root: string;
+    persistCache: PersistCache;
+    plugins: MiniProgramSummer.SummerPlugin[];
+    compiler: SummerCompiler;
+}
+export declare abstract class BaseGraph {
+    pluginDriver: PluginDriver;
+    modulesByPath: Map<string, Module>;
+    root: string;
+    rootPath: string;
+    persistCache: PersistCache;
+    type: GraphType;
+    compiler: SummerCompiler;
+    project: MiniProgramCore.IPreCompileProject;
+    cachedModules: Map<string, MiniProgramSummer.ModuleJSON>;
+    resolver: Resolver;
+    private invalidated;
+    private running;
+    protected _whiteListConfig: Set<string> | undefined;
+    protected conf: MiniProgramDevtools.IAppConf | MiniProgramDevtools.IGameConf | MiniProgramDevtools.IGamePluginConf | undefined;
+    constructor(options: IGraphOptions);
+    destroy(): void;
+    clearCache(): void;
+    protected ensureConf(recorder: Recorder): Promise<void>;
+    getPackageFile(root: string): Promise<FileInfo[]>;
+    protected abstract checkFilePackage(path: string): string;
+    protected abstract getIndependentRoot(targetPath: string): string;
+    private onFileChange;
+    private onFileAndDirChange;
+    private invalidateModules;
+    private loadModuleFromFile;
+    private loadSourceForModule;
+    protected doCompileSingleCode(info: FileInfo, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    private getCodeFileTask;
+    protected getCodeFiles(files: FileInfo[], recorder: Recorder, options?: MiniProgramCore.ICompileOptions & {
+        useCache: boolean;
+    }): Promise<MiniProgramDevtools.CodeFiles>;
+    private readFile;
+    private tranform;
+    private generate;
+    private optimize;
+    private compress;
+    compile(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<MiniProgramDevtools.ICompileResult>;
+    protected abstract getWhiteListConfig(): Promise<Set<string>>;
+    getLocalFileList(): Promise<MiniProgramCore.IFileInfos>;
+    private compileOther;
+    private compileCodeWithoutJSON;
+    protected isBabelSettingIgnore(fileInfo: ResolveFileInfo): boolean;
+    protected abstract onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
+    abstract getConf(recorder: Recorder): Promise<MiniProgramDevtools.IAppConf | MiniProgramDevtools.IPluginConf | MiniProgramDevtools.IGameConf | MiniProgramDevtools.IGamePluginConf>;
+    abstract getDevCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    abstract getProdCode(recorder: Recorder, options?: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    abstract compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    protected abstract compileJSON(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<{
+        conf: any;
+        jsons: Record<string, string>;
+    }>;
+    protected abstract getLocalCodeFileList(): string[];
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { BaseConf } from './baseconf';
+export declare class GameConf extends BaseConf {
+    private app;
+    private packages;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<{
+        app: any;
+        packages: {
+            [k: string]: any;
+        };
+    }>;
+    buildPagesAndCompsForUpload(recorder: Recorder, disabelSpreadingUsingComponent?: boolean): Promise<{
+        pageResults: {};
+        componentResults: {};
+    }>;
+    onFileChange: (type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string) => void;
+    protected resetState(): Promise<void>;
+    protected load(recorder: Recorder): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../../types';
+import { Recorder } from '../../../../utils/progressRecorder';
+import { BaseGraph, IGraphOptions } from './basegraph';
+export declare class GameGraph extends BaseGraph {
+    private appConf;
+    protected conf: MiniProgramDevtools.IGameConf | undefined;
+    constructor(options: IGraphOptions);
+    protected getWhiteListConfig(): Promise<Set<string>>;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<MiniProgramDevtools.IGameConf>;
+    compileSingleCode(filePath: string, sourceCode?: string): Promise<MiniProgramDevtools.CodeFile>;
+    getDevCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    getProdCode(recorder: Recorder, options: MiniProgramDevtools.IPackageCodeOptions & MiniProgramCore.ICompileOptions): Promise<MiniProgramDevtools.CodeFiles>;
+    protected getLocalCodeFileList(): string[];
+    protected onFileChangeForGraph(type: 'unlink' | 'unlinkDir' | 'add' | 'addDir' | 'change', path: string): void;
+    protected getIndependentRoot(targetPath: string): string;
+    protected checkFilePackage(path: string): string;
+    protected compileJSON(options: MiniProgramCore.ICompileOptions, recorder: Recorder): Promise<{
+        conf: MiniProgramDevtools.IGameConf;
+        jsons: {
+            [x: string]: string;
+        };
+    }>;
+}

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

@@ -0,0 +1,11 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { BaseConf } from './baseconf';
+export declare class GamePluginConf extends BaseConf {
+    private plugin;
+    destroy(): void;
+    getConf(recorder: Recorder): Promise<{
+        plugin: any;
+    }>;
+    protected resetState(): Promise<void>;
+    protected load(recorder: Recorder): Promise<void>;
+}