weapp-tailwindcss 5.1.16 → 5.2.0

package/dist/transform-BbaPIji9.js

@@ -0,0 +1,342 @@
+import { n as _defineProperty } from "./object-Bvy6-w9r.js";
+import { g as babelParse, i as analyzeSource, m as replaceWxml, n as generateCode, o as JsTokenUpdater, r as createAttributeMatcher, u as isClassContextLiteralPath } from "./wxml-IBzZSaQC.js";
+import { splitCandidateTokens } from "@tailwindcss-mangle/engine";
+import MagicString from "magic-string";
+import { NodeTypes, parse } from "@vue/compiler-dom";
+//#region src/uni-app-x/component-local-style.ts
+const EXPRESSION_WRAPPER_PREFIX = "(\n";
+const EXPRESSION_WRAPPER_SUFFIX = "\n)";
+const COMPONENT_RE = /(?:^|[/\\])components(?:[/\\].+)?\.(?:uvue|nvue)$/;
+const PAGE_RE = /(?:^|[/\\])pages(?:[/\\].+)?\.(?:uvue|nvue)$/;
+function createStableHash(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function extractLiteralValue(path) {
+	if (path.isStringLiteral()) return {
+		literal: path.node.value,
+		offset: 1
+	};
+	return {
+		literal: typeof path.node.value === "string" ? path.node.value : path.node.value.raw,
+		offset: 0
+	};
+}
+function createAlias(fileId, utility, index) {
+	return `wtu-${createStableHash(`${fileId}:${utility}`)}-${index.toString(36)}`;
+}
+function isRuntimeCandidate(candidate, runtimeSet) {
+	if (!runtimeSet || runtimeSet.size === 0) return false;
+	return runtimeSet.has(candidate) || runtimeSet.has(replaceWxml(candidate));
+}
+function hasTopLevelVariant(candidate) {
+	let bracketDepth = 0;
+	let parenthesisDepth = 0;
+	let quote = "";
+	let escaped = false;
+	for (const char of candidate) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "[") {
+			bracketDepth += 1;
+			continue;
+		}
+		if (char === "]") {
+			bracketDepth = Math.max(0, bracketDepth - 1);
+			continue;
+		}
+		if (char === "(") {
+			parenthesisDepth += 1;
+			continue;
+		}
+		if (char === ")") {
+			parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+			continue;
+		}
+		if (char === ":" && bracketDepth === 0 && parenthesisDepth === 0) return true;
+	}
+	return false;
+}
+function shouldEnableComponentLocalStyle(id) {
+	return COMPONENT_RE.test(id);
+}
+function shouldEnablePageLocalStyle(id) {
+	return PAGE_RE.test(id);
+}
+var UniAppXComponentLocalStyleCollector = class {
+	constructor(fileId, runtimeSet) {
+		this.fileId = fileId;
+		this.runtimeSet = runtimeSet;
+		_defineProperty(this, "aliasByUtility", /* @__PURE__ */ new Map());
+		_defineProperty(this, "aliasByLookup", /* @__PURE__ */ new Map());
+	}
+	ensureAlias(utility) {
+		const cached = this.aliasByUtility.get(utility);
+		if (cached) return cached;
+		const alias = createAlias(this.fileId, utility, this.aliasByUtility.size);
+		this.aliasByUtility.set(utility, alias);
+		this.aliasByLookup.set(utility, alias);
+		this.aliasByLookup.set(replaceWxml(utility), alias);
+		return alias;
+	}
+	rewriteLiteral(literal) {
+		const candidates = splitCandidateTokens(literal);
+		if (candidates.length === 0) return literal;
+		let rewritten = literal;
+		for (const candidate of candidates) {
+			if (!isRuntimeCandidate(candidate, this.runtimeSet)) continue;
+			rewritten = rewritten.replace(candidate, hasTopLevelVariant(candidate) ? replaceWxml(candidate) : this.ensureAlias(candidate));
+		}
+		return rewritten;
+	}
+	collectAndRewriteStaticClass(literal) {
+		return this.rewriteLiteral(literal);
+	}
+	collectRuntimeClasses(rawSource, options = {}) {
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = analyzeSource(babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			for (const path of analysis.targetPaths) {
+				const { literal } = extractLiteralValue(path);
+				const candidates = splitCandidateTokens(literal);
+				const classContext = options.wrapExpression || isClassContextLiteralPath(path);
+				for (const candidate of candidates) {
+					if (!candidate || !classContext && !isRuntimeCandidate(candidate, this.runtimeSet)) continue;
+					if (isRuntimeCandidate(candidate, this.runtimeSet) && !hasTopLevelVariant(candidate)) this.ensureAlias(candidate);
+				}
+			}
+		} catch {}
+	}
+	rewriteTransformedCode(rawSource, options = {}) {
+		if (this.aliasByLookup.size === 0) return rawSource;
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = analyzeSource(babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			if (analysis.targetPaths.length === 0) return rawSource;
+			const updater = new JsTokenUpdater();
+			for (const path of analysis.targetPaths) {
+				const { literal, offset } = extractLiteralValue(path);
+				const candidates = splitCandidateTokens(literal);
+				if (candidates.length === 0) continue;
+				let rewritten = literal;
+				let mutated = false;
+				for (const candidate of candidates) {
+					const alias = this.aliasByLookup.get(candidate);
+					if (!alias) continue;
+					const replaced = rewritten.replace(candidate, alias);
+					if (replaced !== rewritten) {
+						rewritten = replaced;
+						mutated = true;
+					}
+				}
+				if (!mutated || typeof path.node.start !== "number" || typeof path.node.end !== "number") continue;
+				updater.addToken({
+					start: path.node.start + offset,
+					end: path.node.end - offset,
+					value: rewritten,
+					path
+				});
+			}
+			if (updater.length === 0) return rawSource;
+			const ms = new MagicString(wrapped);
+			updater.updateMagicString(ms);
+			if (options.wrapExpression) {
+				ms.remove(0, 2);
+				ms.remove(wrapped.length - 2, wrapped.length);
+			}
+			return ms.toString();
+		} catch {
+			return rawSource;
+		}
+	}
+	hasStyles() {
+		return this.aliasByUtility.size > 0;
+	}
+	toStyleBlock() {
+		if (!this.hasStyles()) return "";
+		const lines = ["<style scoped>"];
+		for (const [utility, alias] of this.aliasByUtility) {
+			lines.push(`.${alias} {`);
+			lines.push(`  @apply ${utility};`);
+			lines.push("}");
+		}
+		lines.push("</style>");
+		return `${lines.join("\n")}\n`;
+	}
+};
+//#endregion
+//#region src/uni-app-x/transform.ts
+function traverse(node, visitor) {
+	visitor(node);
+	if (Array.isArray(node.children)) {
+		for (const child of node.children) if (child && typeof child === "object" && "type" in child) traverse(child, visitor);
+	}
+}
+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, replaceWxml(content ?? ""));
+}
+function updateStaticAttributeWithLocalStyle(ms, prop, offset, collector, 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, collector.collectAndRewriteStaticClass(content ?? ""));
+}
+function updateDirectiveExpression(ms, prop, offset, jsHandler, runtimeSet) {
+	if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = offset + prop.exp.loc.start.offset;
+	const end = offset + prop.exp.loc.end.offset;
+	if (start >= end) return;
+	const generated = generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, generated);
+}
+function updateDirectiveExpressionWithLocalStyle(ms, prop, offset, jsHandler, collector, runtimeSet) {
+	if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = offset + prop.exp.loc.start.offset;
+	const end = offset + prop.exp.loc.end.offset;
+	if (start >= end) return;
+	collector.collectRuntimeClasses(expression, { wrapExpression: true });
+	const generated = generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, collector.rewriteTransformedCode(generated, { wrapExpression: true }));
+}
+function shouldEnableLocalStyle(id, options) {
+	if (options.enableComponentLocalStyle && shouldEnableComponentLocalStyle(id)) return true;
+	if (options.enablePageLocalStyle && shouldEnablePageLocalStyle(id)) return true;
+	return false;
+}
+function shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute) {
+	const lowerName = attrName.toLowerCase();
+	const shouldHandleDefault = !disabledDefaultTemplateHandler && lowerName === "class";
+	const shouldHandleCustom = matchCustomAttribute?.(tag, attrName) ?? false;
+	return {
+		shouldHandleDefault,
+		shouldHandleCustom,
+		shouldHandle: shouldHandleDefault || shouldHandleCustom
+	};
+}
+const defaultCreateJsHandlerOptions = { babelParserOptions: { plugins: ["typescript"] } };
+const UVUE_NVUE_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+const SFC_BLOCK_RE = /<(template|script)\b([^>]*)>([\s\S]*?)<\/\1>/gi;
+const SCRIPT_SETUP_RE = /(?:^|\s)setup(?:\s|=|$)/;
+function parseSfc(code) {
+	const descriptor = { errors: [] };
+	for (const match of code.matchAll(SFC_BLOCK_RE)) {
+		const type = match[1];
+		const attrs = match[2] ?? "";
+		const content = match[3] ?? "";
+		const full = match[0];
+		const contentStart = (match.index ?? 0) + full.indexOf(">") + 1;
+		const block = {
+			content,
+			start: contentStart,
+			end: contentStart + content.length,
+			attrs
+		};
+		if (type === "template" && !descriptor.template) {
+			try {
+				descriptor.template = {
+					...block,
+					ast: parse(content)
+				};
+			} catch (error) {
+				descriptor.errors.push(error);
+				descriptor.template = block;
+			}
+			continue;
+		}
+		if (type === "script") if (SCRIPT_SETUP_RE.test(attrs)) descriptor.scriptSetup ?? (descriptor.scriptSetup = block);
+		else descriptor.script ?? (descriptor.script = block);
+	}
+	return descriptor;
+}
+function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
+	if (!UVUE_NVUE_RE.test(id)) return;
+	const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
+	const matchCustomAttribute = createAttributeMatcher(customAttributesEntities);
+	const ms = new MagicString(code);
+	const descriptor = parseSfc(code);
+	const localStyleCollector = shouldEnableLocalStyle(id, options) ? new UniAppXComponentLocalStyleCollector(id, runtimeSet) : void 0;
+	if (descriptor.errors.length === 0) {
+		if (descriptor.template?.ast) {
+			const templateOffset = descriptor.template.start;
+			traverse(descriptor.template.ast, (node) => {
+				if (node.type !== NodeTypes.ELEMENT) return;
+				const tag = node.tag;
+				for (const prop of node.props) if (prop.type === NodeTypes.ATTRIBUTE) {
+					const { shouldHandle, shouldHandleDefault } = shouldHandleAttribute(tag, prop.name, disabledDefaultTemplateHandler, matchCustomAttribute);
+					if (!shouldHandle) continue;
+					if (shouldHandleDefault && localStyleCollector) updateStaticAttributeWithLocalStyle(ms, prop, templateOffset, localStyleCollector);
+					else updateStaticAttribute(ms, prop, templateOffset);
+					if (shouldHandleDefault) continue;
+				} else if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic) {
+					const attrName = prop.arg.content;
+					const { shouldHandle } = shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute);
+					if (!shouldHandle) continue;
+					if (attrName.toLowerCase() === "class" && localStyleCollector) updateDirectiveExpressionWithLocalStyle(ms, prop, templateOffset, jsHandler, localStyleCollector, runtimeSet);
+					else updateDirectiveExpression(ms, prop, templateOffset, jsHandler, runtimeSet);
+				}
+			});
+		}
+		if (descriptor.script) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.script.content);
+			const { code } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.script.start, descriptor.script.end, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (descriptor.scriptSetup) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.scriptSetup.content);
+			const { code } = jsHandler(descriptor.scriptSetup.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.scriptSetup.start, descriptor.scriptSetup.end, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (localStyleCollector?.hasStyles()) ms.append(`\n${localStyleCollector.toStyleBlock()}`);
+	}
+	const result = {
+		code: ms.toString(),
+		map: null
+	};
+	Object.defineProperty(result, "map", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ms.generateMap();
+		}
+	});
+	return result;
+}
+//#endregion
+export { transformUVue };

package/dist/typedoc.export.d.ts

@@ -1,4 +1,4 @@
-export type { WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult, WeappTailwindcssGenerator, WeappTailwindcssGeneratorTarget, WeappTailwindcssPostcssPluginOptions, } from './index';
-export type { WeappTailwindcssStyleInjectorOptions } from './types';
-export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindV4Options, } from './types/typedoc-tailwindcss-runtime';
-export type { UserDefinedOptions } from './types/user-defined-options';
+export type { WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult, WeappTailwindcssGenerator, WeappTailwindcssGeneratorTarget, WeappTailwindcssPostcssPluginOptions, } from './index.js';
+export type { WeappTailwindcssStyleInjectorOptions } from './types/index.js';
+export type { ApplyOptions, CacheOptions, ExtractOptions, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindV4Options, } from './types/typedoc-tailwindcss-runtime.js';
+export type { UserDefinedOptions } from './types/user-defined-options/index.js';

package/dist/types/index.d.ts

@@ -1,15 +1,15 @@
 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 { 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';
-import type { LengthUnitsRuntimeOptions, TailwindContentTokenReport, TailwindcssExtractOptions, TailwindcssExtractResult, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindPackageInfo } from '../tailwindcss/runtime-types';
+import type { ICreateCacheReturnType } from '../cache/index.js';
+import type { ItemOrItemArray } from './base.js';
+import type { AppType, IArbitraryValues, ICustomAttributesEntities } from './shared.js';
+import type { UniAppXComponentLocalStylesOptions, UniAppXOptions as UniAppXUserDefinedOptions, UserDefinedOptions } from './user-defined-options/index.js';
+import type { LengthUnitsRuntimeOptions, TailwindContentTokenReport, TailwindcssExtractOptions, TailwindcssExtractResult, TailwindCssOptions, TailwindCssRuntimeOptions, TailwindPackageInfo } from '../tailwindcss/runtime-types.js';
 export type { TailwindCssOptions, TailwindCssRuntimeOptions, UniAppXComponentLocalStylesOptions, UniAppXUserDefinedOptions, UserDefinedOptions, };
-export type { AppType, IArbitraryValues, ICustomAttributes, ICustomAttributesEntities, IUnocssCompatibilityOptions } from './shared';
+export type { AppType, IArbitraryValues, ICustomAttributes, ICustomAttributesEntities, IUnocssCompatibilityOptions } from './shared.js';
 export type { CssPreflightOptions, IStyleHandlerOptions, ItemOrItemArray };
-export type { WeappTailwindcssStyleInjectorOptions } from '../style-injector/internal';
+export type { WeappTailwindcssStyleInjectorOptions } from '../style-injector/internal.js';
 export type RequiredDefined<T> = {
     [K in keyof T]-?: Exclude<T[K], undefined>;
 };

package/dist/types/shared.d.ts

@@ -1,4 +1,4 @@
-import type { ItemOrItemArray } from './base';
+import type { ItemOrItemArray } from './base.js';
 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>][];

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

@@ -1,7 +1,7 @@
 import type { PackageResolvingOptions } from 'local-pkg';
-import type { TailwindSourceEntry as SourceEntry } from '../tailwindcss/source-scan';
-import type { TailwindV4SourceOptions } from '../tailwindcss/v4-engine';
-import type { LengthUnitsRuntimeOptions } from '../tailwindcss/runtime-types';
+import type { TailwindSourceEntry as SourceEntry } from '../tailwindcss/source-scan.js';
+import type { TailwindV4SourceOptions } from '../tailwindcss/v4-engine/index.js';
+import type { LengthUnitsRuntimeOptions } from '../tailwindcss/runtime-types.js';
 type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
 export type CacheStrategy = 'merge' | 'overwrite';
 export type CacheDriver = 'file' | 'memory' | 'noop';

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

@@ -1,10 +1,10 @@
 import type { ParserOptions } from '@babel/parser';
 import type { CssOptions, LoadedPostcssOptions } from '@weapp-tailwindcss/postcss/types';
-import type { ICreateCacheReturnType } from '../../cache';
-import type { WeappTailwindcssGeneratorUserOptions } from '../../generator';
-import type { WeappTailwindcssStyleInjectorUserOptions } from '../../style-injector/internal';
-import type { AppType, IArbitraryValues, IUnocssCompatibilityOptions } from '../shared';
-import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types';
+import type { ICreateCacheReturnType } from '../../cache/index.js';
+import type { WeappTailwindcssGeneratorUserOptions } from '../../generator/index.js';
+import type { WeappTailwindcssStyleInjectorUserOptions } from '../../style-injector/internal.js';
+import type { AppType, IArbitraryValues, IUnocssCompatibilityOptions } from '../shared.js';
+import type { LengthUnitsRuntimeOptions, TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types.js';
 export interface CssSourceTraceOptions {
     root?: string | 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 { ICustomAttributes } from '../shared';
-import type { TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types';
+import type { ICustomAttributes } from '../shared.js';
+import type { TailwindCssRuntimeOptions } from '../../tailwindcss/runtime-types.js';
 export interface UniAppXComponentLocalStylesOptions {
     enabled?: boolean | undefined;
     onlyWhenStyleIsolationVersion2?: boolean | undefined;

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

@@ -1,11 +1,11 @@
-import type { UserDefinedOptionsGeneralPart } from './general';
-import type { UserDefinedOptionsImportantPart } from './important';
-import type { UserDefinedOptionsLifecyclePart } from './lifecycle';
-import type { UserDefinedOptionsMatcherPart } from './matcher';
-export type { UserDefinedOptionsGeneralPart, } from './general';
-export type { UniAppXComponentLocalStylesOptions, UniAppXOptions, } from './important';
-export type { UserDefinedOptionsImportantPart, } from './important';
-export type { UserDefinedOptionsLifecyclePart, } from './lifecycle';
-export type { UserDefinedOptionsMatcherPart, } from './matcher';
+import type { UserDefinedOptionsGeneralPart } from './general.js';
+import type { UserDefinedOptionsImportantPart } from './important.js';
+import type { UserDefinedOptionsLifecyclePart } from './lifecycle.js';
+import type { UserDefinedOptionsMatcherPart } from './matcher.js';
+export type { UserDefinedOptionsGeneralPart, } from './general.js';
+export type { UniAppXComponentLocalStylesOptions, UniAppXOptions, } from './important.js';
+export type { UserDefinedOptionsImportantPart, } from './important.js';
+export type { UserDefinedOptionsLifecyclePart, } from './lifecycle.js';
+export type { UserDefinedOptionsMatcherPart, } from './matcher.js';
 export interface UserDefinedOptions extends UserDefinedOptionsGeneralPart, UserDefinedOptionsImportantPart, UserDefinedOptionsLifecyclePart, UserDefinedOptionsMatcherPart {
 }

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

@@ -1,5 +1,5 @@
-import type { ItemOrItemArray } from '../base';
-import type { AppType } from '../shared';
+import type { ItemOrItemArray } from '../base.js';
+import type { AppType } from '../shared.js';
 export type TransformRule = string | RegExp | ((id: string) => boolean);
 export interface TransformOptions {
     include?: ItemOrItemArray<TransformRule> | undefined;

package/dist/types.d.ts

@@ -1 +1 @@
-export * from './types/index'
+export * from './types/index.js'

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/uni-app-x/harmony.d.ts

@@ -1 +1,2 @@
 export declare function isUniAppXHarmonyOutDir(outDir: string | undefined): boolean;
+export declare function isUniAppXNativeAppOutDir(outDir: string | undefined): boolean;

package/dist/uni-app-x/index.d.ts

@@ -1,2 +1,2 @@
-export { transformUVue } from './transform';
-export { createUniAppXAssetTask, createUniAppXPlugins } from './vite';
+export { transformUVue } from './transform.js';
+export { createUniAppXAssetTask, createUniAppXPlugins } from './vite.js';

package/dist/uni-app-x/options.d.ts

@@ -1,4 +1,4 @@
-import type { UserDefinedOptions } from '../types';
+import type { UserDefinedOptions } from '../types/index.js';
 export interface ResolvedUniAppXComponentLocalStylesOptions {
     enabled: boolean;
     onlyWhenStyleIsolationVersion2: boolean;

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

@@ -0,0 +1 @@
+export declare function expandUniAppXHarmonyApplyStyles(source: string, generatedCss: string): string;

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

@@ -13,4 +13,7 @@ export declare function createStyleValueFromApplySources(sources: string[], util
 export declare function collectUniAppXHarmonyApplyStyleSourcesFromSource(source: string, sourceId?: string): string[];
 export declare function collectUniAppXHarmonyApplyUtilitiesFromSources(sources: Iterable<string>): Set<string>;
 export declare function createMergedStyleValue(code: string, localStyle: StyleValue | undefined, appStyle: StyleValue): StyleValue | undefined;
+export declare function createMergedStyleValues(code: string, localStyles: StyleValue[], appStyle: StyleValue): {
+    [x: string]: Record<string, StyleDeclarations>;
+}[] | undefined;
 export {};

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

@@ -1,6 +1,7 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import { collectUniAppXHarmonyApplyStyleSourcesFromSource, collectUniAppXHarmonyApplyUtilitiesFromSources } from './style-asset/style-value';
-export declare const UNI_APP_X_STYLE_PLACEHOLDER_VERSION = "uni-app-x-style-placeholder-v2";
+import { expandUniAppXHarmonyApplyStyles } from './style-asset/harmony-apply.js';
+import { collectUniAppXHarmonyApplyStyleSourcesFromSource, collectUniAppXHarmonyApplyUtilitiesFromSources } from './style-asset/style-value.js';
+export declare const UNI_APP_X_STYLE_PLACEHOLDER_VERSION = "uni-app-x-style-placeholder-v3";
 type BundleItem = {
     type: string;
 } | OutputAsset | OutputChunk;
@@ -10,11 +11,11 @@ interface HarmonyStyleInjectOptions {
     excludeComponents?: boolean | undefined;
     mapSources?: Iterable<string | undefined> | undefined;
 }
-export { collectUniAppXHarmonyApplyStyleSourcesFromSource, collectUniAppXHarmonyApplyUtilitiesFromSources, };
+export { collectUniAppXHarmonyApplyStyleSourcesFromSource, collectUniAppXHarmonyApplyUtilitiesFromSources, expandUniAppXHarmonyApplyStyles, };
 export declare function createUniAppXHarmonyApplyGeneratorSource(applyStyleSources: string[], _applyUtilities: Iterable<string>): string;
 export declare function collectUniAppXHarmonyApplyUtilities(bundle: Record<string, BundleItem>): Set<string>;
 export declare function collectUniAppXHarmonyApplyStyleSources(bundle: Record<string, BundleItem>): string[];
-export declare function injectUniAppXStylePlaceholder(file: string, code: string, getAssetSource?: (file: string) => string | undefined): string;
+export declare function injectUniAppXStylePlaceholder(file: string, code: string, getAssetSource?: (file: string) => string | undefined, cssSources?: Iterable<string | undefined>): string;
 export declare function injectUniAppXHarmonyGlobalStyles(file: string, code: string, getBundleSource?: (file: string) => string | undefined, options?: HarmonyStyleInjectOptions): string;
 export declare function injectUniAppXHarmonyBundleStyles(bundle: Record<string, BundleItem>, options?: HarmonyStyleInjectOptions): boolean;
 export declare function isUniAppXHarmonyBundle(bundle: Record<string, BundleItem>): boolean;

package/dist/uni-app-x/transform.d.ts

@@ -1,5 +1,5 @@
 import type { TransformResult } from 'vite';
-import type { ICustomAttributesEntities, JsHandler } from '../types';
+import type { ICustomAttributesEntities, JsHandler } from '../types/index.js';
 interface TransformUVueOptions {
     customAttributesEntities?: ICustomAttributesEntities;
     disabledDefaultTemplateHandler?: boolean;

package/dist/uni-app-x/vite/harmony-apply.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedConfig } from 'vite';
+interface HarmonyApplyHookContext {
+    addWatchFile?: (id: string) => void;
+}
+interface CreateUniAppXHarmonyApplyExpanderOptions {
+    generateCss?: ((id: string, code: string, hookContext?: HarmonyApplyHookContext & {
+        transient?: boolean;
+    }) => Promise<string | undefined> | string | undefined) | undefined;
+    getResolvedConfig: () => ResolvedConfig | undefined;
+    isHarmonyBuildTarget: () => boolean;
+    transformCss: (css: string, id: string) => Promise<string>;
+}
+export declare function createUniAppXHarmonyApplyExpander(options: CreateUniAppXHarmonyApplyExpanderOptions): {
+    expandStyles: (code: string, id: string, hookContext: HarmonyApplyHookContext) => Promise<string>;
+    rememberSource: (code: string, id: string) => void;
+    styleSources: Set<string>;
+    utilities: Set<string>;
+};
+export {};

package/dist/uni-app-x/vite/native-target.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConfig } from 'vite';
+export declare function createUniAppXNativeBuildTargetResolver(getResolvedConfig: () => ResolvedConfig | undefined): (id?: string) => boolean;

package/dist/uni-app-x/vite.d.ts

@@ -1,7 +1,7 @@
 import type { OutputAsset } from 'rollup';
 import type { Plugin, ResolvedConfig } from 'vite';
-import type { ICreateCacheReturnType } from '../cache';
-import type { AppType, CreateJsHandlerOptions, ICustomAttributesEntities, InternalUserDefinedOptions, JsHandler, LinkedJsModuleResult } from '../types';
+import type { ICreateCacheReturnType } from '../cache/index.js';
+import type { AppType, CreateJsHandlerOptions, ICustomAttributesEntities, InternalUserDefinedOptions, JsHandler, LinkedJsModuleResult } from '../types/index.js';
 interface UniAppXRuntimeState {
     readyPromise: Promise<unknown>;
 }
@@ -14,6 +14,7 @@ interface CreateUniAppXPluginsOptions {
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     generateCss?: ((id: string, code: string, hookContext?: {
         addWatchFile?: (id: string) => void;
+        transient?: boolean;
     }) => Promise<string | undefined> | string | undefined) | undefined;
     jsHandler: JsHandler;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
@@ -36,6 +37,8 @@ interface CreateUniAppXAssetTaskOptions {
     applyLinkedResults: ApplyLinkedResults;
     uniAppX?: InternalUserDefinedOptions['uniAppX'];
     getAssetSource?: (file: string) => string | undefined;
+    getCssSources?: () => Iterable<string | undefined>;
+    injectStylePlaceholder?: boolean;
 }
 export declare function createUniAppXAssetTask(file: string, originalSource: OutputAsset, outDir: string, options: CreateUniAppXAssetTaskOptions): () => Promise<void>;
 export {};

package/dist/unocss/index.d.ts

@@ -1,2 +1,2 @@
-import type { IArbitraryValues, UserDefinedOptions } from '../types';
+import type { IArbitraryValues, UserDefinedOptions } from '../types/index.js';
 export declare function resolveUnocssBareArbitraryValues(arbitraryValues: IArbitraryValues | undefined, unocss: UserDefinedOptions['unocss']): IArbitraryValues;

package/dist/utils/disabled.d.ts

@@ -1,4 +1,4 @@
-import type { UserDefinedOptions } from '../types';
+import type { UserDefinedOptions } from '../types/index.js';
 export interface ResolvedPluginDisabledState {
     plugin: boolean;
 }

package/dist/utils/index.d.ts

@@ -1,7 +1,7 @@
-import type { InternalUserDefinedOptions } from '../types';
+import type { InternalUserDefinedOptions } from '../types/index.js';
 import { defu, defuOverrideArray, groupBy, isMap, isRegexp, noop, regExpTest, removeExt } from '@weapp-tailwindcss/shared';
-export * from './hbuilderx';
-export * from './uni-platform';
+export * from './hbuilderx.js';
+export * from './uni-platform.js';
 export { defu, defuOverrideArray, groupBy, isMap, isRegexp, noop, regExpTest, removeExt, };
 export type EntryGroup = 'css' | 'html' | 'js' | 'other';
 export declare function getGroupedEntries<T>(entries: [string, T][], options: InternalUserDefinedOptions): Record<EntryGroup, [string, T][]>;