@dimina/compiler 1.0.12 → 1.0.14-beta.0

package/dist/env-M-7lpbHL.cjs

@@ -0,0 +1,705 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+//#region src/common/path-utils.js
+var WINDOWS_FS_PATH_RE = /^(?:[a-zA-Z]:[\\/]|\\\\)/;
+function isWindowsFsPath(targetPath) {
+	return typeof targetPath === "string" && (WINDOWS_FS_PATH_RE.test(targetPath) || targetPath.includes("\\"));
+}
+function getFsPathApi(targetPath) {
+	return isWindowsFsPath(targetPath) ? node_path.default.win32 : node_path.default.posix;
+}
+function normalizeToPosixPath(targetPath) {
+	return targetPath.replace(/\\/g, "/");
+}
+function resolveMiniProgramPath(workPath, importerPath, sourcePath) {
+	const pathApi = getFsPathApi(importerPath || workPath);
+	return sourcePath.startsWith("/") ? pathApi.join(workPath, sourcePath) : pathApi.resolve(pathApi.dirname(importerPath), sourcePath);
+}
+function toMiniProgramModuleId(resolvedPath, workPath) {
+	const normalizedResolvedPath = normalizeToPosixPath(resolvedPath);
+	const normalizedWorkPath = normalizeToPosixPath(workPath);
+	let moduleId = normalizedResolvedPath.startsWith(normalizedWorkPath) ? normalizedResolvedPath.slice(normalizedWorkPath.length) : normalizedResolvedPath;
+	moduleId = moduleId.replace(/\/+/g, "/");
+	if (!moduleId.startsWith("/")) moduleId = `/${moduleId}`;
+	return moduleId;
+}
+function getRelativePosixPath(targetPath, rootPath) {
+	return normalizeToPosixPath(targetPath).replace(normalizeToPosixPath(rootPath), "").replace(/^\//, "");
+}
+//#endregion
+//#region src/common/art.js
+var artCode = `
+██████╗ ██╗███╗   ███╗██╗███╗   ██╗ █████╗
+██╔══██╗██║████╗ ████║██║████╗  ██║██╔══██╗
+██║  ██║██║██╔████╔██║██║██╔██╗ ██║███████║
+██║  ██║██║██║╚██╔╝██║██║██║╚██╗██║██╔══██║
+██████╔╝██║██║ ╚═╝ ██║██║██║ ╚████║██║  ██║
+╚═════╝ ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝
+`;
+function art_default() {
+	console.log(artCode);
+}
+//#endregion
+//#region src/common/utils.js
+function hasCompileInfo(modulePath, list, preList) {
+	const mergeList = Array.isArray(preList) ? [...preList, ...list] : list;
+	for (const element of mergeList) if (element.path === modulePath) return true;
+	return false;
+}
+function getAbsolutePath(workPath, pagePath, src) {
+	if (src.startsWith("/")) return node_path.default.join(workPath, src);
+	if (pagePath.includes("/miniprogram_npm/")) {
+		const componentFullPath = workPath + pagePath.split("/").slice(0, -1).join("/");
+		return node_path.default.resolve(componentFullPath, src);
+	}
+	const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
+	return node_path.default.resolve(workPath, relativePath, src);
+}
+var assetsMap = {};
+/**
+* 将静态资源存储到 static 文件夹
+*/
+function collectAssets(workPath, pagePath, src, targetPath, appId) {
+	if (src.startsWith("http") || src.startsWith("//")) return src;
+	if (!/\.(?:png|jpe?g|gif|svg)(?:\?.*)?$/.test(src)) return src;
+	const relativePath = pagePath.split("/").slice(0, -1).join("/");
+	const absolutePath = src.startsWith("/") ? workPath + src : node_path.default.resolve(workPath, relativePath, src);
+	if (assetsMap[absolutePath]) return assetsMap[absolutePath];
+	try {
+		const ext = `.${src.split(".").pop()}`;
+		const dirPath = absolutePath.split(node_path.default.sep).slice(0, -1).join("/");
+		const prefix = uuid();
+		const targetStatic = `${targetPath}/main/static`;
+		if (!node_fs.default.existsSync(targetStatic)) node_fs.default.mkdirSync(targetStatic, { recursive: true });
+		getFilesWithExtension(dirPath, ext).forEach((file) => {
+			node_fs.default.copyFileSync(node_path.default.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+		});
+		const filename = src.split("/").pop();
+		assetsMap[absolutePath] = `${node_process.default.env.ASSETS_PATH_PREFIX ? "" : "/"}${appId}/main/static/${prefix}_${filename}`;
+	} catch (error) {
+		console.log(error);
+	}
+	return assetsMap[absolutePath] || src;
+}
+function getFilesWithExtension(directory, extension) {
+	return node_fs.default.readdirSync(directory).filter((file) => node_path.default.extname(file) === extension);
+}
+function isObjectEmpty(objectName) {
+	if (!objectName) return true;
+	return Object.keys(objectName).length === 0 && objectName.constructor === Object;
+}
+function isString(o) {
+	return Object.prototype.toString.call(o) === "[object String]";
+}
+function transformRpx(styleText) {
+	if (!isString(styleText)) return styleText;
+	return styleText.replace(/([+-]?\d+(?:\.\d+)?)rpx/g, (_, pixel) => {
+		return `${Number(pixel)}rem`;
+	});
+}
+function uuid() {
+	return Math.random().toString(36).slice(2, 7);
+}
+var tagWhiteList = [
+	"page",
+	"wrapper",
+	"block",
+	"button",
+	"camera",
+	"checkbox-group",
+	"checkbox",
+	"cover-image",
+	"cover-view",
+	"form",
+	"icon",
+	"image",
+	"input",
+	"keyboard-accessory",
+	"label",
+	"map",
+	"movable-area",
+	"movable-view",
+	"navigation-bar",
+	"navigator",
+	"open-data",
+	"page-meta",
+	"picker-view-column",
+	"picker-view",
+	"picker",
+	"progress",
+	"radio-group",
+	"radio",
+	"rich-text",
+	"root-portal",
+	"scroll-view",
+	"slider",
+	"swiper-item",
+	"swiper",
+	"switch",
+	"template",
+	"text",
+	"textarea",
+	"video",
+	"view",
+	"web-view"
+];
+//#endregion
+//#region src/common/npm-resolver.js
+/**
+* npm 组件解析器
+* 根据微信小程序 npm 支持规范实现组件寻址
+* https://developers.weixin.qq.com/miniprogram/dev/devtools/npm.html
+*/
+var NpmResolver = class {
+	constructor(workPath) {
+		this.workPath = workPath;
+		this.miniprogramNpmCache = /* @__PURE__ */ new Map();
+		this.packageCache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* 解析组件路径，支持 npm 包组件
+	* @param {string} componentPath 组件路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string} 解析后的组件路径
+	*/
+	resolveComponentPath(componentPath, pageFilePath) {
+		if (componentPath.startsWith("./") || componentPath.startsWith("../") || componentPath.startsWith("/")) return this.resolveRelativePath(componentPath, pageFilePath);
+		const npmPath = this.resolveNpmComponent(componentPath, pageFilePath);
+		if (npmPath) return npmPath;
+		return this.resolveRelativePath(componentPath, pageFilePath);
+	}
+	/**
+	* 解析相对路径组件
+	* @param {string} componentPath 组件路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string} 解析后的路径
+	*/
+	resolveRelativePath(componentPath, pageFilePath) {
+		return toMiniProgramModuleId(resolveMiniProgramPath(this.workPath, pageFilePath, componentPath), this.workPath);
+	}
+	/**
+	* 解析 npm 组件
+	* @param {string} componentName 组件名称
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string|null} 解析后的组件路径，如果找不到返回 null
+	*/
+	resolveNpmComponent(componentName, pageFilePath) {
+		const searchPaths = this.generateSearchPaths(pageFilePath);
+		for (const searchPath of searchPaths) {
+			const componentPath = this.findComponentInMiniprogramNpm(componentName, searchPath);
+			if (componentPath) return componentPath;
+		}
+		return null;
+	}
+	/**
+	* 解析脚本模块路径，支持微信小程序 npm 逐级寻址和 package.json 入口
+	* @param {string} specifier 模块导入路径
+	* @param {string} modulePath 当前模块绝对文件路径
+	* @param {(moduleId: string) => string | null} resolveExistingModuleId 解析真实存在模块的回调
+	* @returns {string|null} 解析后的模块 id
+	*/
+	resolveScriptModule(specifier, modulePath, resolveExistingModuleId) {
+		if (!specifier || !resolveExistingModuleId) return null;
+		for (const searchPath of this.generateSearchPaths(modulePath)) {
+			const resolvedModuleId = resolveExistingModuleId(this.normalizeModuleId(`/${searchPath}/${specifier}`));
+			if (resolvedModuleId) return resolvedModuleId;
+		}
+		return null;
+	}
+	/**
+	* 生成 miniprogram_npm 搜索路径
+	* 按照微信小程序的寻址顺序生成搜索路径
+	* @param {string} pageFilePath 页面文件路径
+	* @returns {string[]} 搜索路径数组
+	*/
+	generateSearchPaths(pageFilePath) {
+		const pathParts = getRelativePosixPath(pageFilePath, this.workPath).split("/").slice(0, -1);
+		const searchPaths = [];
+		for (let i = pathParts.length; i >= 0; i--) {
+			const currentPath = pathParts.slice(0, i).join("/");
+			const miniprogramNpmPath = currentPath ? `${currentPath}/miniprogram_npm` : "miniprogram_npm";
+			searchPaths.push(miniprogramNpmPath);
+		}
+		return searchPaths;
+	}
+	/**
+	* 在指定的 miniprogram_npm 目录中查找组件
+	* @param {string} componentName 组件名称
+	* @param {string} miniprogramNpmPath miniprogram_npm 路径
+	* @returns {string|null} 组件路径，如果找不到返回 null
+	*/
+	findComponentInMiniprogramNpm(componentName, miniprogramNpmPath) {
+		const fullMiniprogramNpmPath = node_path.default.join(this.workPath, miniprogramNpmPath);
+		if (!node_fs.default.existsSync(fullMiniprogramNpmPath)) return null;
+		const cacheKey = `${miniprogramNpmPath}/${componentName}`;
+		if (this.miniprogramNpmCache.has(cacheKey)) return this.miniprogramNpmCache.get(cacheKey);
+		const candidatePaths = [componentName, `${componentName}/index`];
+		for (const candidatePath of candidatePaths) {
+			const componentDir = node_path.default.join(fullMiniprogramNpmPath, candidatePath);
+			if (this.isValidComponent(componentDir)) {
+				const resolvedPath = `/${miniprogramNpmPath}/${candidatePath}`.replace(/\/+/g, "/");
+				this.miniprogramNpmCache.set(cacheKey, resolvedPath);
+				return resolvedPath;
+			}
+		}
+		this.miniprogramNpmCache.set(cacheKey, null);
+		return null;
+	}
+	normalizeModuleId(moduleId) {
+		let normalized = moduleId.replace(/\.(js|ts)$/, "").replace(/\\/g, "/");
+		if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+		return normalized;
+	}
+	/**
+	* 检查是否为有效的组件
+	* @param {string} componentPath 组件路径
+	* @returns {boolean} 是否为有效组件
+	*/
+	isValidComponent(componentPath) {
+		const requiredFiles = [".json", ".js"];
+		if (!requiredFiles.some((ext) => {
+			return node_fs.default.existsSync(`${componentPath}${ext}`);
+		})) {
+			if (!requiredFiles.some((ext) => {
+				return node_fs.default.existsSync(node_path.default.join(componentPath, `index${ext}`));
+			})) return false;
+			const indexJsonFile = node_path.default.join(componentPath, "index.json");
+			if (node_fs.default.existsSync(indexJsonFile)) try {
+				return JSON.parse(node_fs.default.readFileSync(indexJsonFile, "utf-8")).component === true;
+			} catch (e) {
+				return false;
+			}
+			return true;
+		}
+		const jsonFile = `${componentPath}.json`;
+		if (node_fs.default.existsSync(jsonFile)) try {
+			return JSON.parse(node_fs.default.readFileSync(jsonFile, "utf-8")).component === true;
+		} catch (e) {
+			return false;
+		}
+		return true;
+	}
+	/**
+	* 获取 npm 包信息
+	* @param {string} packageName 包名
+	* @param {string} searchPath 搜索路径
+	* @returns {object|null} 包信息，如果找不到返回 null
+	*/
+	getPackageInfo(packageName, searchPath) {
+		const cacheKey = `${searchPath}/${packageName}`;
+		if (this.packageCache.has(cacheKey)) return this.packageCache.get(cacheKey);
+		const packageJsonPath = node_path.default.join(this.workPath, searchPath, packageName, "package.json");
+		if (!node_fs.default.existsSync(packageJsonPath)) {
+			this.packageCache.set(cacheKey, null);
+			return null;
+		}
+		try {
+			const packageInfo = JSON.parse(node_fs.default.readFileSync(packageJsonPath, "utf-8"));
+			this.packageCache.set(cacheKey, packageInfo);
+			return packageInfo;
+		} catch (e) {
+			this.packageCache.set(cacheKey, null);
+			return null;
+		}
+	}
+	/**
+	* 清除缓存
+	*/
+	clearCache() {
+		this.miniprogramNpmCache.clear();
+		this.packageCache.clear();
+	}
+};
+//#endregion
+//#region src/env.js
+var pathInfo = {};
+var configInfo = {};
+var npmResolver = null;
+/**
+* 持久化编译过程的上下文
+*/
+function storeInfo(workPath) {
+	storePathInfo(workPath);
+	storeProjectConfig();
+	storeAppConfig();
+	storePageConfig();
+	return {
+		pathInfo,
+		configInfo
+	};
+}
+function resetStoreInfo(opts) {
+	pathInfo = opts.pathInfo;
+	configInfo = opts.configInfo;
+	if (pathInfo.workPath) npmResolver = new NpmResolver(pathInfo.workPath);
+}
+function storePathInfo(workPath) {
+	pathInfo.workPath = workPath;
+	if (node_process.default.env.TARGET_PATH) pathInfo.targetPath = node_process.default.env.TARGET_PATH;
+	else {
+		const tempDir = node_process.default.env.GITHUB_WORKSPACE || node_os.default.tmpdir();
+		const targetDir = node_path.default.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+		if (!node_fs.default.existsSync(targetDir)) node_fs.default.mkdirSync(targetDir, { recursive: true });
+		pathInfo.targetPath = targetDir;
+	}
+	npmResolver = new NpmResolver(workPath);
+}
+function storeProjectConfig() {
+	const privateConfigPath = `${pathInfo.workPath}/project.private.config.json`;
+	const defaultConfigPath = `${pathInfo.workPath}/project.config.json`;
+	let privateConfig = {};
+	let defaultConfig = {};
+	if (node_fs.default.existsSync(defaultConfigPath)) try {
+		defaultConfig = parseContentByPath(defaultConfigPath);
+	} catch (e) {
+		console.warn("Failed to parse project.config.json:", e.message);
+	}
+	if (node_fs.default.existsSync(privateConfigPath)) try {
+		privateConfig = parseContentByPath(privateConfigPath);
+	} catch (e) {
+		console.warn("Failed to parse project.private.config.json:", e.message);
+	}
+	configInfo.projectInfo = {
+		...defaultConfig,
+		...privateConfig
+	};
+}
+function storeAppConfig() {
+	const content = parseContentByPath(`${pathInfo.workPath}/app.json`);
+	const newObj = {};
+	for (const key in content) if (Object.hasOwn(content, key)) if (key === "subpackages") newObj.subPackages = content[key];
+	else newObj[key] = content[key];
+	configInfo.appInfo = newObj;
+}
+function getContentByPath(path) {
+	return node_fs.default.readFileSync(path, { encoding: "utf-8" });
+}
+function parseContentByPath(path) {
+	return JSON.parse(getContentByPath(path));
+}
+/**
+* 收集页面 json 信息
+*/
+function storePageConfig() {
+	const { pages, subPackages } = configInfo.appInfo;
+	configInfo.pageInfo = {};
+	configInfo.componentInfo = {};
+	if (configInfo.appInfo.usingComponents) {
+		const appFilePath = `${pathInfo.workPath}/app.json`;
+		storeComponentConfig(configInfo.appInfo, appFilePath);
+	}
+	collectionPageJson(pages);
+	if (subPackages) subPackages.forEach((subPkg) => {
+		collectionPageJson(subPkg.pages, subPkg.root);
+	});
+}
+/**
+* 匹配页面和对应的配置信息
+* @param {*} pages
+*/
+function collectionPageJson(pages, root) {
+	pages.forEach((pagePath) => {
+		let np = pagePath;
+		if (root) {
+			if (!root.endsWith("/")) root += "/";
+			np = root + np;
+		}
+		const pageFilePath = `${pathInfo.workPath}/${np}.json`;
+		if (node_fs.default.existsSync(pageFilePath)) {
+			const pageJsonContent = parseContentByPath(pageFilePath);
+			if (root) pageJsonContent.root = transSubDir(root);
+			configInfo.pageInfo[np] = pageJsonContent;
+			storeComponentConfig(pageJsonContent, pageFilePath);
+		}
+	});
+}
+/**
+* 按页面收集组件 json 信息
+* @param {*} pageJsonContent
+* @param {*} pageFilePath
+*/
+function storeComponentConfig(pageJsonContent, pageFilePath) {
+	if (isObjectEmpty(pageJsonContent.usingComponents)) return;
+	for (const [componentName, componentPath] of Object.entries(pageJsonContent.usingComponents)) {
+		const moduleId = getModuleId(componentPath, pageFilePath);
+		pageJsonContent.usingComponents[componentName] = moduleId;
+		if (configInfo.componentInfo[moduleId]) continue;
+		let componentFilePath = node_path.default.resolve(getWorkPath(), `./${moduleId}.json`);
+		let cContent = null;
+		if (node_fs.default.existsSync(componentFilePath)) cContent = parseContentByPath(componentFilePath);
+		else {
+			const indexJsonPath = node_path.default.resolve(getWorkPath(), `./${moduleId}/index.json`);
+			if (node_fs.default.existsSync(indexJsonPath)) {
+				componentFilePath = indexJsonPath;
+				cContent = parseContentByPath(componentFilePath);
+			} else if (moduleId.includes("/miniprogram_npm/")) {
+				console.log(`[env] 为 npm 组件创建默认配置: ${moduleId}`);
+				cContent = {
+					component: true,
+					usingComponents: {}
+				};
+			} else {
+				console.warn(`[env] 组件配置文件不存在: ${componentFilePath}`);
+				continue;
+			}
+		}
+		const cUsing = cContent.usingComponents || {};
+		const isComponent = cContent.component || false;
+		const cComponents = Object.keys(cUsing).reduce((acc, key) => {
+			acc[key] = getModuleId(cUsing[key], componentFilePath);
+			return acc;
+		}, {});
+		configInfo.componentInfo[moduleId] = {
+			id: uuid(),
+			path: moduleId,
+			component: isComponent,
+			usingComponents: cComponents
+		};
+		if (cContent.usingComponents && Object.keys(cContent.usingComponents).length > 0) storeComponentConfig(configInfo.componentInfo[moduleId], componentFilePath);
+	}
+}
+/**
+* 转化为相对小程序根目录的绝对路径，作为模块唯一性 id
+* 支持 npm 组件解析
+* @param {string} src
+*/
+function getModuleId(src, pageFilePath) {
+	const resolvedAlias = resolveAppAlias(src);
+	if (resolvedAlias) return resolvedAlias;
+	if (!npmResolver) {
+		const workPath = getWorkPath();
+		return toMiniProgramModuleId(resolveMiniProgramPath(workPath, pageFilePath, src), workPath);
+	}
+	return npmResolver.resolveComponentPath(src, pageFilePath);
+}
+function resolveAppAlias(src) {
+	const resolveAlias = configInfo.appInfo?.resolveAlias;
+	if (!resolveAlias || typeof src !== "string") return null;
+	for (const [alias, target] of Object.entries(resolveAlias)) if (alias.endsWith("/*") && target.endsWith("/*")) {
+		const aliasPrefix = alias.slice(0, -1);
+		const targetPrefix = target.slice(0, -1);
+		if (src.startsWith(aliasPrefix)) return src.replace(aliasPrefix, targetPrefix);
+	} else if (src === alias) return target;
+	return null;
+}
+function getTargetPath() {
+	return pathInfo.targetPath;
+}
+function getComponent(src) {
+	return configInfo.componentInfo[src];
+}
+function getPageConfigInfo() {
+	return configInfo.pageInfo;
+}
+function getAppConfigInfo() {
+	return configInfo.appInfo;
+}
+function getWorkPath() {
+	return pathInfo.workPath;
+}
+function getNpmResolver() {
+	return npmResolver;
+}
+function getAppId() {
+	return configInfo.projectInfo.appid;
+}
+function getAppName() {
+	if (configInfo.projectInfo.projectname) return decodeURIComponent(configInfo.projectInfo.projectname);
+	return getAppId();
+}
+function transSubDir(name) {
+	return `sub_${name.replace(/\/$/, "")}`;
+}
+/**
+* 获取页面及其配置信息，并生成id（输出的 json 文件没有 id)
+*/
+function getPages() {
+	const { pages, subPackages = [], usingComponents: globalComponents = {} } = getAppConfigInfo();
+	const pageInfo = getPageConfigInfo();
+	const mainPages = pages.map((path) => {
+		const pageComponents = pageInfo[path]?.usingComponents || {};
+		const mergedComponents = {
+			...globalComponents,
+			...pageComponents
+		};
+		return {
+			id: uuid(),
+			path,
+			usingComponents: mergedComponents
+		};
+	});
+	const subPages = {};
+	subPackages.forEach((subPkg) => {
+		const rootPath = subPkg.root.endsWith("/") ? subPkg.root : `${subPkg.root}/`;
+		const independent = subPkg.independent ? subPkg.independent : false;
+		subPages[transSubDir(rootPath)] = {
+			independent,
+			info: subPkg.pages.map((path) => {
+				const fullPath = rootPath + path;
+				const pageComponents = pageInfo[fullPath]?.usingComponents || {};
+				const mergedComponents = {
+					...globalComponents,
+					...pageComponents
+				};
+				return {
+					id: uuid(),
+					path: fullPath,
+					usingComponents: mergedComponents
+				};
+			})
+		};
+	});
+	return {
+		mainPages,
+		subPages
+	};
+}
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "art_default", {
+	enumerable: true,
+	get: function() {
+		return art_default;
+	}
+});
+Object.defineProperty(exports, "collectAssets", {
+	enumerable: true,
+	get: function() {
+		return collectAssets;
+	}
+});
+Object.defineProperty(exports, "getAbsolutePath", {
+	enumerable: true,
+	get: function() {
+		return getAbsolutePath;
+	}
+});
+Object.defineProperty(exports, "getAppConfigInfo", {
+	enumerable: true,
+	get: function() {
+		return getAppConfigInfo;
+	}
+});
+Object.defineProperty(exports, "getAppId", {
+	enumerable: true,
+	get: function() {
+		return getAppId;
+	}
+});
+Object.defineProperty(exports, "getAppName", {
+	enumerable: true,
+	get: function() {
+		return getAppName;
+	}
+});
+Object.defineProperty(exports, "getComponent", {
+	enumerable: true,
+	get: function() {
+		return getComponent;
+	}
+});
+Object.defineProperty(exports, "getContentByPath", {
+	enumerable: true,
+	get: function() {
+		return getContentByPath;
+	}
+});
+Object.defineProperty(exports, "getNpmResolver", {
+	enumerable: true,
+	get: function() {
+		return getNpmResolver;
+	}
+});
+Object.defineProperty(exports, "getPageConfigInfo", {
+	enumerable: true,
+	get: function() {
+		return getPageConfigInfo;
+	}
+});
+Object.defineProperty(exports, "getPages", {
+	enumerable: true,
+	get: function() {
+		return getPages;
+	}
+});
+Object.defineProperty(exports, "getTargetPath", {
+	enumerable: true,
+	get: function() {
+		return getTargetPath;
+	}
+});
+Object.defineProperty(exports, "getWorkPath", {
+	enumerable: true,
+	get: function() {
+		return getWorkPath;
+	}
+});
+Object.defineProperty(exports, "hasCompileInfo", {
+	enumerable: true,
+	get: function() {
+		return hasCompileInfo;
+	}
+});
+Object.defineProperty(exports, "resetStoreInfo", {
+	enumerable: true,
+	get: function() {
+		return resetStoreInfo;
+	}
+});
+Object.defineProperty(exports, "resolveAppAlias", {
+	enumerable: true,
+	get: function() {
+		return resolveAppAlias;
+	}
+});
+Object.defineProperty(exports, "storeInfo", {
+	enumerable: true,
+	get: function() {
+		return storeInfo;
+	}
+});
+Object.defineProperty(exports, "tagWhiteList", {
+	enumerable: true,
+	get: function() {
+		return tagWhiteList;
+	}
+});
+Object.defineProperty(exports, "transformRpx", {
+	enumerable: true,
+	get: function() {
+		return transformRpx;
+	}
+});