weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.7

package/dist/cache-nq0_XJoS.mjs

@@ -0,0 +1,429 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { logger } from "@weapp-tailwindcss/logger";
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import { TailwindcssPatcher } from "tailwindcss-patch";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/context/workspace.ts
+const IGNORED_WORKSPACE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	".turbo",
+	".output",
+	".next",
+	"dist",
+	"build"
+]);
+function findWorkspaceRoot(startDir) {
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "package.json"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [path.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = path.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = path.join(normalized, "package.json");
+			if (existsSync(pkgPath)) {
+				if (JSON.parse(readFileSync(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = readdirSync(normalized, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_WORKSPACE_DIRS.has(entry.name) || entry.isSymbolicLink?.()) continue;
+			queue.push(path.join(normalized, entry.name));
+		}
+	}
+}
+//#endregion
+//#region src/tailwindcss/patcher-options.ts
+function resolveTailwindcssOptions(options) {
+	return options?.tailwindcss ?? options?.tailwind;
+}
+function normalizeExtendLengthUnits(value) {
+	if (value === false) return false;
+	if (value === true) return { enabled: true };
+	if (value && typeof value === "object") return {
+		enabled: true,
+		...value
+	};
+}
+function normalizeTailwindcssPatcherOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/tailwindcss/patcher-resolve.ts
+const GENERIC_RELATIVE_SPECIFIERS = [".", ".."];
+const DEFAULT_TAILWIND_CONFIG_SPECIFIERS = ["stubs/config.full.js", "defaultConfig.js"];
+const TAILWIND_CONFIG_FILES = [
+	"tailwind.config.js",
+	"tailwind.config.cjs",
+	"tailwind.config.mjs",
+	"tailwind.config.ts",
+	"tailwind.config.cts",
+	"tailwind.config.mts"
+];
+function isPathSpecifier(specifier) {
+	if (!specifier) return false;
+	if (specifier.startsWith("file://")) return true;
+	if (path.isAbsolute(specifier)) return true;
+	return GENERIC_RELATIVE_SPECIFIERS.some((prefix) => specifier.startsWith(`${prefix}/`) || specifier.startsWith(`${prefix}\\`));
+}
+function resolveModuleFromPaths(specifier, paths) {
+	if (!specifier || isPathSpecifier(specifier) || paths.length === 0) return;
+	try {
+		return createRequire(import.meta.url).resolve(specifier, { paths });
+	} catch {
+		return;
+	}
+}
+function resolveTailwindConfigFallback(packageName, paths) {
+	if (!packageName) return;
+	for (const suffix of DEFAULT_TAILWIND_CONFIG_SPECIFIERS) {
+		const resolved = resolveModuleFromPaths(`${packageName}/${suffix}`, paths);
+		if (resolved) return resolved;
+	}
+}
+function appendNodeModules(paths, dir) {
+	if (!dir) return;
+	const nodeModulesDir = path.join(dir, "node_modules");
+	if (existsSync(nodeModulesDir)) paths.add(nodeModulesDir);
+}
+function findTailwindConfig(searchRoots) {
+	for (const root of searchRoots) for (const file of TAILWIND_CONFIG_FILES) {
+		const candidate = path.resolve(root, file);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+function createDefaultResolvePaths(basedir) {
+	const paths = /* @__PURE__ */ new Set();
+	let fallbackCandidates = [];
+	if (basedir) {
+		const resolvedBase = path.resolve(basedir);
+		appendNodeModules(paths, resolvedBase);
+		fallbackCandidates.push(resolvedBase);
+		const packageRoot = findNearestPackageRoot(resolvedBase);
+		if (packageRoot) {
+			appendNodeModules(paths, packageRoot);
+			fallbackCandidates.push(packageRoot);
+		}
+	}
+	const cwd = process.cwd();
+	appendNodeModules(paths, cwd);
+	try {
+		const modulePath = fileURLToPath(import.meta.url);
+		const candidate = existsSync(modulePath) && !path.extname(modulePath) ? modulePath : path.dirname(modulePath);
+		paths.add(candidate);
+	} catch {
+		paths.add(import.meta.url);
+	}
+	if (paths.size === 0) {
+		fallbackCandidates = fallbackCandidates.filter(Boolean);
+		if (fallbackCandidates.length === 0) fallbackCandidates.push(cwd);
+		for (const candidate of fallbackCandidates) paths.add(candidate);
+	}
+	return [...paths];
+}
+//#endregion
+//#region src/tailwindcss/version.ts
+function normalizeSupportedTailwindcssMajorVersion(version) {
+	return version === 3 || version === 4 ? version : void 0;
+}
+function readPackageJson(packageJsonPath) {
+	try {
+		return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageJsonDeclaringPackage(packageName, base) {
+	let current = path.resolve(base);
+	while (true) {
+		const pkgPath = path.join(current, "package.json");
+		if (existsSync(pkgPath)) {
+			const pkg = readPackageJson(pkgPath);
+			if (readDeclaredPackageVersion(packageName, pkg)) return pkgPath;
+			if (pkg?.name !== "weapp-tailwindcss") return;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function readDeclaredPackageVersion(packageName, pkg) {
+	return pkg?.dependencies?.[packageName] ?? pkg?.devDependencies?.[packageName] ?? pkg?.peerDependencies?.[packageName] ?? pkg?.optionalDependencies?.[packageName];
+}
+function readDeclaredPackageMajorVersion(version) {
+	const match = version?.match(/(?:^|\D)([34])(?:\.|\b)/);
+	return normalizeSupportedTailwindcssMajorVersion(match ? Number(match[1]) : void 0);
+}
+function readInstalledPackageMajorVersion(packageName, base) {
+	const packageJsonPath = findPackageJsonDeclaringPackage(packageName, base);
+	if (!packageJsonPath) return;
+	const declaredVersion = readDeclaredPackageVersion(packageName, readPackageJson(packageJsonPath));
+	if (!declaredVersion) return;
+	try {
+		const pkg = createRequire(packageJsonPath)(`${packageName}/package.json`);
+		return normalizeSupportedTailwindcssMajorVersion(Number(pkg.version?.split(".")[0]));
+	} catch {
+		return readDeclaredPackageMajorVersion(declaredVersion);
+	}
+}
+//#endregion
+//#region src/tailwindcss/patcher.ts
+function createFallbackTailwindcssPatcher() {
+	return {
+		packageInfo: {
+			name: "tailwindcss",
+			version: void 0,
+			rootPath: "",
+			packageJsonPath: "",
+			packageJson: {}
+		},
+		majorVersion: 4,
+		async getClassSet() {
+			return /* @__PURE__ */ new Set();
+		},
+		async extract(_options) {
+			return {
+				classList: [],
+				classSet: /* @__PURE__ */ new Set()
+			};
+		},
+		async collectContentTokens() {
+			return {
+				entries: [],
+				filesScanned: 0,
+				sources: [],
+				skippedFiles: []
+			};
+		}
+	};
+}
+let hasLoggedMissingTailwind = false;
+const TAILWINDCSS_NOT_FOUND_RE = /tailwindcss not found/i;
+const UNABLE_TO_LOCATE_TAILWINDCSS_RE = /unable to locate tailwind css package/i;
+function isTailwindcssV4PackageName(packageName) {
+	return packageName === "@tailwindcss/postcss" || packageName === "tailwindcss4" || Boolean(packageName && packageName.includes("tailwindcss4"));
+}
+function createTailwindcssPatcher(options) {
+	const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+	const cache = { driver: "memory" };
+	const normalizedBasedir = basedir ? path.resolve(basedir) : void 0;
+	const cacheRoot = findNearestPackageRoot(normalizedBasedir) ?? normalizedBasedir ?? process.cwd();
+	if (cacheDir) if (path.isAbsolute(cacheDir)) cache.dir = cacheDir;
+	else if (normalizedBasedir) cache.dir = path.resolve(normalizedBasedir, cacheDir);
+	else cache.dir = path.resolve(process.cwd(), cacheDir);
+	else cache.dir = path.join(cacheRoot, "node_modules", ".cache", "tailwindcss-patch");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? process.cwd());
+	const normalizedUserOptions = normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
+	const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnitsPatch ?? true);
+	const baseTailwindOptions = defuOverrideArray(tailwindcss ?? {}, {
+		cwd: normalizedBasedir,
+		resolve: { paths: resolvePaths }
+	});
+	if (!baseTailwindOptions.packageName) baseTailwindOptions.packageName = "tailwindcss";
+	if (!baseTailwindOptions.postcssPlugin) baseTailwindOptions.postcssPlugin = baseTailwindOptions.version === 4 || isTailwindcssV4PackageName(baseTailwindOptions.packageName) ? "@tailwindcss/postcss" : "tailwindcss";
+	if (typeof baseTailwindOptions.postcssPlugin === "string") {
+		const resolvedPlugin = resolveModuleFromPaths(baseTailwindOptions.postcssPlugin, resolvePaths);
+		if (resolvedPlugin) baseTailwindOptions.postcssPlugin = resolvedPlugin;
+	}
+	const resolvedOptions = defuOverrideArray(normalizedUserOptions ?? {}, {
+		projectRoot: normalizedBasedir,
+		cache,
+		tailwindcss: baseTailwindOptions,
+		apply: {
+			exposeContext: true,
+			extendLengthUnits
+		}
+	});
+	const resolvedTailwindOptions = resolvedOptions.tailwindcss;
+	if (resolvedTailwindOptions) {
+		const existingResolve = resolvedTailwindOptions.resolve ?? {};
+		const sourcePaths = Array.isArray(existingResolve.paths) && existingResolve.paths.length > 0 ? existingResolve.paths : resolvePaths;
+		resolvedTailwindOptions.resolve = {
+			...existingResolve,
+			paths: [...new Set(sourcePaths)]
+		};
+		logger.debug("Tailwind resolve config %O", {
+			packageName: resolvedTailwindOptions.packageName,
+			version: resolvedTailwindOptions.version,
+			resolve: resolvedTailwindOptions.resolve,
+			cwd: resolvedTailwindOptions.cwd
+		});
+		if (typeof resolvedTailwindOptions.postcssPlugin === "string") {
+			const resolvedPlugin = resolveModuleFromPaths(resolvedTailwindOptions.postcssPlugin, resolvedTailwindOptions.resolve?.paths ?? resolvePaths);
+			if (resolvedPlugin) resolvedTailwindOptions.postcssPlugin = resolvedPlugin;
+		}
+		const searchRoots = /* @__PURE__ */ new Set();
+		if (resolvedTailwindOptions.cwd) searchRoots.add(resolvedTailwindOptions.cwd);
+		for (const resolvePath of resolvedTailwindOptions.resolve?.paths ?? []) {
+			const parentDir = path.dirname(resolvePath);
+			searchRoots.add(parentDir);
+		}
+		const configPath = findTailwindConfig(searchRoots);
+		if (!resolvedTailwindOptions.config) if (configPath) resolvedTailwindOptions.config = configPath;
+		else {
+			const fallbackConfig = resolveTailwindConfigFallback(resolvedTailwindOptions.packageName, resolvedTailwindOptions.resolve.paths ?? resolvePaths);
+			if (fallbackConfig) resolvedTailwindOptions.config = fallbackConfig;
+		}
+		if (!resolvedTailwindOptions.cwd && configPath) resolvedTailwindOptions.cwd = path.dirname(configPath);
+		resolvedOptions.tailwindcss = resolvedTailwindOptions;
+	}
+	try {
+		return new TailwindcssPatcher(resolvedOptions);
+	} catch (error) {
+		const searchPaths = resolvedOptions.tailwindcss?.resolve?.paths;
+		if (error instanceof Error && TAILWINDCSS_NOT_FOUND_RE.test(error.message)) {
+			if (!hasLoggedMissingTailwind) {
+				logger.warn("Tailwind CSS 未安装，已跳过 Tailwind 运行时能力。若需使用 Tailwind 能力，请安装 tailwindcss。");
+				hasLoggedMissingTailwind = true;
+			}
+			return createFallbackTailwindcssPatcher();
+		}
+		if (error instanceof Error && UNABLE_TO_LOCATE_TAILWINDCSS_RE.test(error.message)) logger.error("无法定位 Tailwind CSS 包 \"%s\"，已尝试路径: %O", resolvedOptions.tailwindcss?.packageName, searchPaths);
+		throw error;
+	}
+}
+//#endregion
+//#region src/tailwindcss/runtime/cache.ts
+const runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+const runtimeFileSignatureCache = /* @__PURE__ */ new Map();
+let runtimeFileSignatureCacheClearTimer;
+const runtimeSignaturePatchersSymbol = Symbol.for("weapp-tailwindcss.runtimeSignaturePatchers");
+function getCacheEntry(twPatcher) {
+	let entry = runtimeClassSetCache.get(twPatcher);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetCache.set(twPatcher, entry);
+	}
+	return entry;
+}
+function scheduleRuntimeConfigSignatureCacheClear() {
+	if (runtimeFileSignatureCacheClearTimer) return;
+	runtimeFileSignatureCacheClearTimer = setTimeout(() => {
+		runtimeFileSignatureCache.clear();
+		runtimeFileSignatureCacheClearTimer = void 0;
+	}, 0);
+	runtimeFileSignatureCacheClearTimer.unref?.();
+}
+function getFileSignature(filePath) {
+	const cached = runtimeFileSignatureCache.get(filePath);
+	if (cached !== void 0) return cached;
+	let signature;
+	try {
+		const stats = statSync(filePath);
+		signature = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+	} catch {
+		signature = `${filePath}:missing`;
+	}
+	runtimeFileSignatureCache.set(filePath, signature);
+	scheduleRuntimeConfigSignatureCacheClear();
+	return signature;
+}
+function getTailwindTrackedFiles(twPatcher) {
+	const tailwindOptions = resolveTailwindcssOptions(twPatcher.options);
+	const tracked = /* @__PURE__ */ new Set();
+	const configPath = tailwindOptions?.config;
+	if (typeof configPath === "string" && configPath.length > 0) tracked.add(configPath);
+	for (const entry of tailwindOptions?.v4?.cssEntries ?? []) if (typeof entry === "string" && entry.length > 0) tracked.add(entry);
+	return tracked;
+}
+function normalizeSignatureValue(value) {
+	if (value == null) return "null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map((item) => normalizeSignatureValue(item)).join(",")}]`;
+	if (typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${key}:${normalizeSignatureValue(item)}`).join(",")}}`;
+	return String(value);
+}
+function readOptionalProperty(value, key) {
+	if (typeof value !== "object" || value === null || !(key in value)) return;
+	return value[key];
+}
+function getTailwindOptionsSignature(twPatcher) {
+	const options = twPatcher.options;
+	const tailwindOptions = resolveTailwindcssOptions(options);
+	return normalizeSignatureValue({
+		projectRoot: options?.projectRoot,
+		packageName: tailwindOptions?.packageName,
+		versionHint: readOptionalProperty(tailwindOptions, "versionHint"),
+		cwd: tailwindOptions?.cwd,
+		config: tailwindOptions?.config,
+		v2: tailwindOptions?.v2,
+		v3: tailwindOptions?.v3,
+		v4: {
+			base: tailwindOptions?.v4?.base,
+			configuredBase: readOptionalProperty(tailwindOptions?.v4, "configuredBase"),
+			css: tailwindOptions?.v4?.css,
+			cssEntries: tailwindOptions?.v4?.cssEntries,
+			hasUserDefinedSources: readOptionalProperty(tailwindOptions?.v4, "hasUserDefinedSources"),
+			sources: tailwindOptions?.v4?.sources
+		}
+	});
+}
+function getRuntimeTargetSignature(twPatcher) {
+	const packageInfo = twPatcher.packageInfo;
+	return [
+		packageInfo?.name ?? "missing",
+		packageInfo?.rootPath ?? "missing",
+		packageInfo?.version ?? "unknown",
+		twPatcher.majorVersion ?? "unknown",
+		getTailwindOptionsSignature(twPatcher)
+	].join(":");
+}
+function getNestedPatchers(twPatcher) {
+	const nested = twPatcher[runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function getOwnRuntimeClassSetSignature(twPatcher) {
+	const trackedFiles = [...getTailwindTrackedFiles(twPatcher)].sort((a, b) => a.localeCompare(b)).map(getFileSignature);
+	return `${trackedFiles.length > 0 ? trackedFiles.join("|") : "files:missing"}|runtime:${getRuntimeTargetSignature(twPatcher)}`;
+}
+function invalidateRuntimeClassSet(twPatcher) {
+	if (!twPatcher) return;
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) for (const patcher of nestedPatchers) invalidateRuntimeClassSet(patcher);
+	for (const trackedFile of getTailwindTrackedFiles(twPatcher)) runtimeFileSignatureCache.delete(trackedFile);
+	runtimeClassSetCache.delete(twPatcher);
+}
+function getRuntimeClassSetCacheEntry(twPatcher) {
+	return getCacheEntry(twPatcher);
+}
+function getRuntimeClassSetSignature(twPatcher) {
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) return nestedPatchers.map(getOwnRuntimeClassSetSignature).sort((a, b) => a.localeCompare(b)).join("||");
+	return getOwnRuntimeClassSetSignature(twPatcher);
+}
+//#endregion
+export { createTailwindcssPatcher as a, resolveTailwindcssOptions as c, findWorkspaceRoot as d, runtimeSignaturePatchersSymbol as i, findNearestPackageRoot as l, getRuntimeClassSetSignature as n, readInstalledPackageMajorVersion as o, invalidateRuntimeClassSet as r, findTailwindConfig as s, getRuntimeClassSetCacheEntry as t, findWorkspacePackageDir as u };

package/dist/cli/context.d.ts

@@ -1,7 +1,4 @@
-import type { CompatTailwindCssPatchOptions } from '../tailwindcss/patcher-options';
 import type { UserDefinedOptions } from '../types';
-export declare function resolveEntry(entry: string, cwd: string | undefined): string;
-export declare function buildTailwindcssPatcherOptions(overrides: Partial<CompatTailwindCssPatchOptions> | undefined): CompatTailwindCssPatchOptions | undefined;
 export declare function createCliContext(overrides: Partial<UserDefinedOptions> | undefined, resolvedCwd: string | undefined): Required<Omit<UserDefinedOptions, "supportCustomLengthUnitsPatch" | "customReplaceDictionary" | "cache"> & {
     supportCustomLengthUnitsPatch: import("tailwindcss-patch").ILengthUnitsPatchOptions | boolean;
     templateHandler: (rawSource: string, options?: import("@/types").ITemplateHandlerOptions) => Promise<string>;

package/dist/cli/helpers.d.ts

@@ -1,5 +1,4 @@
 import { normalizeExtractFormat, normalizeTokenFormat, readStringArrayOption, readStringOption, resolveCliCwd, toBoolean } from './helpers/options';
-import { resolvePatchDefaultCwd } from './helpers/patch-cwd';
 export declare function ensureDir(dir: string): Promise<void>;
 export declare function commandAction<T extends unknown[]>(handler: (...args: T) => Promise<void>): (...args: T) => Promise<void>;
-export { normalizeExtractFormat, normalizeTokenFormat, readStringArrayOption, readStringOption, resolveCliCwd, resolvePatchDefaultCwd, toBoolean, };
+export { normalizeExtractFormat, normalizeTokenFormat, readStringArrayOption, readStringOption, resolveCliCwd, toBoolean, };

package/dist/cli/mount-options.d.ts

@@ -1,2 +1,4 @@
 import type { TailwindcssPatchCliMountOptions } from 'tailwindcss-patch';
+export declare const PATCH_COMMAND_OBSOLETE_NOTICE = "\u63D0\u793A\uFF1Aweapp-tailwindcss@5 \u5DF2\u7531\u6784\u5EFA\u8FD0\u884C\u65F6\u63A5\u7BA1 Tailwind CSS \u5904\u7406\uFF0Cweapp-tw patch \u5DF2\u65E0\u9700\u6267\u884C\uFF1B\u8BF7\u79FB\u9664 package.json \u4E2D\u7684 postinstall \u94A9\u5B50\u3002";
+export declare function logPatchCommandObsoleteNotice(): void;
 export declare const mountOptions: TailwindcssPatchCliMountOptions;

package/dist/cli/types.d.ts

@@ -1,7 +1,5 @@
 export interface CommonCommandOptions {
     cwd?: string | boolean;
-    recordTarget?: boolean | string;
-    clearCache?: boolean | string;
 }
 export interface ExtractCommandOptions extends CommonCommandOptions {
     output?: string | boolean;