weapp-tailwindcss 5.0.0-next.9 → 5.0.1

package/dist/bundle-state-CQmxxx0R.mjs

@@ -0,0 +1,413 @@
+import { g as traverse, h as babelParse, o as Parser } from "./precheck-jZvTVXXG.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "node:path";
+import { cleanUrl, ensurePosix } from "@weapp-tailwindcss/shared";
+import { Buffer } from "node:buffer";
+//#region src/bundlers/shared/module-graph.ts
+const QUERY_HASH_RE = /[?#].*$/u;
+const PROTOCOL_RE = /^[a-z][a-z+.-]*:/iu;
+const WINDOWS_ABSOLUTE_RE = /^[a-z]:[\\/]/iu;
+const VIRTUAL_PREFIX = "\0";
+const JS_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+function normalizeOutputPathKey(value) {
+	return path.normalize(value).replace(/\\/g, "/");
+}
+function stripQueryAndHash(specifier) {
+	return specifier.replace(QUERY_HASH_RE, "");
+}
+function isResolvableSpecifier(specifier) {
+	if (!specifier) return false;
+	const normalized = stripQueryAndHash(specifier);
+	if (normalized.startsWith(VIRTUAL_PREFIX)) return false;
+	if (path.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) return true;
+	return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+	if (path.isAbsolute(fileName) || WINDOWS_ABSOLUTE_RE.test(fileName)) return path.normalize(fileName);
+	return path.resolve(outDir, fileName);
+}
+function matchWithExtensions(candidate, hasOutput) {
+	if (hasOutput(candidate)) return candidate;
+	if (!path.extname(candidate)) for (const ext of JS_EXTENSIONS) {
+		const extended = `${candidate}${ext}`;
+		if (hasOutput(extended)) return extended;
+	}
+}
+function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
+	if (!isResolvableSpecifier(specifier)) return;
+	const normalized = stripQueryAndHash(specifier);
+	let candidate;
+	if (path.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) candidate = path.normalize(normalized);
+	else if (normalized.startsWith("/")) candidate = path.resolve(outDir, normalized.slice(1));
+	else candidate = path.resolve(path.dirname(importer), normalized);
+	return matchWithExtensions(candidate, hasOutput);
+}
+//#endregion
+//#region src/bundlers/shared/style-requests.ts
+const SOURCE_STYLE_EXT_RE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+const STYLE_QUERY_RE = /(?:^|&)type=styles?(?:&|$)/;
+const STYLE_LANG_QUERY_RE = /(?:^|&)lang(?:[.=](?:css|scss|sass|less|styl|stylus|pcss|postcss))?(?:&|$)/;
+function stripHash(request) {
+	const hashIndex = request.indexOf("#");
+	return hashIndex === -1 ? request : request.slice(0, hashIndex);
+}
+function stripRequestQuery(request) {
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	return queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+}
+function isSourceStyleRequest(request) {
+	if (typeof request !== "string" || request.length === 0) return false;
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	const pathname = queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+	if (SOURCE_STYLE_EXT_RE.test(pathname)) return true;
+	if (queryIndex === -1) return false;
+	const query = normalized.slice(queryIndex + 1);
+	return STYLE_QUERY_RE.test(query) || STYLE_LANG_QUERY_RE.test(query);
+}
+//#endregion
+//#region src/bundlers/vite/utils.ts
+function slash(p) {
+	return ensurePosix(p);
+}
+const isWindows = process.platform === "win32";
+const cssLangRE = new RegExp(`\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`);
+function isCSSRequest(request) {
+	return cssLangRE.test(request) || isSourceStyleRequest(request);
+}
+function normalizePath(id) {
+	return path.posix.normalize(isWindows ? ensurePosix(id) : id);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+	const inputFileDir = path.dirname(file);
+	const sources = rawMap.sources.map((source) => {
+		const cleanSource = cleanUrl(decodeURIComponent(source));
+		if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`;
+		return normalizePath(path.resolve(inputFileDir, cleanSource));
+	});
+	return {
+		file,
+		mappings: rawMap.mappings,
+		names: rawMap.names,
+		sources,
+		sourcesContent: rawMap.sourcesContent,
+		version: rawMap.version
+	};
+}
+//#endregion
+//#region src/utils/disabled.ts
+function resolvePluginDisabledState(disabled) {
+	if (disabled === true) return { plugin: true };
+	if (disabled === false || disabled == null) return { plugin: false };
+	return { plugin: disabled.plugin ?? false };
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const require = createRequire(import.meta.url);
+function resolvePackageDir(name) {
+	const pkgPath = require.resolve(`${name}/package.json`);
+	return path.dirname(pkgPath);
+}
+//#endregion
+//#region src/bundlers/shared/generated-css-marker.ts
+const BUNDLER_GENERATED_CSS_MARKER_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/i;
+const BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss (?:vite|webpack)-generated-css(?::[^\s*]+)?\s*\*\/\s*/gi;
+function createBundlerGeneratedCssMarker(bundler, file) {
+	return `/*! weapp-tailwindcss ${bundler}-generated-css:${encodeURIComponent(file)} */`;
+}
+function hasBundlerGeneratedCssMarker(source) {
+	return typeof source === "string" && BUNDLER_GENERATED_CSS_MARKER_RE.test(source);
+}
+function stripBundlerGeneratedCssMarkers(source) {
+	return source.replace(BUNDLER_GENERATED_CSS_MARKER_GLOBAL_RE, "");
+}
+//#endregion
+//#region src/bundlers/shared/run-tasks.ts
+async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, factories.length))) {
+	if (factories.length === 0) return [];
+	const results = Array.from({ length: factories.length });
+	const executing = /* @__PURE__ */ new Set();
+	let cursor = 0;
+	const effectiveLimit = Math.max(1, limit);
+	const scheduleNext = () => {
+		if (cursor >= factories.length) return;
+		const currentIndex = cursor++;
+		const factory = factories[currentIndex];
+		if (!factory) return;
+		const wrapped = Promise.resolve(factory()).then((value) => {
+			results[currentIndex] = value;
+		}).finally(() => {
+			executing.delete(wrapped);
+		});
+		executing.add(wrapped);
+	};
+	while (cursor < factories.length && executing.size < effectiveLimit) scheduleNext();
+	while (cursor < factories.length) {
+		await Promise.race(executing);
+		scheduleNext();
+	}
+	await Promise.all(executing);
+	return results;
+}
+function pushConcurrentTaskFactories(queue, factories, limit) {
+	if (factories.length === 0) return;
+	queue.push(runWithConcurrency(factories, limit).then(() => void 0));
+}
+//#endregion
+//#region src/bundlers/vite/bundle-entries.ts
+function readOutputEntry(entry) {
+	if (entry.output.type === "chunk") return entry.output.code;
+	const source = entry.output.source;
+	if (typeof source === "string") return source;
+	if (source instanceof Uint8Array) return Buffer.from(source).toString();
+	const fallbackSource = source;
+	if (fallbackSource == null) return;
+	if (typeof fallbackSource.toString === "function") return fallbackSource.toString();
+}
+function isJavaScriptEntry(entry) {
+	if (entry.output.type === "chunk") return true;
+	return entry.fileName.endsWith(".js");
+}
+function createBundleModuleGraphOptions(outputDir, entries) {
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [id, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(id), entry);
+	const getEntry = (id) => entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+	return {
+		resolve(specifier, importer) {
+			return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => Boolean(getEntry(candidate)));
+		},
+		load(id) {
+			const entry = getEntry(id);
+			if (!entry) return;
+			return readOutputEntry(entry);
+		},
+		filter(id) {
+			return Boolean(getEntry(id));
+		}
+	};
+}
+function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
+	if (!linked) return;
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [entryId, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(entryId), entry);
+	for (const [id, { code }] of Object.entries(linked)) {
+		const entry = entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+		if (!entry) continue;
+		const previous = readOutputEntry(entry);
+		if (previous == null || previous === code) continue;
+		if (entry.output.type === "chunk") entry.output.code = code;
+		else entry.output.source = code;
+		onApplied?.(entry, code);
+		onLinkedUpdate(entry.fileName, previous, code);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/runtime-affecting-signature.ts
+const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+const CSS_WHITESPACE_RE = /\s+/g;
+function createHtmlRuntimeAffectingSignature(source) {
+	try {
+		const parts = [];
+		const parser = new Parser({
+			onattribute(name, value) {
+				parts.push(`a:${name}=${value}`);
+			},
+			oncomment(data) {
+				parts.push(`c:${data}`);
+			},
+			ontext(data) {
+				const value = data.trim();
+				if (value.length > 0) parts.push(`t:${value}`);
+			}
+		}, { xmlMode: true });
+		parser.write(source);
+		parser.end();
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createJsRuntimeAffectingSignature(source) {
+	try {
+		const ast = babelParse(source, {
+			cache: true,
+			cacheKey: "vite-runtime-affecting:unambiguous",
+			plugins: ["jsx", "typescript"],
+			sourceType: "unambiguous"
+		});
+		const parts = [];
+		traverse(ast, {
+			noScope: true,
+			StringLiteral(path) {
+				parts.push(`s:${path.node.value}`);
+			},
+			TemplateElement(path) {
+				parts.push(`t:${path.node.value.raw}`);
+			},
+			JSXText(path) {
+				const value = path.node.value.trim();
+				if (value.length > 0) parts.push(`x:${value}`);
+			}
+		});
+		const comments = ast.comments;
+		if (Array.isArray(comments)) {
+			for (const comment of comments) if (typeof comment?.value === "string" && comment.value.length > 0) parts.push(`c:${comment.value}`);
+		}
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createCssRuntimeAffectingSignature(source) {
+	return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+	if (type === "html") return createHtmlRuntimeAffectingSignature(source);
+	if (type === "js") return createJsRuntimeAffectingSignature(source);
+	if (type === "css") return createCssRuntimeAffectingSignature(source);
+	return source;
+}
+//#endregion
+//#region src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
+	return {
+		iteration: 0,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		linkedByEntry: /* @__PURE__ */ new Map(),
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
+	};
+}
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+function createProcessFiles() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set()
+	};
+}
+function readEntrySource(output) {
+	if (output.type === "chunk") return output.code;
+	return output.source.toString();
+}
+function classifyBundleEntry(file, opts) {
+	if (opts.cssMatcher(file) || isCSSRequest(file)) return "css";
+	if (opts.htmlMatcher(file)) return "html";
+	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
+	return "other";
+}
+function collectJsEntries(fileName, output, outDir, store) {
+	const entry = {
+		fileName,
+		output
+	};
+	if (!isJavaScriptEntry(entry)) return;
+	const absolute = toAbsoluteOutputPath(fileName, outDir);
+	store.set(absolute, entry);
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+	const sourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+	const changedByType = createChangedByType();
+	const runtimeAffectingChangedByType = createChangedByType();
+	const processFiles = createProcessFiles();
+	const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+	const jsEntries = /* @__PURE__ */ new Map();
+	const entries = [];
+	const firstRun = state.linkedByEntry.size === 0;
+	for (const [file, output] of Object.entries(bundle)) {
+		const type = classifyBundleEntry(file, opts);
+		const source = readEntrySource(output);
+		const hash = opts.cache.computeHash(source);
+		sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
+		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
+		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
+		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
+		if (forceAll || firstRun) markProcessFile(type, file, processFiles);
+		else if (type === "html") processFiles.html.add(file);
+		else if (changed && (type === "js" || type === "css")) processFiles[type].add(file);
+		collectJsEntries(file, output, outDir, jsEntries);
+		entries.push({
+			file,
+			output,
+			source,
+			type
+		});
+	}
+	if (!forceAll && !firstRun) for (const changedFile of changedByType.js) {
+		const dependents = state.dependentsByLinkedFile.get(changedFile);
+		if (!dependents) continue;
+		for (const entryFile of dependents) {
+			processFiles.js.add(entryFile);
+			let impacts = linkedImpactsByEntry.get(entryFile);
+			if (!impacts) {
+				impacts = /* @__PURE__ */ new Set();
+				linkedImpactsByEntry.set(entryFile, impacts);
+			}
+			impacts.add(changedFile);
+		}
+	}
+	return {
+		entries,
+		jsEntries,
+		sourceHashByFile,
+		runtimeAffectingSignatureByFile,
+		runtimeAffectingHashByFile,
+		changedByType,
+		runtimeAffectingChangedByType,
+		processFiles,
+		linkedImpactsByEntry
+	};
+}
+function invertLinkedByEntry(linkedByEntry) {
+	const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+	for (const [entryFile, linkedFiles] of linkedByEntry.entries()) for (const linkedFile of linkedFiles) {
+		let dependents = dependentsByLinkedFile.get(linkedFile);
+		if (!dependents) {
+			dependents = /* @__PURE__ */ new Set();
+			dependentsByLinkedFile.set(linkedFile, dependents);
+		}
+		dependents.add(entryFile);
+	}
+	return dependentsByLinkedFile;
+}
+function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
+	const incremental = options.incremental === true;
+	state.iteration += 1;
+	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
+	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
+	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
+	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+//#endregion
+export { stripRequestQuery as _, createBundleModuleGraphOptions as a, toAbsoluteOutputPath as b, hasBundlerGeneratedCssMarker as c, resolvePluginDisabledState as d, cleanUrl as f, isSourceStyleRequest as g, slash as h, applyLinkedResults as i, stripBundlerGeneratedCssMarkers as l, isCSSRequest as m, createBundleBuildState as n, pushConcurrentTaskFactories as o, formatPostcssSourceMap as p, updateBundleBuildState as r, createBundlerGeneratedCssMarker as s, buildBundleSnapshot as t, resolvePackageDir as u, normalizeOutputPathKey as v, resolveOutputSpecifier as y };

package/dist/bundlers/shared/cache.d.ts

@@ -2,15 +2,17 @@ import type { CacheValue, HashMapKey, ICreateCacheReturnType } from '../../cache
 export interface ProcessCachedTaskOptions<TValue extends CacheValue> {
     cache: ICreateCacheReturnType;
     cacheKey: string;
-    hashKey?: HashMapKey;
-    rawSource?: string;
-    hash?: string;
-    readCache?: () => TValue | undefined;
-    applyResult: (value: TValue) => void | Promise<void>;
+    hashKey?: HashMapKey | undefined;
+    rawSource?: string | undefined;
+    hash?: string | undefined;
+    readCache?: (() => TValue | undefined) | undefined;
+    applyResult: (value: TValue, meta: {
+        cacheHit: boolean;
+    }) => void | Promise<void>;
     transform: () => Promise<{
         result: TValue;
-        cacheValue?: CacheValue;
+        cacheValue?: CacheValue | undefined;
     }>;
-    onCacheHit?: () => void;
+    onCacheHit?: (() => void) | undefined;
 }
 export declare function processCachedTask<TValue extends CacheValue>({ cache, cacheKey, hashKey, rawSource, hash, readCache, applyResult, transform, onCacheHit, }: ProcessCachedTaskOptions<TValue>): Promise<void>;

package/dist/bundlers/shared/css-cleanup/at-rules.d.ts

@@ -1,2 +1 @@
-export declare function removeUnsupportedMiniProgramAtRules(css: string): string;
-export declare function removeUnsupportedAtSupports(css: string): string;
+export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, } from '@weapp-tailwindcss/postcss';

package/dist/bundlers/shared/css-cleanup.d.ts

@@ -1,3 +1 @@
-export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules } from './css-cleanup/at-rules';
-export declare function hoistTailwindPreflightBase(css: string): string;
-export declare function finalizeMiniProgramCss(css: string): string;
+export { finalizeMiniProgramCss, hoistTailwindPreflightBase, removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules, } from '@weapp-tailwindcss/postcss';

package/dist/bundlers/shared/css-imports.d.ts

@@ -1,8 +1,8 @@
 import type { AppType } from '../../types';
 export interface ResolveTailwindcssImportOptions {
-    join?: (base: string, subpath: string) => string;
-    appType?: AppType;
-    rootImport?: string;
+    join?: ((base: string, subpath: string) => string) | undefined;
+    appType?: AppType | undefined;
+    rootImport?: string | undefined;
 }
 export declare function resolveTailwindcssImport(specifier: string, pkgDir: string, options?: ResolveTailwindcssImportOptions): string | null;
 export declare function rewriteTailwindcssImportsInCode(code: string, pkgDir: string, options?: ResolveTailwindcssImportOptions): string | undefined;

package/dist/bundlers/shared/generated-css-marker.d.ts

@@ -0,0 +1,3 @@
+export declare function createBundlerGeneratedCssMarker(bundler: 'vite' | 'webpack', file: string): string;
+export declare function hasBundlerGeneratedCssMarker(source: unknown): boolean;
+export declare function stripBundlerGeneratedCssMarkers(source: string): string;

package/dist/bundlers/shared/generator-css/directives.d.ts

@@ -1,13 +1,21 @@
+interface TailwindDirectiveOptions {
+    importFallback?: boolean | undefined;
+}
 export declare function parseImportRequest(params: string): string | undefined;
-export declare function removeTailwindSourceDirectives(rawSource: string): string;
-export declare function hasTailwindSourceDirectives(rawSource: string): boolean;
-export declare function hasTailwindRootDirectives(rawSource: string): boolean;
+export declare function normalizeTailwindSourceForGenerator(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function normalizeTailwindV3CssEntrySource(rawSource: string): string;
+export declare function normalizeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function removeTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): string;
+export declare function hasTailwindSourceDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
+export declare function hasTailwindRootDirectives(rawSource: string, options?: TailwindDirectiveOptions): boolean;
 export declare function hasTailwindApplyDirective(rawSource: string): boolean;
 export declare function resolveCssEntrySource(rawSource: string, base: string, options?: {
     removeConfig?: boolean;
+    importFallback?: boolean;
 }): {
     css: string;
     config: string | undefined;
     configRequest: string | undefined;
     base: string;
 } | undefined;
+export {};

package/dist/bundlers/shared/generator-css/markers.d.ts

@@ -8,7 +8,19 @@ export declare const TAILWIND_BANNER_GLOBAL_RE: RegExp;
 export declare const VITE_MARKER_RE: RegExp;
 export declare function createCssAppend(base: string, extra: string): string;
 export declare function splitTailwindV4GeneratedCss(rawSource: string, rawTailwindCss: string): string | undefined;
+export declare function splitTailwindV4GeneratedCssBySourceOrder(rawSource: string, rawTailwindCss: string): {
+    before: string;
+    after: string;
+} | undefined;
+export declare function splitGeneratorPlaceholderCssBySourceOrder(rawSource: string, rawTailwindCss?: string): {
+    before: string;
+    after: string;
+} | undefined;
 export declare function removeTailwindGeneratedCssByBanner(rawSource: string): string | undefined;
+export declare function splitTailwindGeneratedCssByBanner(rawSource: string, start?: number): {
+    before: string;
+    after: string;
+} | undefined;
 export declare function stripTailwindBanner(css: string): string;
 export declare function stripTailwindBanners(css: string): string;
 export declare function stripGeneratorPlaceholderMarkers(css: string): string;

package/dist/bundlers/shared/generator-css/source-files.d.ts

@@ -1,11 +1,14 @@
+export interface SourceSideCssEntrySource {
+    css: string;
+    config?: string | undefined;
+    configRequest?: string | undefined;
+    base: string;
+    file: string;
+}
 export declare function resolveSourceSideCssEntrySource(file: string, sourceOptions: {
     projectRoot?: string;
     cwd?: string;
+    outputRoot?: string;
 }, resolveOptions?: {
     removeConfig?: boolean;
-}): {
-    css: string;
-    config: string | undefined;
-    configRequest: string | undefined;
-    base: string;
-} | undefined;
+}): SourceSideCssEntrySource | undefined;

package/dist/bundlers/shared/generator-css/source-resolver.d.ts

@@ -1,10 +1,24 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 interface GeneratorSourceRuntimeState {
     twPatcher: InternalUserDefinedOptions['twPatcher'];
 }
+interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+}
+export interface GeneratorSourceMetadata {
+    matchedCssSourceFile?: string | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+export type GeneratorResolvedSource = TailwindResolvedSource & {
+    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
+};
 export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;
-export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource>;
-export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource | import("@/generator").TailwindV3ResolvedSource | undefined>;
+export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<TailwindSourceEntry[] | undefined>;
 export {};

package/dist/bundlers/shared/generator-css/user-layer-order.d.ts

@@ -0,0 +1,10 @@
+export declare function wrapUserLayerComponentsCss(css: string): string;
+export declare function extractMarkedUserLayerComponentsCss(css: string): {
+    layers: string[];
+    rest: string;
+};
+export declare function reorderMarkedUserLayerComponentsCss(css: string): string;
+export declare function mergeMarkedUserLayerComponentsCss(baseCss: string, markedCss: string): {
+    css: string;
+    merged: boolean;
+};

package/dist/bundlers/shared/generator-css.d.ts

@@ -1,9 +1,10 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
-export { hasTailwindSourceDirectives, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
+export { hasTailwindSourceDirectives, normalizeTailwindSourceForGenerator, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
 export { removeTailwindApplyRules, } from './generator-css/legacy-compat';
 export { inheritLegacyUnitConvertedDeclarations, } from './generator-css/legacy-units';
-export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
+export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
 export { resolveGeneratorSource, } from './generator-css/source-resolver';
 export interface GenerateCssByGeneratorOptions {
     opts: InternalUserDefinedOptions;
@@ -16,14 +17,17 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;
+    previousCss?: string | undefined;
 }
 export interface GenerateCssByGeneratorResult {
     css: string;
     target: string;
     source: 'generator';
     dependencies: string[];
+    incremental?: boolean | undefined;
 }
 export declare function isPureLocalCssImportWrapper(css: string): boolean;
 export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/bundlers/shared/hmr-timing.d.ts

@@ -0,0 +1,22 @@
+export interface HmrTimingDetails {
+    emit?: boolean;
+    file?: string;
+    hooks?: Record<string, HmrTimingHookSummary>;
+    metric?: 'hook' | 'total';
+    wallMs?: number;
+}
+export interface HmrTimingHookSummary {
+    count: number;
+    durationMs: number;
+    maxMs: number;
+}
+type HmrTimingBundler = 'vite' | 'webpack' | 'gulp';
+export interface HmrTimingRecorder {
+    emitTotal: (phase?: string) => void;
+    measure: <T>(phase: string, task: () => T | Promise<T>, details?: HmrTimingDetails) => Promise<T>;
+    record: (phase: string, durationMs: number, details?: HmrTimingDetails) => void;
+}
+export declare function shouldEmitHmrTiming(): boolean;
+export declare function emitHmrTiming(bundler: HmrTimingBundler, phase: string, durationMs: number, details?: HmrTimingDetails): void;
+export declare function createHmrTimingRecorder(bundler: HmrTimingBundler): HmrTimingRecorder;
+export {};

package/dist/bundlers/shared/style-requests.d.ts

@@ -0,0 +1,2 @@
+export declare function stripRequestQuery(request: string): string;
+export declare function isSourceStyleRequest(request: string | undefined): boolean;

package/dist/bundlers/vite/bundle-state.d.ts

@@ -31,6 +31,7 @@ export interface BundleBuildState {
     runtimeAffectingHashByFile: Map<string, string>;
     linkedByEntry: Map<string, Set<string>>;
     dependentsByLinkedFile: Map<string, Set<string>>;
+    generatorCandidateSignature?: string | undefined;
 }
 interface UpdateBundleBuildStateOptions {
     incremental?: boolean;