miniprogram-ci 1.9.27 → 2.0.0

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

@@ -0,0 +1,5 @@
+export declare const PLATFORM: {
+    'mini-android': string;
+    'mini-ios': string;
+    'mini-weixin': string;
+};

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

@@ -0,0 +1,25 @@
+export declare const GET_ATTR_URL: string;
+export declare const UPLOAD_URL: string;
+export declare const TEST_SOURCE_URL: string;
+export declare const GET_WHITE_EXT_LIST: string;
+export declare const GET_ONLINE_SCHEMA: string;
+export declare const GET_RAND_STRING: string;
+export declare const GET_DEV_SOURCE_MAP: string;
+export declare const TRANSLATE_FILENAME: string;
+export declare const GET_CLOUD_API_SIGNATURE: string;
+export declare const GET_UPLOAD_TOKEN: string;
+export declare const GET_ASYNC_RESULT: string;
+export declare const UPLOAD_JS_SERVER: string;
+export declare const GET_LATEST_VERSION: string;
+export declare const cloudAPIAgentURL: string;
+export declare const get3rdCloudCodeSecret: string;
+export declare const cloudCosUploadURL: string;
+export declare const scfTencentCloudUrl = "https://scf.tencentcloudapi.com";
+export declare const dbTencentCloudUrl = "https://flexdb.tencentcloudapi.com";
+export declare const tcbTencentCloudUrl = "https://tcb.tencentcloudapi.com";
+export declare const commitSourceNewFeatureURL: string;
+export declare const commitSourceURL: string;
+export declare const getUploadToken: string;
+export declare const testSourceURL: string;
+export declare const testSourceNewFeatureURL: string;
+export declare const getAsyncResult: string;

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

@@ -1,40 +1,29 @@
-import { Project } from './ci/project';
-import { upload as _upload } from './ci/upload';
-import { preview as _preview } from './ci/preview';
-import { getDevSourceMap as _getDevSourceMap } from './ci/getDevSourceMap';
-import { packNpm, packNpmManually } from './core/npm/packnpm';
-import { setCiProxy as proxy } from './utils/request';
-import { uploadFunction } from './cloud/uploadFunction';
-import { createTimeTrigger } from './cloud/createTimeTrigger';
-import { uploadContainer } from './cloud/uploadContainer';
-import { IUploadOptions } from './cloud/uploadFile';
-import { uploadJsServer } from './ci/jsserver';
-import { analyseCode } from './ci/code-analyse';
-import { getCompiledResult } from './ci/getCompiledResult';
-import { getLatestVersion } from './ci/getLatestVersion';
+import { BaseProject } from './project/baseProject';
+import { CIProject } from './project/ciProject';
+import { DevtoolsProject } from './project/devtoolsProject';
+import { WebProject } from './project/webProject';
+import { PreCompileProject } from './project/advance/precompileProject';
+import { BaseCoreCompiler, ICompileOptions } from './modules/corecompiler/baseCompiler';
+import { OriginalCompiler } from './modules/corecompiler/originalCompiler';
+import { SummerCompiler, ICompilerStatus } from './modules/corecompiler/summerCompiler';
+import { Builder } from './modules';
 import { getWhiteExtList } from './utils/white_ext_list';
-import { checkCodeQuality } from './ci/checkCodeQuality';
-export { Project };
-export type { IUploadOptions };
-export declare const upload: typeof _upload;
-export declare const preview: typeof _preview;
-export { getCompiledResult };
-export { packNpm };
-export { packNpmManually };
-export { proxy };
-export declare const getDevSourceMap: typeof _getDevSourceMap;
-export declare const cloud: {
-    uploadFunction: typeof uploadFunction;
-    createTimeTrigger: typeof createTimeTrigger;
-    uploadStaticStorage: (options: IUploadOptions) => Promise<void>;
-    uploadStorage: (options: IUploadOptions) => Promise<void>;
-    uploadContainer: typeof uploadContainer;
-};
-export { uploadJsServer };
-export { getLatestVersion };
-export { analyseCode };
-export { checkCodeQuality };
-export { getWhiteExtList };
-export * from './core';
-export * from './summer';
+import { setCiProxy as proxy } from './utils/request';
+import locales from './utils/locales/locales';
+import { checkIsInSubPackage, escapeQuot, escapeScript, generateMD5, isHexColor, mkdirSync, normalizePath } from './utils/tools';
+import { DefaultProjectAttr, JSON_CONTENT_ERR, compileTypeConfig } from './config/config';
+import { getBabelHelperVersion, getBabelHelperDepMap } from './utils/babel_helper';
+import { getSummerPluginConfig } from './modules/corecompiler/summer/pluginconfig';
+import { getHelperOutputPath, getHelperDeps, isValidHelperFunc, getHelperContent, getHelperName } from './utils/helper_util';
+import { updateContactBase64ForSubPkgs } from './modules/fullcompiler/app/contactandlaunch/updateContactForSubpkg';
+import { updateContactBase64 } from './modules/fullcompiler/app/contactandlaunch/updatecontactandlaunch';
+import * as adroidDeviceUtils from './modules/nativecompiler/android/device';
+import * as iosDeviceUtils from './modules/nativecompiler/ios/device';
+import * as miniappBuilder from './utils/miniapp-builder';
+export { BaseProject, CIProject as Project, CIProject, DevtoolsProject, WebProject, PreCompileProject, };
+export { BaseCoreCompiler, OriginalCompiler, SummerCompiler, ICompilerStatus, ICompileOptions, Builder, };
+export * from './modules/corecompiler/original';
 export declare const workletVersion: any;
+export { getWhiteExtList, proxy, locales, isHexColor, DefaultProjectAttr, JSON_CONTENT_ERR, compileTypeConfig, generateMD5, mkdirSync, normalizePath, checkIsInSubPackage, getHelperOutputPath, isValidHelperFunc, getHelperName, getHelperContent, getHelperDeps, getBabelHelperVersion, getBabelHelperDepMap, escapeQuot, escapeScript, updateContactBase64ForSubPkgs, updateContactBase64, getSummerPluginConfig, };
+export { adroidDeviceUtils, iosDeviceUtils, miniappBuilder, };
+export * from './ci/index';

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

@@ -0,0 +1,132 @@
+/// <reference types="node" />
+import { ExtJSON, AppJSON, IGameJSON, MiniProgramCore, PageJSON, PluginJSON, SiteMapJSON, ThemeJSON, MiniProgramDevtools } from '../../types';
+import { SingletonTask } from '../../utils/singletontask';
+import { FileInfo } from './summer/graph/basegraph';
+export type ICompileOptions = MiniProgramCore.ICompileOptions;
+export declare abstract class BaseCoreCompiler {
+    protected _checkReadyTask?: SingletonTask;
+    isSummer: boolean;
+    project: MiniProgramCore.IPreCompileProject;
+    protected isGameType(type: MiniProgramCore.ProjectType): boolean;
+    protected isPluginType(type: MiniProgramCore.ProjectType): boolean;
+    get projectPath(): string;
+    get srcPath(): string;
+    get pluginSrcPath(): string;
+    constructor(project: MiniProgramCore.IPreCompileProject);
+    protected abstract init(...args: any[]): any;
+    ready(): Promise<any>;
+    abstract destroy(): void;
+    watch(fn: MiniProgramCore.FN): void;
+    unwatch(fn: MiniProgramCore.FN): void;
+    compileJS(options: {
+        root: string;
+        filePath: string;
+        sourceCode?: string | undefined;
+        babelRoot: string;
+        setting: {
+            es6: boolean;
+            es7: boolean;
+            minify: boolean;
+            disableUseStrict?: boolean;
+            compileWorklet?: boolean;
+        };
+    }): Promise<any>;
+    compile(options: MiniProgramCore.ICompileOptions): any;
+    clearCache(): void;
+    uglifyFileNames(project: MiniProgramDevtools.IDevtoolsProject, result: Record<string, string | Buffer>, nameMapping: Record<string, string>): Promise<MiniProgramCore.IAnyObject>;
+    packNpm(options?: MiniProgramCore.IPackNpmOptions): Promise<MiniProgramCore.IWarnItem[]>;
+    packNpmManually(packTaskList: Array<{
+        packageJsonPath: string;
+        miniprogramNpmDistDir: string;
+    }>): Promise<MiniProgramCore.IWarnItem[]>;
+    stat(prefix?: string, filePath?: string): MiniProgramCore.IStat | undefined;
+    exists(prefix?: string, filePath?: string): boolean;
+    excludeRoot(fileList?: string[], prefix?: string): string[];
+    excludeKeyRoot(obj: any, prefix?: string): any;
+    getFile(prefix?: string, filePath?: string): Buffer;
+    getFileString(prefix?: string, filePath?: string): string;
+    getMPFileWithDir(prefix?: string): string[];
+    getMPFileList(prefix?: string, extName?: string): string[];
+    getMPWXMLFileList(filter?: string): string[];
+    getMPWXSFileList(filter?: string): string[];
+    getMPJSFileList(filter?: string): string[];
+    getMPWXSSFileList(filter?: string): string[];
+    getMPJSONFileList(filter?: string): string[];
+    getPluginFileList(prefix?: string, extName?: string): string[];
+    getPluginWXMLFileList(filter?: string): string[];
+    getPluginWXSFileList(filter?: string): string[];
+    getPluginJSFileList(filter?: string): string[];
+    getPluginWXSSFileList(filter?: string): string[];
+    getPluginJSONFileList(filter?: string): string[];
+    isValidComponent(prefix: string | undefined, filePath: string): boolean;
+    getAllFileInfo(prefix?: string): MiniProgramCore.IFileInfos;
+    abstract getMPFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    abstract getPackageWxssFiles(packagePath: string): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getPackageWxmlAndWxsFiles(packagePath: string): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getAllWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getPluginComponents(): Promise<string[]>;
+    abstract getPluginJSFiles(): Promise<{
+        jsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getPluginWxssFiles(): Promise<{
+        wxssFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getPluginWxmlAndWxsFiles(): Promise<{
+        wxmlFiles: string[];
+        wxsFiles: string[];
+        content: Record<string, string>;
+    }>;
+    abstract getPluginFileInfo(): Promise<MiniProgramCore.IFileInfos>;
+    abstract getAllSortedJSFiles(): Promise<{
+        otherJsFiles: string[];
+        jsPagesFiles: string[];
+        components: string[];
+    }>;
+    abstract getMainPkgSortedJSFiles(): Promise<{
+        hasAppJS: boolean;
+        allFiles: string[];
+        pageFiles: string[];
+        functionalPageFiles: string[];
+        workerFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    abstract getPackageFiles(graphId: MiniProgramDevtools.GraphId, root: string): Promise<FileInfo[]>;
+    abstract getSubPkgSortedJSFiles(rootPath: string): Promise<{
+        allFiles: string[];
+        pageFiles: string[];
+        componentFiles: string[];
+        otherFiles: string[];
+    }>;
+    abstract getAllPageAndComponent(): Promise<string[]>;
+    abstract getExtJSON(): Promise<ExtJSON.IExtJSON>;
+    abstract getAppJSON(): Promise<AppJSON.IAppJSON>;
+    abstract getSiteMapJSON(): Promise<SiteMapJSON.ISiteMapJSON>;
+    abstract getPageJSON(pagePath: string): Promise<PageJSON.IPageJSON>;
+    abstract getGameJSON(): Promise<IGameJSON>;
+    abstract getPluginPageJSON(pagePath: string): Promise<PluginJSON.IPluginpageJSON>;
+    abstract getPluginJSON(localPath: string): Promise<PluginJSON.IPluginJSON>;
+    abstract setLocale(locale: string): void;
+    abstract getWxssMap(graphId: MiniProgramDevtools.GraphId, wxssPath: string): any;
+    abstract getCompAndPagesOfConf(): Promise<{
+        pages: Record<string, any>;
+        comps: Record<string, any>;
+    }>;
+    abstract checkThemeJSON(options: {
+        themeLocation: string;
+        isPlugin?: boolean | undefined;
+    }): Promise<ThemeJSON.IThemeJSON>;
+}

package/dist/@types/modules/corecompiler/original/analyse/partial.d.ts

@@ -0,0 +1,25 @@
+import type { Analyzer, IModule, ModuleType } from '../../../../common/code-analyse';
+export declare function findAllDescendant(mod: IModule | IModule[], type: ModuleType): IModule[];
+export declare function partialGetSubPkgSortedJSFiles(analyzer: Analyzer, pages: string[], subPackage: string): {
+    allFiles: string[];
+    pageFiles: string[];
+    componentFiles: string[];
+};
+export declare function partialGetMainPkgSortedJSFiles(analyzer: Analyzer, pages: string[]): {
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    componentFiles: string[];
+};
+export declare function partialWholePkgGetSortedJSFiles(analyzer: Analyzer, pages: string[]): {
+    hasAppJS: boolean;
+    allFiles: string[];
+    pageFiles: string[];
+    componentFiles: string[];
+};
+export declare function partialGetWxmlAndWxsFiles(analyzer: Analyzer, pages: string[], subPackage?: string): {
+    wxmlFiles: string[];
+    wxsFiles: string[];
+};
+export declare function partialGetWxssFiles(analyzer: Analyzer, pages: string[], subPackage?: string): string[];
+export declare function partialGetCodeFiles(analyzer: Analyzer, pages: string[]): string[];

package/dist/@types/modules/corecompiler/original/compile/common.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { MiniProgramCore, ProjectConfigJSON } from '../../../../types';
+export declare function getBabelRoot(project: MiniProgramCore.IPreCompileProject): Promise<string>;
+export declare function isNotIgnoredByProjectConfig(projectConfig: MiniProgramCore.IAnyObject, root: string, file: string): boolean;
+export declare function compileOther(project: MiniProgramCore.IPreCompileProject, files: string[], options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer;
+}>;
+export declare function compileJSFiles(project: MiniProgramCore.IPreCompileProject, files: string[], root: string, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: string;
+}>;
+export declare function compileWXSSFiles(project: MiniProgramCore.IPreCompileProject, files: string[], root: string, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: string;
+}>;
+export declare function compileWXMLFiles(project: MiniProgramCore.IPreCompileProject, files: string[], root: string, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: string;
+}>;
+export declare function getUploadProjectConfig(project: MiniProgramCore.IPreCompileProject, projectConfig: ProjectConfigJSON.IProjectConfigJSON): Promise<MiniProgramCore.IAnyObject>;

package/dist/@types/modules/corecompiler/original/compile/game.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [x: string]: string | Buffer;
+}>;

package/dist/@types/modules/corecompiler/original/compile/gamePlugin.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compilePlugin(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;
+export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;

package/dist/@types/modules/corecompiler/original/compile/handler/js.d.ts

@@ -0,0 +1,15 @@
+import { RawSourceMap } from 'source-map';
+import { MiniProgramCore, MiniProgramDevtools } from '../../../../../types';
+export declare function compileJS(project: MiniProgramCore.IPreCompileProject, filePath: string, options: {
+    root?: string;
+    sourceCode?: string;
+    setting?: MiniProgramDevtools.IProjectSetting;
+    babelRoot?: string;
+    onProgressUpdate?: (status: MiniProgramCore.ITaskStatus) => void;
+    devToolsCompileCache?: MiniProgramCore.IDevToolsCompileCache;
+}): Promise<{
+    filePath: string;
+    code: string;
+    helpers: string[];
+    map: string | RawSourceMap;
+}>;

package/dist/@types/modules/corecompiler/original/compile/handler/mpjson.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../../types';
+export declare function addSkylineRendererToComponents(pageJSONResults: {
+    [key: string]: string;
+}, potantialComponentResults: {
+    [key: string]: string;
+}): void;
+export declare function compileJSON(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;

package/dist/@types/modules/corecompiler/original/compile/handler/wxml.d.ts

@@ -0,0 +1,9 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../../../types';
+export declare function compileWXML(project: MiniProgramCore.IPreCompileProject, filePath: string, options: {
+    root?: string;
+    setting?: MiniProgramDevtools.IProjectSetting;
+    onProgressUpdate?: (status: MiniProgramCore.ITaskStatus) => void;
+}): Promise<{
+    filePath: string;
+    code: string;
+}>;

package/dist/@types/modules/corecompiler/original/compile/handler/wxss.d.ts

@@ -0,0 +1,10 @@
+import { MiniProgramCore, MiniProgramDevtools } from '../../../../../types';
+export declare function compileWXSS(project: MiniProgramCore.IPreCompileProject, filePath: string, options: {
+    root?: string;
+    setting?: MiniProgramDevtools.IProjectSetting;
+    onProgressUpdate?: (status: MiniProgramCore.ITaskStatus) => void;
+    devToolsCompileCache?: MiniProgramCore.IDevToolsCompileCache;
+}): Promise<{
+    filePath: string;
+    code: string;
+}>;

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [x: string]: string | Buffer;
+}>;

package/dist/@types/modules/corecompiler/original/compile/miniprogram.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;

package/dist/@types/modules/corecompiler/original/compile/miniprogramPlugin.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compilePlugin(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;
+export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
+    [filePath: string]: Buffer | string;
+}>;

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

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { MiniProgramCore, PageJSON, PluginJSON } from '../../../types';
+import { setFSAgent } from '../../../utils/fs';
+import { compile } from './compile/index';
+import { getPageJSON } from './json/page/getPageJSON';
+import { compileJS } from './compile/handler/js';
+import { getDevPluginJSON as getPluginJSON } from './json/plugin/plugin';
+import { getPluginPageJSON } from './json/plugin/pluginPage';
+import { getSiteMapJSON } from './json/sitemap';
+import { checkThemeJSON, mergeThemeJSONToAppJSON, mergeThemeJSONToPageJSON } from './json/theme';
+import { schemaValidate } from './validate/schemaValidate';
+import { packNpm, packNpmManually } from './npm/packnpm';
+export * as partialAnalyse from './analyse/partial';
+declare const setLocale: (tag: string) => void;
+declare function getAppJSON(project: MiniProgramCore.IPreCompileProject): Promise<import("../../../types").AppJSON.IAppJSON>;
+declare function getExtJSON(project: MiniProgramCore.IPreCompileProject): Promise<import("../../../types").ExtJSON.IExtJSON | undefined>;
+declare function getGameJSON(project: MiniProgramCore.IPreCompileProject): Promise<import("../../../types").IGameJSON>;
+declare function clearCache(): void;
+export { getAppJSON, getExtJSON, getPageJSON, getGameJSON, getPluginJSON, getPluginPageJSON, checkThemeJSON, getSiteMapJSON, schemaValidate, mergeThemeJSONToAppJSON, mergeThemeJSONToPageJSON, packNpm, packNpmManually, compileJS, compile, clearCache, setLocale, setFSAgent, };
+export declare class OriginalCompileManager {
+    project: MiniProgramCore.IPreCompileProject;
+    constructor(project: MiniProgramCore.IPreCompileProject);
+    getAppJSON(): Promise<import("../../../types").AppJSON.IAppJSON>;
+    getExtJSON(): Promise<import("../../../types").ExtJSON.IExtJSON | undefined>;
+    getPageJSON(options: {
+        miniprogramRoot: string;
+        pagePath: string;
+    }): Promise<PageJSON.IPageJSON>;
+    getGameJSON(): Promise<import("../../../types").IGameJSON>;
+    getPluginJSON(...args: any[]): Promise<PluginJSON.IPluginJSON>;
+    checkThemeJSON(options: any): import("../../../types").ThemeJSON.IThemeJSON;
+    getSiteMapJSON(): import("../../../types").SiteMapJSON.ISiteMapJSON;
+    getPluginPageJSON: typeof getPluginPageJSON;
+    schemaValidate: typeof schemaValidate;
+    mergeThemeJSONToAppJSON: typeof mergeThemeJSONToAppJSON;
+    mergeThemeJSONToPageJSON: typeof mergeThemeJSONToPageJSON;
+    packNpm(...args: any[]): Promise<MiniProgramCore.IWarnItem[]>;
+    packNpmManually: typeof packNpmManually;
+    compileJS(filePath: string, options: any): Promise<{
+        filePath: string;
+        code: string;
+        helpers: string[];
+        map: string | import("source-map").RawSourceMap;
+    }>;
+    compile(options: MiniProgramCore.ICompileOptions): Promise<{
+        [x: string]: string | Buffer;
+    }>;
+    clearCache: typeof clearCache;
+    setLocale: (tag: string) => void;
+    setFSAgent: typeof setFSAgent;
+}

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

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { MiniProgramCore } from '../../../../types';
+export declare function compile(buffer: Buffer, filePath: string, settings: MiniProgramCore.ICompileSettings): void;

package/dist/@types/modules/corecompiler/original/js/minifyjs.d.ts

@@ -0,0 +1,16 @@
+import type { RawSourceMap } from 'source-map';
+import { MinifyOutput } from 'uglify-js';
+import type { MinifyOutput as TerserMinifyOutput } from 'terser';
+interface IOptions {
+    code: string;
+    useTerser: boolean;
+    filePath: string;
+    inputSourceMap?: RawSourceMap;
+}
+declare const minify: (options: IOptions) => TerserMinifyOutput | MinifyOutput | {
+    error: {
+        message: string;
+        code: number;
+    };
+};
+export = minify;

package/dist/@types/modules/corecompiler/original/js/minifyjsAfterWrap.d.ts

@@ -0,0 +1,12 @@
+interface IOptions {
+    code: string;
+    inputSourceMap?: import('source-map').RawSourceMap;
+    filePath: string;
+}
+declare const minifyAfterWrap: (options: IOptions) => import("terser").MinifyOutput | import("uglify-js").MinifyOutput | {
+    error: {
+        message: string;
+        code: number;
+    };
+};
+export = minifyAfterWrap;

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

@@ -0,0 +1,6 @@
+import { AppJSON } from '../../../../../types';
+import { ReactiveProject } from '../reactiveCache';
+import { IInnerAppJSONCheckOptions } from './checkAppFields';
+export declare function checkAppJSON(options: IInnerAppJSONCheckOptions): AppJSON.IAppJSON;
+export declare const getRawAppJSON: (project: ReactiveProject) => AppJSON.IAppJSON;
+export declare const getAppJSON: (project: ReactiveProject) => AppJSON.IAppJSON;

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

@@ -0,0 +1,43 @@
+import { ReactiveProject } from '../reactiveCache';
+import { AppJSON } from '../../../../../types';
+export interface IPageInfo {
+    path: string;
+    root: string;
+    name?: string;
+}
+export interface IInnerAppJSONCheckOptions {
+    project: ReactiveProject;
+    miniprogramRoot: string;
+    filePath: string;
+    inputJSON: AppJSON.IAppJSON;
+    mode?: 'light' | 'dark';
+}
+export declare function checkPageExist(options: IInnerAppJSONCheckOptions, page: string, tips: string): void;
+export declare function checkWindow(options: IInnerAppJSONCheckOptions): void;
+export declare function checkTabbar(options: IInnerAppJSONCheckOptions): void;
+export declare function checkWorkers(options: IInnerAppJSONCheckOptions): void;
+export declare function checkOpenLocationPagePath(options: IInnerAppJSONCheckOptions): void;
+export declare const checkMainPkgPages: (options: IInnerAppJSONCheckOptions) => void;
+export declare function checkSitemapLocation(options: IInnerAppJSONCheckOptions): void;
+export declare function checkSubpackages(options: IInnerAppJSONCheckOptions): void;
+export declare function checkPlugins(options: IInnerAppJSONCheckOptions): void;
+export declare function checkNavigateToMiniProgramAppIdList(options: IInnerAppJSONCheckOptions): void;
+export declare function checkFunctionalPages(options: IInnerAppJSONCheckOptions): void;
+export declare function checkPreloadRule(options: IInnerAppJSONCheckOptions, allPages: IPageInfo[]): void;
+export declare function checkEntryPagePath(options: IInnerAppJSONCheckOptions, allPages: IPageInfo[]): void;
+export declare function checkTabbarPage(options: IInnerAppJSONCheckOptions): void;
+export declare function checkMainPkgPageIsInSubpkg(options: IInnerAppJSONCheckOptions): void;
+export declare function checkMainPkgPluginIsInSubPkg(options: IInnerAppJSONCheckOptions): void;
+export declare function checkComponentPath(options: IInnerAppJSONCheckOptions): void;
+export declare function checkEntranceDeclare(options: IInnerAppJSONCheckOptions): void;
+interface IVariableDeclareProperty {
+    property: string;
+    value: string;
+}
+export declare function getAppJSONVariableDecalearProperty(appJSON: AppJSON.IAppJSON): IVariableDeclareProperty[];
+export declare function checkOpenDataContext(options: IInnerAppJSONCheckOptions, appJSON: AppJSON.IAppJSON): void;
+export declare function checkRenderer(options: IInnerAppJSONCheckOptions): void;
+export declare function checkResolveAlias(options: IInnerAppJSONCheckOptions): void;
+export declare function checkRequiredPrivateInfos(options: IInnerAppJSONCheckOptions): void;
+export declare function checkAccountCardPackage(options: IInnerAppJSONCheckOptions): void;
+export {};

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

@@ -0,0 +1,3 @@
+import { ReactiveProject } from '../reactiveCache';
+import { ExtJSON } from '../../../../../types';
+export declare const getExtJSON: (project: ReactiveProject) => ExtJSON.IExtJSON | undefined;

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

@@ -0,0 +1,4 @@
+import { ReactiveProject } from '../reactiveCache';
+import { AppJSON } from '../../../../../types';
+export declare const getAppJSON: (project: ReactiveProject) => AppJSON.IAppJSON;
+export { getExtJSON } from './extJSON';

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

@@ -0,0 +1,19 @@
+import { AppJSON, IGameJSON, MiniProgramCore, PageJSON } from '../../../../types';
+import { ReactiveProject } from './reactiveCache';
+export declare function checkJSONFormat(code: string, filePath: string): MiniProgramCore.IAnyObject;
+export declare function checkPagePathIsInSubPackage(appJSON: AppJSON.IAppJSON, pathName: string): undefined | AppJSON.ISubpackageItem;
+export declare function checkPagePathIsInIndependentSubpackage(appJSON: AppJSON.IAppJSON, pathName: string): undefined | AppJSON.ISubpackageItem;
+export declare function checkFilePathIsInIndependentSubpackage(appOrGameJSON: AppJSON.IAppJSON | IGameJSON, pathName: string): string | undefined;
+export declare const getUseExtendLib: (project: MiniProgramCore.IPreCompileProject, pagePath: string) => string[];
+export declare const checkComponentPath: (options: {
+    project: MiniProgramCore.IPreCompileProject | ReactiveProject;
+    root: string;
+    relativePath: string;
+    inputJSON: MiniProgramCore.IAnyObject;
+}) => void;
+interface IVariableDeclareProperty {
+    property: string;
+    value: string;
+}
+export declare function getPageJSONVariableDecalearProperty(pageJSON: PageJSON.IPageJSON): IVariableDeclareProperty[];
+export {};

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

@@ -0,0 +1,4 @@
+import { IGameJSON } from '../../../../types';
+import { ReactiveProject } from './reactiveCache';
+declare const getGameJSON: (project: ReactiveProject) => IGameJSON;
+export default getGameJSON;

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

@@ -0,0 +1,6 @@
+import { ReactiveProject } from '../reactiveCache';
+import { PageJSON } from '../../../../../types';
+export declare function checkPageJSON(project: ReactiveProject, options: {
+    pagePath: string;
+    miniprogramRoot: string;
+}): PageJSON.IPageJSON;

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

@@ -0,0 +1,14 @@
+import { ReactiveProject } from '../reactiveCache';
+import { MiniProgramCore, PageJSON } from '../../../../../types';
+export declare function originGetPageJSON(project: ReactiveProject, options: {
+    miniprogramRoot: string;
+    pagePath: string;
+}): PageJSON.IPageJSON;
+export declare function getPageJSON(project: MiniProgramCore.IPreCompileProject, options: {
+    miniprogramRoot: string;
+    pagePath: string;
+}): Promise<PageJSON.IPageJSON>;
+export declare function getPageJSONWithDisableSpreading(project: MiniProgramCore.IPreCompileProject, options: {
+    miniprogramRoot: string;
+    pagePath: string;
+}): PageJSON.IPageJSON;

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

@@ -0,0 +1,12 @@
+import { ReactiveProject } from '../reactiveCache';
+import { MiniProgramCore, PluginJSON } from '../../../../../types';
+interface ICheckOptions {
+    project: ReactiveProject;
+    filePath: string;
+    root: string;
+}
+export declare function checkComponentPath(options: ICheckOptions, inputJSON: PluginJSON.IPluginJSON): void;
+export declare function checkWorkers(options: ICheckOptions, inputJSON: PluginJSON.IPluginJSON): void;
+export declare const getDevPluginJSON: (project: ReactiveProject, localPath?: any) => PluginJSON.IPluginJSON;
+export declare const getGameLocalPluginJSON: (project: MiniProgramCore.IPreCompileProject, localPath: string) => Promise<{}>;
+export {};

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

@@ -0,0 +1,9 @@
+import { ReactiveProject } from '../reactiveCache';
+import { MiniProgramCore, PageJSON } from '../../../../../types';
+interface ICheckOptions {
+    project: MiniProgramCore.IPreCompileProject | ReactiveProject;
+    root: string;
+    filePath: string;
+}
+export declare function getPluginPageJSON(options: ICheckOptions): Promise<PageJSON.IPageJSON>;
+export {};

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

@@ -0,0 +1,2 @@
+import { MiniProgramCI, ProjectConfigJSON } from '../../../../types';
+export declare const getProjectConfigJSON: (project: MiniProgramCI.IProject) => ProjectConfigJSON.IProjectConfigJSON;

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

@@ -0,0 +1,24 @@
+import { CACHE_KEY } from '../../../../utils/cache';
+import { ReactiveProject } from '../../../../project/advance/reactiveProject';
+import { PageJSON, MiniProgramCore } from '../../../../types';
+export { ReactiveProject };
+export declare function tryToGetReactiveProject(project: MiniProgramCore.IPreCompileProject): ReactiveProject;
+export declare class ReactiveJSONCompiler {
+    static originGetPageJSON: any;
+    static originCheckPageJSON: any;
+    private pageComputeds;
+    private jsonComputeds;
+    private project;
+    constructor(project: ReactiveProject);
+    release(): void;
+    registerOrGet<A extends any[], T>(cacheKey: CACHE_KEY, compileFunc: (project: ReactiveProject, ...args: A) => T, ...args: A): T;
+    static setOriginGetPageJSON(originGetPageJSON: Function): void;
+    static setOriginCheckPageJSON(originCheckPageJSON: Function): void;
+    getPageJSON(type: 'checked' | 'compiled', options: {
+        miniprogramRoot: string;
+        pagePath: string;
+    }): PageJSON.IPageJSON;
+}
+export declare function tryToGetReactiveJSONCompiler(project: ReactiveProject): ReactiveJSONCompiler;
+export declare function wrapCompileJSONFunc<A extends any[], T>(cacheKey: CACHE_KEY, func: (project: ReactiveProject, ...args: A) => T): (project: ReactiveProject, ...args: A) => T;
+export declare function cleanReactiveCache(): void;