weapp-tailwindcss 5.0.13 → 5.1.1

package/dist/{transform-DfcEjsZF.mjs → transform-fRBeuuK-.mjs}

@@ -1,6 +1,6 @@
-import { c as createAttributeMatcher, d as _defineProperty, f as isClassContextLiteralPath, l as analyzeSource, m as babelParse, p as replaceWxml, s as generateCode, u as JsTokenUpdater } from "./precheck-CRI90iL1.mjs";
+import { c as createAttributeMatcher, d as JsTokenUpdater, f as _defineProperty, h as babelParse, m as replaceWxml, p as isClassContextLiteralPath, s as generateCode, u as analyzeSource } from "./context-DlpKD7aN.mjs";
 import { createRequire } from "node:module";
-import { splitCandidateTokens } from "tailwindcss-patch";
+import { splitCandidateTokens } from "@tailwindcss-mangle/engine";
 import MagicString from "magic-string";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);

package/dist/{transform-YmrmxuF3.js → transform-vLwZpiTE.js}

@@ -1,6 +1,6 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_precheck = require("./precheck-B0Z8yW7E.js");
-let tailwindcss_patch = require("tailwindcss-patch");
+const require_context = require("./context-B6hVF7dr.js");
+let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
 let magic_string = require("magic-string");
 magic_string = require_chunk.__toESM(magic_string);
 //#region ../../node_modules/.pnpm/@vue+shared@3.5.38/node_modules/@vue/shared/dist/shared.cjs.prod.js
@@ -14616,7 +14616,7 @@ function createAlias(fileId, utility, index) {
 }
 function isRuntimeCandidate(candidate, runtimeSet) {
 	if (!runtimeSet || runtimeSet.size === 0) return false;
-	return runtimeSet.has(candidate) || runtimeSet.has(require_precheck.replaceWxml(candidate));
+	return runtimeSet.has(candidate) || runtimeSet.has(require_context.replaceWxml(candidate));
 }
 function shouldEnableComponentLocalStyle(id) {
 	return COMPONENT_RE.test(id);
@@ -14628,8 +14628,8 @@ var UniAppXComponentLocalStyleCollector = class {
 	constructor(fileId, runtimeSet) {
 		this.fileId = fileId;
 		this.runtimeSet = runtimeSet;
-		require_precheck._defineProperty(this, "aliasByUtility", /* @__PURE__ */ new Map());
-		require_precheck._defineProperty(this, "aliasByLookup", /* @__PURE__ */ new Map());
+		require_context._defineProperty(this, "aliasByUtility", /* @__PURE__ */ new Map());
+		require_context._defineProperty(this, "aliasByLookup", /* @__PURE__ */ new Map());
 	}
 	ensureAlias(utility) {
 		const cached = this.aliasByUtility.get(utility);
@@ -14637,11 +14637,11 @@ var UniAppXComponentLocalStyleCollector = class {
 		const alias = createAlias(this.fileId, utility, this.aliasByUtility.size);
 		this.aliasByUtility.set(utility, alias);
 		this.aliasByLookup.set(utility, alias);
-		this.aliasByLookup.set(require_precheck.replaceWxml(utility), alias);
+		this.aliasByLookup.set(require_context.replaceWxml(utility), alias);
 		return alias;
 	}
 	rewriteLiteral(literal, shouldInclude) {
-		const candidates = (0, tailwindcss_patch.splitCandidateTokens)(literal);
+		const candidates = (0, _tailwindcss_mangle_engine.splitCandidateTokens)(literal);
 		if (candidates.length === 0) return literal;
 		let rewritten = literal;
 		for (const candidate of candidates) {
@@ -14656,14 +14656,14 @@ var UniAppXComponentLocalStyleCollector = class {
 	collectRuntimeClasses(rawSource, options = {}) {
 		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
 		try {
-			const analysis = require_precheck.analyzeSource(require_precheck.babelParse(wrapped, {
+			const analysis = require_context.analyzeSource(require_context.babelParse(wrapped, {
 				plugins: ["typescript"],
 				sourceType: options.wrapExpression ? "module" : "unambiguous"
 			}), {}, void 0, false);
 			for (const path of analysis.targetPaths) {
 				const { literal } = extractLiteralValue(path);
-				const candidates = (0, tailwindcss_patch.splitCandidateTokens)(literal);
-				const classContext = options.wrapExpression || require_precheck.isClassContextLiteralPath(path);
+				const candidates = (0, _tailwindcss_mangle_engine.splitCandidateTokens)(literal);
+				const classContext = options.wrapExpression || require_context.isClassContextLiteralPath(path);
 				for (const candidate of candidates) {
 					if (!candidate || !classContext && !isRuntimeCandidate(candidate, this.runtimeSet)) continue;
 					if (isRuntimeCandidate(candidate, this.runtimeSet)) this.ensureAlias(candidate);
@@ -14675,15 +14675,15 @@ var UniAppXComponentLocalStyleCollector = class {
 		if (this.aliasByLookup.size === 0) return rawSource;
 		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
 		try {
-			const analysis = require_precheck.analyzeSource(require_precheck.babelParse(wrapped, {
+			const analysis = require_context.analyzeSource(require_context.babelParse(wrapped, {
 				plugins: ["typescript"],
 				sourceType: options.wrapExpression ? "module" : "unambiguous"
 			}), {}, void 0, false);
 			if (analysis.targetPaths.length === 0) return rawSource;
-			const updater = new require_precheck.JsTokenUpdater();
+			const updater = new require_context.JsTokenUpdater();
 			for (const path of analysis.targetPaths) {
 				const { literal, offset } = extractLiteralValue(path);
-				const candidates = (0, tailwindcss_patch.splitCandidateTokens)(literal);
+				const candidates = (0, _tailwindcss_mangle_engine.splitCandidateTokens)(literal);
 				if (candidates.length === 0) continue;
 				let rewritten = literal;
 				let mutated = false;
@@ -14743,7 +14743,7 @@ function updateStaticAttribute(ms, prop, offset, content = prop.value?.content)
 	if (!prop.value) return;
 	const start = offset + prop.value.loc.start.offset + 1;
 	const end = offset + prop.value.loc.end.offset - 1;
-	if (start < end) ms.update(start, end, require_precheck.replaceWxml(content ?? ""));
+	if (start < end) ms.update(start, end, require_context.replaceWxml(content ?? ""));
 }
 function updateStaticAttributeWithLocalStyle(ms, prop, offset, collector, content = prop.value?.content) {
 	if (!prop.value) return;
@@ -14757,7 +14757,7 @@ function updateDirectiveExpression(ms, prop, offset, jsHandler, runtimeSet) {
 	const start = offset + prop.exp.loc.start.offset;
 	const end = offset + prop.exp.loc.end.offset;
 	if (start >= end) return;
-	const generated = require_precheck.generateCode(expression, {
+	const generated = require_context.generateCode(expression, {
 		jsHandler,
 		runtimeSet,
 		wrapExpression: true
@@ -14771,7 +14771,7 @@ function updateDirectiveExpressionWithLocalStyle(ms, prop, offset, jsHandler, co
 	const end = offset + prop.exp.loc.end.offset;
 	if (start >= end) return;
 	collector.collectRuntimeClasses(expression, { wrapExpression: true });
-	const generated = require_precheck.generateCode(expression, {
+	const generated = require_context.generateCode(expression, {
 		jsHandler,
 		runtimeSet,
 		wrapExpression: true
@@ -14831,7 +14831,7 @@ function parseSfc(code) {
 function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
 	if (!UVUE_NVUE_RE.test(id)) return;
 	const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
-	const matchCustomAttribute = require_precheck.createAttributeMatcher(customAttributesEntities);
+	const matchCustomAttribute = require_context.createAttributeMatcher(customAttributesEntities);
 	const ms = new magic_string.default(code);
 	const descriptor = parseSfc(code);
 	const localStyleCollector = shouldEnableLocalStyle(id, options) ? new UniAppXComponentLocalStyleCollector(id, runtimeSet) : void 0;

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 { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindV4Options, } from './types/typedoc-tailwindcss-runtime';
 export type { UserDefinedOptions } from './types/user-defined-options';

package/dist/types/index.d.ts

@@ -1,19 +1,18 @@
 import type { ParseError, ParserOptions } from '@babel/parser';
 import type { CssPreflightOptions, Document, IStyleHandlerOptions, Result as PostcssResult, Root } from '@weapp-tailwindcss/postcss';
 import type { SourceMap } from 'magic-string';
-import type { ILengthUnitsPatchOptions, TailwindcssPatcher } from 'tailwindcss-patch';
 import type { ICreateCacheReturnType } from '../cache';
 import type { ItemOrItemArray } from './base';
 import type { AppType, IArbitraryValues, ICustomAttributesEntities } from './shared';
 import type { UniAppXComponentLocalStylesOptions, UniAppXOptions as UniAppXUserDefinedOptions, UserDefinedOptions } from './user-defined-options';
-type AsyncableMethod<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> | Awaited<R> : never;
-export type { UniAppXComponentLocalStylesOptions, UniAppXUserDefinedOptions, UserDefinedOptions, };
+import type { LengthUnitsRuntimeOptions, TailwindContentTokenReport, TailwindcssExtractOptions, TailwindcssExtractResult, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindPackageInfo } from '../tailwindcss/runtime-types';
+export type { TailwindCssOptions, TailwindCssRuntimeOptions, UniAppXComponentLocalStylesOptions, UniAppXUserDefinedOptions, UserDefinedOptions, };
 export type { CssPreflightOptions, IStyleHandlerOptions, ItemOrItemArray };
 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'>>;
+type InternalUserDefinedOptionsBase = RequiredDefined<Omit<UserDefinedOptions, 'supportCustomLengthUnits' | 'customReplaceDictionary' | 'cache' | 'templateHandler' | 'styleHandler' | 'jsHandler'>>;
 export interface LinkedJsModuleResult {
     code: string;
 }
@@ -23,15 +22,14 @@ export interface JsHandlerResult {
     error?: ParseError;
     linked?: Record<string, LinkedJsModuleResult>;
 }
-export interface TailwindcssPatcherLike {
-    packageInfo: TailwindcssPatcher['packageInfo'];
-    majorVersion?: TailwindcssPatcher['majorVersion'] | undefined;
-    patch?: TailwindcssPatcher['patch'] | undefined;
-    getClassSet: AsyncableMethod<TailwindcssPatcher['getClassSet']>;
-    getClassSetSync?: TailwindcssPatcher['getClassSetSync'] | undefined;
-    extract: TailwindcssPatcher['extract'];
-    collectContentTokens?: TailwindcssPatcher['collectContentTokens'] | undefined;
-    options?: TailwindcssPatcher['options'] | undefined;
+export interface TailwindcssRuntimeLike {
+    packageInfo: TailwindPackageInfo;
+    majorVersion?: number | undefined;
+    getClassSet: () => Promise<Set<string>> | Set<string>;
+    getClassSetSync?: (() => Set<string>) | undefined;
+    extract: (options?: TailwindcssExtractOptions) => Promise<TailwindcssExtractResult> | TailwindcssExtractResult;
+    collectContentTokens?: (() => Promise<TailwindContentTokenReport> | TailwindContentTokenReport) | undefined;
+    options?: TailwindCssRuntimeOptions | undefined;
 }
 export type BabelParserOptions = ParserOptions & {
     cache?: boolean | undefined;
@@ -39,7 +37,7 @@ export type BabelParserOptions = ParserOptions & {
     cacheMaxEntries?: number | undefined;
     cacheMaxSourceLength?: number | undefined;
 };
-export interface RefreshTailwindcssPatcherOptions {
+export interface RefreshTailwindcssRuntimeOptions {
     clearCache?: boolean | undefined;
 }
 export interface IJsHandlerOptions {
@@ -54,6 +52,7 @@ export interface IJsHandlerOptions {
     alwaysEscape?: boolean | undefined;
     unescapeUnicode?: boolean | undefined;
     babelParserOptions?: BabelParserOptions | undefined;
+    experimentalJsFastPath?: boolean | 'oxc' | undefined;
     ignoreTaggedTemplateExpressionIdentifiers?: (string | RegExp)[] | undefined;
     ignoreCallExpressionIdentifiers?: (string | RegExp)[] | undefined;
     uniAppX?: boolean | undefined;
@@ -81,15 +80,15 @@ export interface ITemplateHandlerOptions extends ICommonReplaceOptions {
     wrapExpression?: boolean | undefined;
 }
 export interface InternalUserDefinedOptions extends InternalUserDefinedOptionsBase {
-    supportCustomLengthUnitsPatch: ILengthUnitsPatchOptions | boolean;
+    supportCustomLengthUnits: LengthUnitsRuntimeOptions | boolean;
     templateHandler: (rawSource: string, options?: ITemplateHandlerOptions) => Promise<string>;
     styleHandler: (rawSource: string, options?: IStyleHandlerOptions) => Promise<PostcssResult<Root | Document>>;
     jsHandler: JsHandler;
     escapeMap: Record<string, string>;
     customReplaceDictionary: Record<string, string>;
     cache: ICreateCacheReturnType;
-    twPatcher: TailwindcssPatcherLike;
-    refreshTailwindcssPatcher: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
+    tailwindRuntime: TailwindcssRuntimeLike;
+    refreshTailwindcssRuntime: (options?: RefreshTailwindcssRuntimeOptions) => Promise<TailwindcssRuntimeLike>;
 }
 export type InternalPostcssOptions = Pick<UserDefinedOptions, 'cssMatcher' | 'mainCssChunkMatcher' | 'cssPreflight' | 'cssPreflightRange' | 'disabled'>;
 export interface IBaseWebpackPlugin {

package/dist/types/shared.d.ts

@@ -1,5 +1,5 @@
 import type { ItemOrItemArray } from './base';
-export type AppType = 'uni-app' | 'uni-app-vite' | 'uni-app-x' | 'taro' | 'remax' | 'rax' | 'native' | 'kbone' | 'mpx' | 'weapp-vite';
+export type AppType = 'uni-app' | 'uni-app-vite' | 'uni-app-x' | 'taro' | 'remax' | 'native' | 'kbone' | 'mpx' | 'weapp-vite';
 export type ICustomAttributes = Record<string, ItemOrItemArray<string | RegExp>> | Map<string | RegExp, ItemOrItemArray<string | RegExp>>;
 export type ICustomAttributesEntities = [string | RegExp, ItemOrItemArray<string | RegExp>][];
 export interface IArbitraryValues {

package/dist/types/{typedoc-tailwindcss-patch.d.ts → typedoc-tailwindcss-runtime.d.ts}

@@ -1,7 +1,7 @@
 import type { PackageResolvingOptions } from 'local-pkg';
-import type { ILengthUnitsPatchOptions } from 'tailwindcss-patch';
 import type { TailwindSourceEntry as SourceEntry } from '../tailwindcss/source-scan';
 import type { TailwindV4SourceOptions } from '../tailwindcss/v4-engine';
+import type { LengthUnitsRuntimeOptions } from '../tailwindcss/runtime-types';
 type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
 export type CacheStrategy = 'merge' | 'overwrite';
 export type CacheDriver = 'file' | 'memory' | 'noop';
@@ -23,7 +23,7 @@ export interface ExtractOptions {
 export interface ExposeContextOptions {
     refProperty?: string;
 }
-export interface ExtendLengthUnitsOptions extends Partial<ILengthUnitsPatchOptions> {
+export interface ExtendLengthUnitsOptions extends Partial<LengthUnitsRuntimeOptions> {
     enabled?: boolean;
 }
 export interface ApplyOptions {
@@ -36,10 +36,6 @@ export interface TailwindRuntimeOptionsBase {
     cwd?: string;
     postcssPlugin?: string;
 }
-export interface TailwindV2Options extends TailwindRuntimeOptionsBase {
-}
-export interface TailwindV3Options extends TailwindRuntimeOptionsBase {
-}
 export interface TailwindV4Options {
     base?: string;
     css?: string;
@@ -51,14 +47,12 @@ export interface TailwindV4Options {
     } | undefined;
 }
 export interface TailwindCssOptions extends TailwindRuntimeOptionsBase {
-    version?: 2 | 3 | 4;
+    version?: 4;
     packageName?: string;
     resolve?: PackageResolvingOptions;
-    v2?: TailwindV2Options;
-    v3?: TailwindV3Options;
     v4?: TailwindV4Options;
 }
-export interface TailwindCssPatchOptions {
+export interface TailwindCssRuntimeOptions {
     projectRoot?: string;
     tailwindcss?: TailwindCssOptions;
     apply?: ApplyOptions;

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

@@ -1,21 +1,22 @@
 import type { ParserOptions } from '@babel/parser';
 import type { CssOptions, 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, IUnocssCompatibilityOptions } from '../shared';
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types';
 export interface CssSourceTraceOptions {
     root?: string | undefined;
 }
 export type CssSourceTraceUserOptions = boolean | CssSourceTraceOptions;
 export interface UserDefinedOptionsGeneralPart {
-    supportCustomLengthUnitsPatch?: ILengthUnitsPatchOptions | boolean | undefined;
+    supportCustomLengthUnits?: LengthUnitsRuntimeOptions | 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;
+    rewriteCssImports?: boolean | undefined;
     generator?: WeappTailwindcssGeneratorUserOptions | undefined;
     cssSourceTrace?: CssSourceTraceUserOptions | undefined;
     disabledDefaultTemplateHandler?: boolean | undefined;
@@ -28,12 +29,13 @@ export interface UserDefinedOptionsGeneralPart {
         cacheMaxEntries?: number | undefined;
         cacheMaxSourceLength?: number | undefined;
     }) | undefined;
+    experimentalJsFastPath?: boolean | 'oxc' | undefined;
     cssChildCombinatorReplaceValue?: string | string[] | undefined;
     postcssOptions?: LoadedPostcssOptions | undefined;
     cssOptions?: CssOptions | undefined;
     cssRemoveHoverPseudoClass?: boolean | undefined;
     cssRemoveProperty?: boolean | undefined;
     tailwindcssV4GradientFallback?: boolean | undefined;
-    tailwindcssPatcherOptions?: TailwindCssPatchOptions | undefined;
+    tailwindcssRuntimeOptions?: TailwindCssRuntimeOptions | undefined;
     logLevel?: 'info' | 'warn' | 'error' | 'silent' | undefined;
 }

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

@@ -1,6 +1,6 @@
 import type { CssCalcOptions, CssPreflightOptions, IStyleHandlerOptions, PresetEnvOptions, Px2rpxOptions, Rem2rpxOptions, UniAppXUnsupportedMode, UnitConversionOptions, UnitsToPxOptions, WeappAutoprefixerOptions } from '@weapp-tailwindcss/postcss/types';
-import type { TailwindCssPatchOptions } from 'tailwindcss-patch';
 import type { ICustomAttributes } from '../shared';
+import type { TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types';
 export interface UniAppXComponentLocalStylesOptions {
     enabled?: boolean | undefined;
     onlyWhenStyleIsolationVersion2?: boolean | undefined;
@@ -34,7 +34,7 @@ export interface UserDefinedOptionsImportantPart {
     cssPresetEnv?: PresetEnvOptions | undefined;
     atRules?: IStyleHandlerOptions['atRules'] | undefined;
     autoprefixer?: WeappAutoprefixerOptions | undefined;
-    tailwindcss?: TailwindCssPatchOptions['tailwindcss'] | undefined;
+    tailwindcss?: TailwindCssRuntimeOptions['tailwindcss'] | undefined;
     cssEntries?: string[] | undefined;
     uniAppX?: boolean | UniAppXOptions | undefined;
     uniAppXCssTarget?: IStyleHandlerOptions['uniAppXCssTarget'] | undefined;

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

@@ -1,8 +1,15 @@
+import type { ItemOrItemArray } from '../base';
 import type { AppType } from '../shared';
+export type TransformRule = string | RegExp | ((id: string) => boolean);
+export interface TransformOptions {
+    include?: ItemOrItemArray<TransformRule> | undefined;
+    exclude?: ItemOrItemArray<TransformRule> | undefined;
+}
 export interface UserDefinedOptionsMatcherPart {
     htmlMatcher?: ((name: string) => boolean) | undefined;
     cssMatcher?: ((name: string) => boolean) | undefined;
     jsMatcher?: ((name: string) => boolean) | undefined;
+    transform?: TransformOptions | undefined;
     mainCssChunkMatcher?: ((name: string, appType?: AppType) => boolean) | undefined;
     wxsMatcher?: ((name: string) => boolean) | undefined;
     inlineWxs?: boolean | undefined;

package/dist/uni-app-x/style-asset.d.ts

@@ -6,6 +6,7 @@ type BundleItem = {
 } | OutputAsset | OutputChunk;
 interface HarmonyStyleInjectOptions {
     cssSources?: Iterable<string | undefined> | undefined;
+    styleAssetFiles?: Iterable<string | undefined> | ((file: string) => Iterable<string | undefined>) | undefined;
     excludeComponents?: boolean | undefined;
     mapSources?: Iterable<string | undefined> | undefined;
 }