weapp-tailwindcss 5.0.0-next.9 → 5.0.1

package/dist/{tailwindcss-Bu-RWIHx.js → tailwindcss-DZckITp1.js}

@@ -1,13 +1,13 @@
-const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-BVAiJV3J.js");
-require("./utils-BiShvil9.js");
+const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_v3_engine = require("./v3-engine-M6Aqru5T.js");
+require("./utils-D7Ygohep.js");
+let node_fs = require("node:fs");
 let node_module = require("node:module");
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
 let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
-let node_fs = require("node:fs");
 let node_url = require("node:url");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 //#region src/tailwindcss/v4/css-sources.ts
@@ -27,18 +27,23 @@ function normalizeCssSourceFile(file) {
 	if (!file) return;
 	return node_path.default.isAbsolute(file) ? node_path.default.normalize(file) : file;
 }
+function normalizeCssSourceBase(base) {
+	if (!base) return;
+	return node_path.default.resolve(base);
+}
 function normalizeDependencies(dependencies) {
 	return dependencies?.map(normalizeCssSourceFile).filter((dependency) => typeof dependency === "string" && dependency.length > 0);
 }
 function isSameCssSource(a, b) {
-	return a.css === b.css && a.base === b.base && normalizeCssSourceFile(a.file) === normalizeCssSourceFile(b.file) && JSON.stringify(normalizeDependencies(a.dependencies)) === JSON.stringify(normalizeDependencies(b.dependencies));
+	return a.css === b.css && normalizeCssSourceBase(a.base) === normalizeCssSourceBase(b.base) && normalizeCssSourceFile(a.file) === normalizeCssSourceFile(b.file) && JSON.stringify(normalizeDependencies(a.dependencies)) === JSON.stringify(normalizeDependencies(b.dependencies));
 }
 function upsertTailwindV4CssSource(opts, source) {
-	const normalizedSource = {
+	const normalizedSource = require_v3_engine.omitUndefined({
 		...source,
+		...source.base === void 0 ? {} : { base: normalizeCssSourceBase(source.base) },
 		...source.file === void 0 ? {} : { file: normalizeCssSourceFile(source.file) },
 		...source.dependencies === void 0 ? {} : { dependencies: normalizeDependencies(source.dependencies) }
-	};
+	});
 	const tailwindcss = opts.tailwindcss ?? {};
 	const v4 = tailwindcss.v4 ?? {};
 	const cssSources = [...v4.cssSources ?? []];
@@ -46,6 +51,10 @@ function upsertTailwindV4CssSource(opts, source) {
 	const existingIndex = cssSources.findIndex((candidate) => normalizeCssSourceFile(candidate.file) === sourceFile);
 	if (existingIndex >= 0) {
 		const existing = cssSources[existingIndex];
+		if (!existing) {
+			cssSources[existingIndex] = normalizedSource;
+			return true;
+		}
 		const nextSource = {
 			...existing,
 			...normalizedSource
@@ -102,14 +111,7 @@ function ensureDefaultsIncluded(value) {
 	return value;
 }
 function normalizeCssEntriesConfig(entries) {
-	if (!entries) return;
-	if (typeof entries === "string") {
-		const trimmed = entries.trim();
-		return trimmed ? [trimmed] : void 0;
-	}
-	if (!Array.isArray(entries)) return;
-	const normalized = entries.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
-	return normalized.length > 0 ? normalized : void 0;
+	return require_v3_engine.normalizeStringListOption(entries);
 }
 function hasConfiguredCssEntries(ctx) {
 	if (normalizeCssEntriesConfig(ctx.cssEntries)) return true;
@@ -136,7 +138,11 @@ function applyV4CssCalcDefaults(cssCalc, patcher) {
 //#endregion
 //#region src/tailwindcss/v4/multi-patcher.ts
 function createMultiTailwindcssPatcher(patchers) {
-	if (patchers.length <= 1) return patchers[0];
+	if (patchers.length <= 1) {
+		const [patcher] = patchers;
+		if (!patcher) throw new Error("createMultiTailwindcssPatcher requires at least one patcher.");
+		return patcher;
+	}
 	const first = patchers[0];
 	const firstWithoutPatch = { ...first };
 	delete firstWithoutPatch.patch;
@@ -167,11 +173,11 @@ function createMultiTailwindcssPatcher(patchers) {
 				}
 				if (result.classSet) for (const className of result.classSet) aggregatedSet.add(className);
 			}
-			return {
+			return require_v3_engine.omitUndefined({
 				classList: aggregatedList,
 				classSet: aggregatedSet,
 				filename
-			};
+			});
 		}
 	};
 	if (patchers.every((patcher) => typeof patcher.getClassSetSync === "function")) multiPatcher.getClassSetSync = () => {
@@ -183,7 +189,7 @@ function createMultiTailwindcssPatcher(patchers) {
 		}
 		return aggregated;
 	};
-	Object.defineProperty(multiPatcher, require_cache.runtimeSignaturePatchersSymbol, {
+	Object.defineProperty(multiPatcher, require_v3_engine.runtimeSignaturePatchersSymbol, {
 		value: [...patchers],
 		configurable: true
 	});
@@ -217,7 +223,7 @@ function guessBasedirFromEntries(entries) {
 		const trimmed = entry.trim();
 		if (!trimmed || !node_path.default.isAbsolute(trimmed)) continue;
 		const entryDir = node_path.default.dirname(trimmed);
-		const resolved = require_cache.findNearestPackageRoot(entryDir) ?? entryDir;
+		const resolved = require_v3_engine.findNearestPackageRoot(entryDir) ?? entryDir;
 		if (resolved) return resolved;
 	}
 }
@@ -243,7 +249,7 @@ function resolveCssEntryBase(entryDir, options) {
 	const { preferredBaseDir, workspaceRoot } = options;
 	if (preferredBaseDir && isSubPath(preferredBaseDir, normalizedDir)) return preferredBaseDir;
 	if (workspaceRoot && isSubPath(workspaceRoot, normalizedDir)) return workspaceRoot;
-	const packageRoot = require_cache.findNearestPackageRoot(normalizedDir);
+	const packageRoot = require_v3_engine.findNearestPackageRoot(normalizedDir);
 	if (packageRoot) return node_path.default.normalize(packageRoot);
 	return normalizedDir;
 }
@@ -263,34 +269,26 @@ function groupCssEntriesByBase(entries, options = {}) {
 }
 //#endregion
 //#region src/tailwindcss/v4/patcher.ts
-const CONFIGURED_TAILWIND_VERSION_RE = /Configured tailwindcss\.version=\d+/u;
-const RESOLVED_TAILWIND_VERSION_RE = /resolved package ".+" is version /u;
 function isTailwindcss4Package(packageName) {
 	return Boolean(packageName && (packageName === "tailwindcss4" || packageName === "@tailwindcss/postcss" || packageName.includes("tailwindcss4")));
 }
 function resolveExplicitTailwindVersion(configuredVersion, configuredPackageName) {
 	if (typeof configuredVersion === "number") return configuredVersion;
-	if (configuredPackageName === "tailwindcss") return 3;
 	if (isTailwindcss4Package(configuredPackageName)) return 4;
 }
-function hasOwnV4Signal(value) {
-	return typeof value === "object" && value !== null && "v4" in value;
-}
-function isTailwindVersionMismatchError(error) {
-	return error instanceof Error && CONFIGURED_TAILWIND_VERSION_RE.test(error.message) && RESOLVED_TAILWIND_VERSION_RE.test(error.message);
-}
 function createPatcherForBase(baseDir, cssEntries, options) {
 	const { tailwindcss, tailwindcssPatcherOptions, supportCustomLengthUnitsPatch, bareArbitraryValues } = options;
 	const hasCssEntries = Boolean(cssEntries?.length);
-	const mergedTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, {
+	const defaultTailwindcssConfig = {
 		cwd: baseDir,
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: hasCssEntries ? { cssEntries } : {
+		v4: hasCssEntries ? require_v3_engine.omitUndefined({ cssEntries }) : require_v3_engine.omitUndefined({
 			base: baseDir,
 			cssEntries
-		}
-	});
+		})
+	};
+	const mergedTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, defaultTailwindcssConfig);
 	if (!mergedTailwindOptions.v4) mergedTailwindOptions.v4 = hasCssEntries ? { cssEntries: cssEntries ?? [] } : {
 		base: baseDir,
 		cssEntries: cssEntries ?? []
@@ -306,69 +304,48 @@ function createPatcherForBase(baseDir, cssEntries, options) {
 	const patchedOptions = overrideTailwindcssPatcherOptionsForBase(tailwindcssPatcherOptions, baseDir, cssEntries ?? []);
 	const configuredPackageName = tailwindcss?.packageName || tailwindcssPatcherOptions?.tailwindcss?.packageName;
 	const explicitTailwindVersion = resolveExplicitTailwindVersion(tailwindcss?.version || tailwindcssPatcherOptions?.tailwindcss?.version || mergedTailwindOptions.version, configuredPackageName);
-	const hasExplicitV4Signals = hasCssEntries || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss);
-	const packageNameForVersionDetection = configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss";
-	const installedTailwindVersion = require_cache.readInstalledPackageMajorVersion(packageNameForVersionDetection, baseDir);
-	const resolvedTailwindVersion = installedTailwindVersion ?? explicitTailwindVersion;
-	const shouldPatchV4PostcssPackage = (resolvedTailwindVersion === 4 && (installedTailwindVersion === 4 || explicitTailwindVersion === 4 || hasExplicitV4Signals && isTailwindcss4Package(packageNameForVersionDetection)) || resolvedTailwindVersion === void 0 && (hasCssEntries || hasOwnV4Signal(tailwindcss) || hasOwnV4Signal(tailwindcssPatcherOptions?.tailwindcss))) && !Boolean(configuredPackageName);
-	const packageCandidates = /* @__PURE__ */ new Set();
-	if (shouldPatchV4PostcssPackage) packageCandidates.add("@tailwindcss/postcss");
-	packageCandidates.add(mergedTailwindOptions.packageName ?? configuredPackageName ?? "tailwindcss");
-	const patchers = [];
-	const packageCandidateList = [...packageCandidates];
-	let firstVersionMismatchError;
-	for (const packageName of packageCandidateList) {
-		const tailwindOptionsForPackage = {
-			...mergedTailwindOptions,
-			packageName
-		};
-		if (resolvedTailwindVersion) tailwindOptionsForPackage.version = resolvedTailwindVersion;
-		try {
-			patchers.push(require_cache.createTailwindcssPatcher({
-				basedir: baseDir,
-				supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
-				tailwindcss: tailwindOptionsForPackage,
-				tailwindcssPatcherOptions: patchedOptions
-			}));
-		} catch (error) {
-			if (packageCandidateList.length > 1 && isTailwindVersionMismatchError(error)) {
-				firstVersionMismatchError ?? (firstVersionMismatchError = error);
-				_weapp_tailwindcss_logger.logger.warn("skip incompatible Tailwind package candidate \"%s\" for v4 patcher: %s", packageName, error.message);
-				continue;
-			}
-			throw error;
-		}
-	}
-	if (patchers.length === 0 && firstVersionMismatchError) throw firstVersionMismatchError;
-	return patchers.length === 1 ? patchers[0] : createMultiTailwindcssPatcher(patchers);
+	const resolvedTailwindVersion = require_v3_engine.readInstalledPackageMajorVersion(configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss", baseDir) ?? explicitTailwindVersion;
+	const supportedResolvedTailwindVersion = resolvedTailwindVersion === 2 || resolvedTailwindVersion === 3 || resolvedTailwindVersion === 4 ? resolvedTailwindVersion : void 0;
+	const tailwindOptionsForPackage = {
+		...mergedTailwindOptions,
+		packageName: mergedTailwindOptions.packageName ?? configuredPackageName ?? "tailwindcss"
+	};
+	if (supportedResolvedTailwindVersion) tailwindOptionsForPackage.version = supportedResolvedTailwindVersion;
+	return require_v3_engine.createTailwindcssPatcher(require_v3_engine.omitUndefined({
+		basedir: baseDir,
+		supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
+		tailwindcss: tailwindOptionsForPackage,
+		tailwindcssPatcherOptions: patchedOptions
+	}));
 }
 function tryCreateMultiTailwindcssPatcher(groups, options) {
 	if (groups.size <= 1) return;
 	_weapp_tailwindcss_logger.logger.debug("detected multiple Tailwind CSS entry bases: %O", [...groups.keys()]);
 	const patchers = [];
-	for (const [baseDir, entries] of groups) patchers.push(createPatcherForBase(baseDir, entries, options));
+	for (const [baseDir, entries] of groups) {
+		const patcher = createPatcherForBase(baseDir, entries, options);
+		if (patcher) patchers.push(patcher);
+	}
 	return createMultiTailwindcssPatcher(patchers);
 }
 //#endregion
 //#region src/uni-app-x/options.ts
+const DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: true,
+	onlyWhenStyleIsolationVersion2: true
+};
+const DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: false,
+	onlyWhenStyleIsolationVersion2: true
+};
+function isBooleanUniAppXShortcut(option) {
+	return option === true || option === false || option === void 0;
+}
 function resolveComponentLocalStyles(option) {
-	if (option === false) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
-	if (option === true || option === void 0) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
+	if (isBooleanUniAppXShortcut(option)) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
 	const componentLocalStyles = option.componentLocalStyles;
-	if (componentLocalStyles === false) return {
-		enabled: false,
-		onlyWhenStyleIsolationVersion2: true
-	};
-	if (componentLocalStyles === true || componentLocalStyles === void 0) return {
-		enabled: true,
-		onlyWhenStyleIsolationVersion2: true
-	};
+	if (componentLocalStyles === false) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
+	if (componentLocalStyles === true || componentLocalStyles === void 0) return DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS;
 	return {
 		enabled: componentLocalStyles.enabled !== false,
 		onlyWhenStyleIsolationVersion2: componentLocalStyles.onlyWhenStyleIsolationVersion2 !== false
@@ -414,12 +391,12 @@ function pickEnvBasedir() {
 	}
 }
 function pickPackageEnvBasedir() {
-	const packageJsonPath = node_process.default.env.npm_package_json;
+	const packageJsonPath = node_process.default.env["npm_package_json"];
 	if (packageJsonPath) {
 		const packageDir = node_path.default.dirname(packageJsonPath);
 		if (packageDir && node_path.default.isAbsolute(packageDir)) return packageDir;
 	}
-	const localPrefix = node_process.default.env.npm_config_local_prefix;
+	const localPrefix = node_process.default.env["npm_config_local_prefix"];
 	if (localPrefix && node_path.default.isAbsolute(localPrefix)) return localPrefix;
 }
 const STACK_PAREN_RE = /\(([^)]+)\)/u;
@@ -427,7 +404,7 @@ const STACK_AT_RE = /at\s+(\S.*)$/u;
 function detectCallerBasedir() {
 	const stack = (/* @__PURE__ */ new Error("resolveTailwindcssBasedir stack probe")).stack;
 	if (!stack) return;
-	if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("caller stack: %s", stack);
+	if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("caller stack: %s", stack);
 	const lines = stack.split("\n");
 	for (const line of lines) {
 		const location = (line.match(STACK_PAREN_RE) ?? line.match(STACK_AT_RE))?.[1];
@@ -438,7 +415,7 @@ function detectCallerBasedir() {
 		} catch {
 			continue;
 		}
-		const [candidate] = filePath.split(":");
+		const [candidate = ""] = filePath.split(":");
 		const resolvedPath = node_path.default.isAbsolute(filePath) ? filePath : candidate;
 		if (!node_path.default.isAbsolute(resolvedPath)) continue;
 		if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) continue;
@@ -459,7 +436,7 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 	const cwd = node_process.default.cwd();
 	const anchor = envBasedir ?? packageEnvBasedir ?? fallback ?? callerBasedir ?? cwd;
 	const resolveRelative = (value) => node_path.default.isAbsolute(value) ? node_path.default.normalize(value) : node_path.default.normalize(node_path.default.resolve(anchor, value));
-	if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("resolveTailwindcssBasedir anchor %O", {
+	if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("resolveTailwindcssBasedir anchor %O", {
 		basedir,
 		envBasedir,
 		envBasedirKey,
@@ -467,7 +444,7 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 		packageEnvBasedir,
 		fallback,
 		callerBasedir,
-		npm_package_json: node_process.default.env.npm_package_json,
+		npm_package_json: node_process.default.env["npm_package_json"],
 		cwd,
 		anchor
 	});
@@ -480,16 +457,16 @@ function resolveTailwindcssBasedir(basedir, fallback) {
 		const librarySegment = `${node_path.default.sep}weapp-tailwindcss${node_path.default.sep}`;
 		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
 	}
-	const packageName = node_process.default.env.PNPM_PACKAGE_NAME;
+	const packageName = node_process.default.env["PNPM_PACKAGE_NAME"];
 	if (packageName) try {
 		const packageJsonPath = (0, node_module.createRequire)(node_path.default.join(anchor, "__resolve_tailwindcss_basedir__.cjs")).resolve(`${packageName}/package.json`);
-		if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+		if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
 		return node_path.default.normalize(node_path.default.dirname(packageJsonPath));
 	} catch {
-		if (node_process.default.env.WEAPP_TW_DEBUG_STACK === "1") _weapp_tailwindcss_logger.logger.debug("failed to resolve package json for %s", packageName);
-		const workspaceRoot = require_cache.findWorkspaceRoot(anchor);
+		if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("failed to resolve package json for %s", packageName);
+		const workspaceRoot = require_v3_engine.findWorkspaceRoot(anchor);
 		if (workspaceRoot) {
-			const packageDir = require_cache.findWorkspacePackageDir(workspaceRoot, packageName);
+			const packageDir = require_v3_engine.findWorkspacePackageDir(workspaceRoot, packageName);
 			if (packageDir) return packageDir;
 		}
 	}
@@ -505,8 +482,8 @@ function isRaxWorkspace(appType, baseDir) {
 		if (!(0, node_fs.existsSync)(pkgPath)) return false;
 		const pkg = JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"));
 		const deps = {
-			...pkg.dependencies ?? {},
-			...pkg.devDependencies ?? {}
+			...pkg["dependencies"] ?? {},
+			...pkg["devDependencies"] ?? {}
 		};
 		if (deps["rax-app"] || deps.rax) return true;
 	} catch {
@@ -535,8 +512,8 @@ function detectImplicitCssEntries(appType, baseDir) {
 	baseCandidates.add(node_path.default.normalize(baseDir));
 	const envCandidates = [
 		node_process.default.cwd(),
-		node_process.default.env.INIT_CWD,
-		node_process.default.env.PWD
+		node_process.default.env["INIT_CWD"],
+		node_process.default.env["PWD"]
 	];
 	for (const candidate of envCandidates) if (candidate) baseCandidates.add(node_path.default.normalize(candidate));
 	for (const candidateBase of baseCandidates) {
@@ -563,11 +540,11 @@ function createTailwindcssPatcherFromContext(ctx) {
 		appType,
 		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
 	};
-	const workspaceRoot = require_cache.findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? require_cache.findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
-	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, {
+	const workspaceRoot = require_v3_engine.findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? require_v3_engine.findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, require_v3_engine.omitUndefined({
 		preferredBaseDir: resolvedTailwindcssBasedir,
 		workspaceRoot
-	}) : void 0;
+	})) : void 0;
 	const multiPatcher = groupedCssEntries ? tryCreateMultiTailwindcssPatcher(groupedCssEntries, patcherOptions) : void 0;
 	if (multiPatcher) return multiPatcher;
 	if (groupedCssEntries?.size === 1) {

package/dist/typedoc.export.d.ts

@@ -1,3 +1,3 @@
 export type { WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult, WeappTailwindcssGenerator, WeappTailwindcssGeneratorTarget, WeappTailwindcssPostcssPluginOptions, } from './index';
+export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssPatchOptions, TailwindV2Options, TailwindV3Options, TailwindV4Options, } from './types/typedoc-tailwindcss-patch';
 export type { UserDefinedOptions } from './types/user-defined-options';
-export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssPatchOptions, TailwindV2Options, TailwindV3Options, TailwindV4Options, } from 'tailwindcss-patch';

package/dist/types/index.d.ts

@@ -10,7 +10,11 @@ import type { UniAppXComponentLocalStylesOptions, UniAppXOptions as UniAppXUserD
 type AsyncableMethod<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> | Awaited<R> : never;
 export type { UniAppXComponentLocalStylesOptions, UniAppXUserDefinedOptions, UserDefinedOptions, };
 export type { CssPreflightOptions, IStyleHandlerOptions, ItemOrItemArray };
-export type { AppType, IArbitraryValues, ICustomAttributes, ICustomAttributesEntities } from './shared';
+export type { AppType, IArbitraryValues, ICustomAttributes, ICustomAttributesEntities, IUnocssCompatibilityOptions } from './shared';
+export type RequiredDefined<T> = {
+    [K in keyof T]-?: Exclude<T[K], undefined>;
+};
+type InternalUserDefinedOptionsBase = RequiredDefined<Omit<UserDefinedOptions, 'supportCustomLengthUnitsPatch' | 'customReplaceDictionary' | 'cache' | 'twPatcher' | 'refreshTailwindcssPatcher' | 'templateHandler' | 'styleHandler' | 'jsHandler'>>;
 export interface LinkedJsModuleResult {
     code: string;
 }
@@ -22,56 +26,62 @@ export interface JsHandlerResult {
 }
 export interface TailwindcssPatcherLike {
     packageInfo: TailwindcssPatcher['packageInfo'];
-    majorVersion?: TailwindcssPatcher['majorVersion'];
-    patch?: TailwindcssPatcher['patch'];
+    majorVersion?: TailwindcssPatcher['majorVersion'] | undefined;
+    patch?: TailwindcssPatcher['patch'] | undefined;
     getClassSet: AsyncableMethod<TailwindcssPatcher['getClassSet']>;
-    getClassSetSync?: TailwindcssPatcher['getClassSetSync'];
+    getClassSetSync?: TailwindcssPatcher['getClassSetSync'] | undefined;
     extract: TailwindcssPatcher['extract'];
-    collectContentTokens?: TailwindcssPatcher['collectContentTokens'];
-    options?: TailwindcssPatcher['options'];
+    collectContentTokens?: TailwindcssPatcher['collectContentTokens'] | undefined;
+    options?: TailwindcssPatcher['options'] | undefined;
 }
+export type BabelParserOptions = ParserOptions & {
+    cache?: boolean | undefined;
+    cacheKey?: string | undefined;
+    cacheMaxEntries?: number | undefined;
+    cacheMaxSourceLength?: number | undefined;
+};
 export interface RefreshTailwindcssPatcherOptions {
-    clearCache?: boolean;
+    clearCache?: boolean | undefined;
 }
 export interface IJsHandlerOptions {
-    escapeMap?: Record<string, string>;
-    classNameSet?: Set<string>;
-    jsArbitraryValueFallback?: boolean | 'auto';
-    tailwindcssMajorVersion?: number;
-    arbitraryValues?: IArbitraryValues;
-    jsPreserveClass?: (keyword: string) => boolean | undefined;
-    needEscaped?: boolean;
-    generateMap?: boolean;
-    alwaysEscape?: boolean;
-    unescapeUnicode?: boolean;
-    babelParserOptions?: ParserOptions;
-    ignoreTaggedTemplateExpressionIdentifiers?: (string | RegExp)[];
-    ignoreCallExpressionIdentifiers?: (string | RegExp)[];
-    uniAppX?: boolean;
-    moduleSpecifierReplacements?: Record<string, string>;
-    wrapExpression?: boolean;
-    filename?: string;
-    moduleGraph?: JsModuleGraphOptions;
+    escapeMap?: Record<string, string> | undefined;
+    classNameSet?: Set<string> | undefined;
+    jsArbitraryValueFallback?: boolean | 'auto' | undefined;
+    tailwindcssMajorVersion?: number | undefined;
+    arbitraryValues?: IArbitraryValues | undefined;
+    jsPreserveClass?: ((keyword: string) => boolean | undefined) | undefined;
+    needEscaped?: boolean | undefined;
+    generateMap?: boolean | undefined;
+    alwaysEscape?: boolean | undefined;
+    unescapeUnicode?: boolean | undefined;
+    babelParserOptions?: BabelParserOptions | undefined;
+    ignoreTaggedTemplateExpressionIdentifiers?: (string | RegExp)[] | undefined;
+    ignoreCallExpressionIdentifiers?: (string | RegExp)[] | undefined;
+    uniAppX?: boolean | undefined;
+    moduleSpecifierReplacements?: Record<string, string> | undefined;
+    wrapExpression?: boolean | undefined;
+    filename?: string | undefined;
+    moduleGraph?: JsModuleGraphOptions | undefined;
 }
 export interface JsHandler {
     (rawSource: string, set?: Set<string>, options?: CreateJsHandlerOptions): JsHandlerResult;
 }
 export interface ICommonReplaceOptions {
-    keepEOL?: boolean;
-    escapeMap?: Record<string, string>;
+    keepEOL?: boolean | undefined;
+    escapeMap?: Record<string, string> | undefined;
 }
 export interface ITemplateHandlerOptions extends ICommonReplaceOptions {
-    customAttributesEntities?: ICustomAttributesEntities;
-    escapeMap?: Record<string, string>;
-    inlineWxs?: boolean;
-    jsHandler?: JsHandler;
-    runtimeSet?: Set<string>;
-    disabledDefaultTemplateHandler?: boolean;
-    quote?: string | null;
-    ignoreHead?: boolean;
-    wrapExpression?: boolean;
+    customAttributesEntities?: ICustomAttributesEntities | undefined;
+    escapeMap?: Record<string, string> | undefined;
+    inlineWxs?: boolean | undefined;
+    jsHandler?: JsHandler | undefined;
+    runtimeSet?: Set<string> | undefined;
+    disabledDefaultTemplateHandler?: boolean | undefined;
+    quote?: string | null | undefined;
+    ignoreHead?: boolean | undefined;
+    wrapExpression?: boolean | undefined;
 }
-export type InternalUserDefinedOptions = Required<Omit<UserDefinedOptions, 'supportCustomLengthUnitsPatch' | 'customReplaceDictionary' | 'cache'> & {
+export interface InternalUserDefinedOptions extends InternalUserDefinedOptionsBase {
     supportCustomLengthUnitsPatch: ILengthUnitsPatchOptions | boolean;
     templateHandler: (rawSource: string, options?: ITemplateHandlerOptions) => Promise<string>;
     styleHandler: (rawSource: string, options?: IStyleHandlerOptions) => Promise<PostcssResult<Root | Document>>;
@@ -81,17 +91,17 @@ export type InternalUserDefinedOptions = Required<Omit<UserDefinedOptions, 'supp
     cache: ICreateCacheReturnType;
     twPatcher: TailwindcssPatcherLike;
     refreshTailwindcssPatcher: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
-}>;
+}
 export type InternalPostcssOptions = Pick<UserDefinedOptions, 'cssMatcher' | 'mainCssChunkMatcher' | 'cssPreflight' | 'cssPreflightRange' | 'disabled'>;
 export interface IBaseWebpackPlugin {
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     apply: (compiler: any) => void;
 }
 export type CreateJsHandlerOptions = Omit<IJsHandlerOptions, 'classNameSet'>;
 export interface JsModuleGraphOptions {
     resolve: (specifier: string, importer: string) => string | undefined;
     load: (id: string) => string | undefined;
-    filter?: (id: string, specifier: string, importer: string) => boolean;
-    maxDepth?: number;
+    filter?: ((id: string, specifier: string, importer: string) => boolean) | undefined;
+    maxDepth?: number | undefined;
 }

package/dist/types/shared.d.ts

@@ -8,3 +8,6 @@ export interface IArbitraryValues {
         units?: string[];
     };
 }
+export interface IUnocssCompatibilityOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'];
+}

package/dist/types/typedoc-tailwindcss-patch.d.ts

@@ -0,0 +1,67 @@
+import type { SourceEntry } from '@tailwindcss/oxide';
+import type { PackageResolvingOptions } from 'local-pkg';
+import type { ILengthUnitsPatchOptions } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '../tailwindcss/v4-engine';
+export type CacheStrategy = 'merge' | 'overwrite';
+export type CacheDriver = 'file' | 'memory' | 'noop';
+export interface CacheOptions {
+    enabled?: boolean;
+    cwd?: string;
+    dir?: string;
+    file?: string;
+    strategy?: CacheStrategy;
+    driver?: CacheDriver;
+}
+export interface ExtractOptions {
+    write?: boolean;
+    file?: string;
+    format?: 'json' | 'lines';
+    pretty?: number | boolean;
+    removeUniversalSelector?: boolean;
+}
+export interface ExposeContextOptions {
+    refProperty?: string;
+}
+export interface ExtendLengthUnitsOptions extends Partial<ILengthUnitsPatchOptions> {
+    enabled?: boolean;
+}
+export interface ApplyOptions {
+    overwrite?: boolean;
+    exposeContext?: boolean | ExposeContextOptions;
+    extendLengthUnits?: false | ExtendLengthUnitsOptions;
+}
+export interface TailwindRuntimeOptionsBase {
+    config?: string;
+    cwd?: string;
+    postcssPlugin?: string;
+}
+export interface TailwindV2Options extends TailwindRuntimeOptionsBase {
+}
+export interface TailwindV3Options extends TailwindRuntimeOptionsBase {
+}
+export interface TailwindV4Options {
+    base?: string;
+    css?: string;
+    cssSources?: TailwindV4CssSource[];
+    cssEntries?: string[];
+    sources?: SourceEntry[];
+    bareArbitraryValues?: boolean | {
+        units?: string[];
+    } | undefined;
+}
+export interface TailwindCssOptions extends TailwindRuntimeOptionsBase {
+    version?: 2 | 3 | 4;
+    packageName?: string;
+    resolve?: PackageResolvingOptions;
+    v2?: TailwindV2Options;
+    v3?: TailwindV3Options;
+    v4?: TailwindV4Options;
+}
+export interface TailwindCssPatchOptions {
+    projectRoot?: string;
+    tailwindcss?: TailwindCssOptions;
+    apply?: ApplyOptions;
+    extract?: ExtractOptions;
+    filter?: (className: string) => boolean;
+    cache?: boolean | CacheOptions;
+}

package/dist/types/user-defined-options/general.d.ts

@@ -3,27 +3,30 @@ import type { LoadedPostcssOptions } from '@weapp-tailwindcss/postcss/types';
 import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
 import type { ICreateCacheReturnType } from '../../cache';
 import type { WeappTailwindcssGeneratorUserOptions } from '../../generator';
-import type { AppType, IArbitraryValues } from '../shared';
+import type { AppType, IArbitraryValues, IUnocssCompatibilityOptions } from '../shared';
 export interface UserDefinedOptionsGeneralPart {
-    supportCustomLengthUnitsPatch?: ILengthUnitsPatchOptions | boolean;
-    appType?: AppType;
-    arbitraryValues?: IArbitraryValues;
-    jsPreserveClass?: (keyword: string) => boolean | undefined;
-    jsArbitraryValueFallback?: boolean | 'auto';
-    replaceRuntimePackages?: boolean | Record<string, string>;
-    generator?: WeappTailwindcssGeneratorUserOptions;
-    disabledDefaultTemplateHandler?: boolean;
-    runtimeLoaderPath?: string;
-    tailwindcssBasedir?: string;
-    cache?: boolean | ICreateCacheReturnType;
-    babelParserOptions?: ParserOptions & {
-        cache?: boolean;
-        cacheKey?: string;
-    };
-    cssChildCombinatorReplaceValue?: string | string[];
-    postcssOptions?: LoadedPostcssOptions;
-    cssRemoveHoverPseudoClass?: boolean;
-    cssRemoveProperty?: boolean;
-    tailwindcssPatcherOptions?: TailwindCssPatchOptions;
-    logLevel?: 'info' | 'warn' | 'error' | 'silent';
+    supportCustomLengthUnitsPatch?: ILengthUnitsPatchOptions | boolean | undefined;
+    appType?: AppType | undefined;
+    arbitraryValues?: IArbitraryValues | undefined;
+    unocss?: boolean | IUnocssCompatibilityOptions | undefined;
+    jsPreserveClass?: ((keyword: string) => boolean | undefined) | undefined;
+    jsArbitraryValueFallback?: boolean | 'auto' | undefined;
+    replaceRuntimePackages?: boolean | Record<string, string> | undefined;
+    generator?: WeappTailwindcssGeneratorUserOptions | undefined;
+    disabledDefaultTemplateHandler?: boolean | undefined;
+    runtimeLoaderPath?: string | undefined;
+    tailwindcssBasedir?: string | undefined;
+    cache?: boolean | ICreateCacheReturnType | undefined;
+    babelParserOptions?: (ParserOptions & {
+        cache?: boolean | undefined;
+        cacheKey?: string | undefined;
+        cacheMaxEntries?: number | undefined;
+        cacheMaxSourceLength?: number | undefined;
+    }) | undefined;
+    cssChildCombinatorReplaceValue?: string | string[] | undefined;
+    postcssOptions?: LoadedPostcssOptions | undefined;
+    cssRemoveHoverPseudoClass?: boolean | undefined;
+    cssRemoveProperty?: boolean | undefined;
+    tailwindcssPatcherOptions?: TailwindCssPatchOptions | undefined;
+    logLevel?: 'info' | 'warn' | 'error' | 'silent' | undefined;
 }