@dimina/compiler 1.0.12-beta.9 → 1.0.13

package/dist/env-COaZNCzL.js

@@ -0,0 +1,537 @@
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs";
+import os from "node:os";
+//#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 path.join(workPath, src);
+	if (pagePath.includes("/miniprogram_npm/")) {
+		const componentFullPath = workPath + pagePath.split("/").slice(0, -1).join("/");
+		return path.resolve(componentFullPath, src);
+	}
+	const relativePath = pagePath.split("/").filter((part) => part !== "").slice(0, -1).join("/");
+	return path.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 : path.resolve(workPath, relativePath, src);
+	if (assetsMap[absolutePath]) return assetsMap[absolutePath];
+	try {
+		const ext = `.${src.split(".").pop()}`;
+		const dirPath = absolutePath.split(path.sep).slice(0, -1).join("/");
+		const prefix = uuid();
+		const targetStatic = `${targetPath}/main/static`;
+		if (!fs.existsSync(targetStatic)) fs.mkdirSync(targetStatic, { recursive: true });
+		getFilesWithExtension(dirPath, ext).forEach((file) => {
+			fs.copyFileSync(path.resolve(dirPath, file), `${targetStatic}/${prefix}_${file}`);
+		});
+		const filename = src.split("/").pop();
+		assetsMap[absolutePath] = `${process.env.ASSETS_PATH_PREFIX ? "" : "/"}${appId}/main/static/${prefix}_${filename}`;
+	} catch (error) {
+		console.log(error);
+	}
+	return assetsMap[absolutePath] || src;
+}
+function getFilesWithExtension(directory, extension) {
+	return fs.readdirSync(directory).filter((file) => path.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) {
+		const lastIndex = pageFilePath.lastIndexOf("/");
+		const newPath = pageFilePath.slice(0, lastIndex);
+		return path.resolve(newPath, componentPath).replace(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 = pageFilePath.replace(this.workPath, "").replace(/^\//, "").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 = path.join(this.workPath, miniprogramNpmPath);
+		if (!fs.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 = path.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 fs.existsSync(`${componentPath}${ext}`);
+		})) {
+			if (!requiredFiles.some((ext) => {
+				return fs.existsSync(path.join(componentPath, `index${ext}`));
+			})) return false;
+			const indexJsonFile = path.join(componentPath, "index.json");
+			if (fs.existsSync(indexJsonFile)) try {
+				return JSON.parse(fs.readFileSync(indexJsonFile, "utf-8")).component === true;
+			} catch (e) {
+				return false;
+			}
+			return true;
+		}
+		const jsonFile = `${componentPath}.json`;
+		if (fs.existsSync(jsonFile)) try {
+			return JSON.parse(fs.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 = path.join(this.workPath, searchPath, packageName, "package.json");
+		if (!fs.existsSync(packageJsonPath)) {
+			this.packageCache.set(cacheKey, null);
+			return null;
+		}
+		try {
+			const packageInfo = JSON.parse(fs.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 (process.env.TARGET_PATH) pathInfo.targetPath = process.env.TARGET_PATH;
+	else {
+		const tempDir = process.env.GITHUB_WORKSPACE || os.tmpdir();
+		const targetDir = path.join(tempDir, `dimina-fe-dist-${Date.now()}`);
+		if (!fs.existsSync(targetDir)) fs.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 (fs.existsSync(defaultConfigPath)) try {
+		defaultConfig = parseContentByPath(defaultConfigPath);
+	} catch (e) {
+		console.warn("Failed to parse project.config.json:", e.message);
+	}
+	if (fs.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 fs.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 (fs.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 = path.resolve(getWorkPath(), `./${moduleId}.json`);
+		let cContent = null;
+		if (fs.existsSync(componentFilePath)) cContent = parseContentByPath(componentFilePath);
+		else {
+			const indexJsonPath = path.resolve(getWorkPath(), `./${moduleId}/index.json`);
+			if (fs.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 lastIndex = pageFilePath.lastIndexOf("/");
+		const newPath = pageFilePath.slice(0, lastIndex);
+		const workPath = getWorkPath();
+		return path.resolve(newPath, src).replace(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
+export { tagWhiteList as _, getContentByPath as a, getPages as c, resetStoreInfo as d, resolveAppAlias as f, hasCompileInfo as g, getAbsolutePath as h, getComponent as i, getTargetPath as l, collectAssets as m, getAppId as n, getNpmResolver as o, storeInfo as p, getAppName as r, getPageConfigInfo as s, getAppConfigInfo as t, getWorkPath as u, transformRpx as v, art_default as y };