weapp-tailwindcss 5.0.11 → 5.0.13

package/dist/{bundle-state-BwtEqxvU.js → bundle-state-CKWeTEhv.js}

@@ -1,10 +1,10 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_precheck = require("./precheck-CY9oaH49.js");
-let node_module = require("node:module");
+const require_precheck = require("./precheck-B0Z8yW7E.js");
 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_module = require("node:module");
 let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
 let node_buffer = require("node:buffer");
 //#region src/bundlers/shared/module-graph.ts
@@ -150,38 +150,6 @@ function parseBundlerGeneratedCssMarkerBlocks(source) {
 	return blocks;
 }
 //#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;
@@ -512,12 +480,6 @@ Object.defineProperty(exports, "parseBundlerGeneratedCssMarkerBlocks", {
 		return parseBundlerGeneratedCssMarkerBlocks;
 	}
 });
-Object.defineProperty(exports, "pushConcurrentTaskFactories", {
-	enumerable: true,
-	get: function() {
-		return pushConcurrentTaskFactories;
-	}
-});
 Object.defineProperty(exports, "resolveOutputSpecifier", {
 	enumerable: true,
 	get: function() {

package/dist/{bundle-state-CXzPknlT.mjs → bundle-state-zQ2MrDdi.mjs}

@@ -1,4 +1,4 @@
-import { h as traverse, m as babelParse, o as Parser } from "./precheck-BpHxsWRd.mjs";
+import { h as traverse, m as babelParse, o as Parser } from "./precheck-CRI90iL1.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
@@ -147,38 +147,6 @@ function parseBundlerGeneratedCssMarkerBlocks(source) {
 	return blocks;
 }
 //#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;
@@ -431,4 +399,4 @@ function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
 	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
 }
 //#endregion
-export { toAbsoluteOutputPath as C, resolveOutputSpecifier as S, normalizePath as _, applyLinkedResults as a, stripRequestQuery as b, createBundlerGeneratedCssMarker as c, stripBundlerGeneratedCssMarkers as d, resolvePackageDir as f, isCSSRequest as g, formatPostcssSourceMap as h, createRuntimeAffectingSourceSignature as i, hasBundlerGeneratedCssMarker as l, cleanUrl as m, createBundleBuildState as n, createBundleModuleGraphOptions as o, resolvePluginDisabledState as p, updateBundleBuildState as r, pushConcurrentTaskFactories as s, buildBundleSnapshot as t, parseBundlerGeneratedCssMarkerBlocks as u, slash as v, normalizeOutputPathKey as x, isSourceStyleRequest as y };
+export { toAbsoluteOutputPath as S, slash as _, applyLinkedResults as a, normalizeOutputPathKey as b, hasBundlerGeneratedCssMarker as c, resolvePackageDir as d, resolvePluginDisabledState as f, normalizePath as g, isCSSRequest as h, createRuntimeAffectingSourceSignature as i, parseBundlerGeneratedCssMarkerBlocks as l, formatPostcssSourceMap as m, createBundleBuildState as n, createBundleModuleGraphOptions as o, cleanUrl as p, updateBundleBuildState as r, createBundlerGeneratedCssMarker as s, buildBundleSnapshot as t, stripBundlerGeneratedCssMarkers as u, isSourceStyleRequest as v, resolveOutputSpecifier as x, stripRequestQuery as y };

package/dist/bundlers/gulp/vinyl-transform.d.ts

@@ -1,3 +1,3 @@
 import type File from 'vinyl';
 import stream from 'node:stream';
-export declare function createVinylTransform(phase: string, handler: (file: File) => Promise<void>): stream.Transform;
+export declare function createVinylTransform(phase: string, handler: (file: File) => Promise<void>, getTimingDetails?: ((file: File) => Record<string, unknown> | undefined) | undefined): stream.Transform;

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

@@ -5,6 +5,7 @@ import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare function finalizeMiniProgramGeneratorCss(css: string, target: string, majorVersion: number | undefined, cssPreflight: InternalUserDefinedOptions['cssPreflight'], options?: {
     injectPreflight?: boolean;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
 }): string;
 export declare function shouldInjectMiniProgramPreflightForGeneratorCss(opts: InternalUserDefinedOptions, options: {
     cssHandlerOptions: IStyleHandlerOptions;
@@ -15,9 +16,13 @@ export declare function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime: Set<
     currentCssCandidates?: string[] | undefined;
     cssHandlerOptions: IStyleHandlerOptions;
     isolateCssSource: boolean;
+    majorVersion?: number | undefined;
     matchedCssSourceFile: boolean;
 }): Set<string>;
-export declare function shouldIsolateScopedCssSource(source: GeneratorResolvedSource, sourceEntries: TailwindSourceEntry[] | undefined): boolean;
+export declare function shouldIsolateScopedCssSource(majorVersion: number | undefined, source: GeneratorResolvedSource, sourceEntries: TailwindSourceEntry[] | undefined, options: {
+    cssHandlerOptions?: IStyleHandlerOptions | undefined;
+    target: string;
+}): boolean;
 export declare function shouldIsolateCurrentTailwindV4CssCandidates(majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
@@ -39,7 +44,7 @@ export declare function splitRawSourceByGeneratedCssOrder(rawSource: string, raw
     before: string;
     after: string;
 } | undefined;
-export declare function shouldUseGeneratorForCurrentCss(majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
+export declare function shouldUseGeneratorForCurrentCss(_majorVersion: number | undefined, cssHandlerOptions: IStyleHandlerOptions, options: {
     hasGeneratedCss: boolean;
     hasGeneratedMarkers: boolean;
     hasSourceDirectives: boolean;

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

@@ -3,6 +3,7 @@ export interface SourceSideCssEntryOptions {
     cwd?: string | undefined;
     outputRoot?: string | undefined;
     sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
     cssSources?: Array<{
         file?: string | undefined;
     }> | undefined;

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

@@ -0,0 +1,3 @@
+export declare function createTailwindV4ApplyReferenceSource(css: string, sourceOptions: {
+    packageName?: string;
+}): string;

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

@@ -0,0 +1,7 @@
+export declare function resolveExistingConfigPath(config: string | undefined, configRequest: string | undefined, file: string, sourceOptions: {
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    config?: string | undefined;
+    sourceFile?: string | undefined;
+    outputRoot?: string | undefined;
+}): string | undefined;

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

@@ -0,0 +1,4 @@
+import type { SourceStyleMatchOptions } from './types';
+export declare function normalizeCssSourceForCompare(css: string): string;
+export declare function getOutputFileStem(file: string): string;
+export declare function scoreTailwindV4CssSourceFileMatch(file: string, cssSourceFile: string, sourceOptions: SourceStyleMatchOptions): number;

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

@@ -0,0 +1,15 @@
+import type { SourceSideCssEntrySource } from '../source-files';
+import type { TailwindResolvedSource } from '../../../../generator';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+export interface GeneratorSourceMetadata {
+    isolateCssSource?: boolean | undefined;
+    matchedCssSourceFile?: string | undefined;
+    sourceEntries?: TailwindSourceEntry[] | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+export type GeneratorResolvedSource = TailwindResolvedSource & {
+    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
+};
+export declare function withGeneratorSourceMetadata(source: TailwindResolvedSource, metadata: GeneratorSourceMetadata): GeneratorResolvedSource;
+export declare function withMatchedSourceSideMetadata(source: TailwindResolvedSource, resolvedEntrySource: SourceSideCssEntrySource): import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource;

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

@@ -0,0 +1,12 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4CssSource } from './types';
+export declare function resolvePostcssFromOption(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolvePostcssSourceFile(cssHandlerOptions: IStyleHandlerOptions): string | undefined;
+export declare function resolveCssHandlerSourceOptions(cssHandlerOptions: IStyleHandlerOptions): {
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+    sourceCss?: string | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+    cssEntries?: string[] | undefined;
+} | undefined;
+export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;

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

@@ -0,0 +1,22 @@
+import type { SourceSideCssEntryOptions } from '../source-files';
+import type { resolveTailwindV4SourceOptionsFromPatcher } from '../../../../generator';
+import type { TailwindSourceEntry } from '../../../../tailwindcss/source-scan';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export interface GeneratorSourceRuntimeState {
+    twPatcher: InternalUserDefinedOptions['twPatcher'];
+}
+export interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+    cssEntries?: string[] | undefined;
+    cssSources?: TailwindV4CssSource[] | undefined;
+}
+export type TailwindV4SourceOptions = ReturnType<typeof resolveTailwindV4SourceOptionsFromPatcher> & {
+    config?: string | undefined;
+    outputRoot?: string | undefined;
+    sourceFile?: string | undefined;
+};
+export type TailwindV4CssSource = NonNullable<TailwindV4SourceOptions['cssSources']>[number];
+export type TailwindV4CssSourceRef = Pick<TailwindV4CssSource, 'file'>;
+export interface SourceStyleMatchOptions extends SourceSideCssEntryOptions {
+}

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

@@ -1,26 +1,9 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/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;
-    cssEntries?: string[] | undefined;
-}
-export interface GeneratorSourceMetadata {
-    matchedCssSourceFile?: string | undefined;
-    sourceEntries?: TailwindSourceEntry[] | undefined;
-    sourceBase?: string | undefined;
-    sourceCss?: string | undefined;
-}
-export type GeneratorResolvedSource = TailwindResolvedSource & {
-    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
-};
-export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;
+export type { GeneratorResolvedSource, GeneratorSourceMetadata } from './source-resolver/metadata';
+export { resolveCssSourceBase } from './source-resolver/postcss-source';
+export type { GeneratorSourceRuntimeState, GeneratorSourceSelectionOptions } from './source-resolver/types';
 export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource | 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 {};
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<any>;

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

@@ -1,4 +1,5 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindV4CssSource } from './source-resolver/types';
 import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 export interface GenerateCssByGeneratorOptions {
@@ -12,6 +13,7 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    cssSources?: TailwindV4CssSource[] | undefined;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;

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

@@ -1,5 +1,6 @@
 import type { GenerateCssByGeneratorOptions } from './types';
 export interface ValidateCandidatesByGeneratorOptions extends Omit<GenerateCssByGeneratorOptions, 'runtime'> {
     candidates: Set<string>;
+    skipGenerateFallback?: boolean | undefined;
 }
 export declare function validateCandidatesByGenerator(options: ValidateCandidatesByGeneratorOptions): Promise<Set<string>>;

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

@@ -3,6 +3,7 @@ export interface HmrTimingDetails {
     file?: string;
     hooks?: Record<string, HmrTimingHookSummary>;
     metric?: 'hook' | 'total';
+    memoryDebug?: Record<string, unknown> | undefined;
     wallMs?: number;
 }
 export interface HmrTimingHookSummary {

package/dist/bundlers/vite/css-memory.d.ts

@@ -0,0 +1,27 @@
+import type { RememberedCssSource } from './generate-bundle';
+export declare function normalizeCssSourceIdentity(sourceFile: string): string;
+export declare function shouldCollectTransformedSourceCandidates(id: string): boolean;
+export declare function createViteCssMemory(options: {
+    debug: (format: string, ...args: unknown[]) => void;
+    getSourceCandidateSource: (file: string) => string | undefined;
+}): {
+    getKnownSfcSource: (file: string) => string | undefined;
+    getRememberedCssSignature: (file: string) => string | undefined;
+    getRememberedCssSourceEntry: (file: string) => RememberedCssSource | undefined;
+    getRememberedCssSources: () => Map<string, RememberedCssSource>;
+    getStats: () => {
+        rememberedCssSources: number;
+        rememberedCssSignatureByFile: number;
+        knownSfcSources: number;
+    };
+    rememberCssSource: (entry: RememberedCssSource, cssRuntimeSignature?: string) => void;
+    rememberKnownSfcSource: (id: string, code: string) => void;
+    refreshRememberedCssSource: (remembered: RememberedCssSource) => Promise<RememberedCssSource | undefined>;
+    refreshRememberedCssSourceByCurrentFile: (sourceFile: string) => Promise<void>;
+    refreshRememberedCssSourceBySourceFile: (sourceFile: string, rawSource: string) => void;
+    setRememberedCssSignature: (file: string, cssRuntimeSignature: string) => void;
+    prune: (pruneOptions: {
+        activeFiles: Set<string>;
+        activeKnownSfcFiles?: Set<string> | undefined;
+    }) => void;
+};

package/dist/bundlers/vite/generate-bundle/bundle-file-names.d.ts

@@ -0,0 +1,2 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+export declare function normalizeBundleFileNameKeysForTest(bundle: Record<string, OutputAsset | OutputChunk>): void;

package/dist/bundlers/vite/generate-bundle/configured-css-sources.d.ts

@@ -0,0 +1,8 @@
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { InternalUserDefinedOptions } from '../../../types';
+export interface ConfiguredCssSourceEntry {
+    file: string;
+    source: string;
+}
+export declare function collectConfiguredTailwindV4CssSources(opts: InternalUserDefinedOptions): TailwindV4CssSource[];
+export declare function collectConfiguredTailwindV4CssSourceEntries(opts: InternalUserDefinedOptions, fallbackBase: string): ConfiguredCssSourceEntry[];

package/dist/bundlers/vite/generate-bundle/css-assets.d.ts

@@ -0,0 +1,4 @@
+import type { OutputAsset } from 'rollup';
+import type { GenerateBundleThis } from './types';
+export declare function createCssAssetEmitter(context: Pick<GenerateBundleThis, 'emitFile'>): (fileName: string, source: string) => OutputAsset;
+export declare function resolveAssetSourceFile(asset: OutputAsset, fallbackFile: string): string;

package/dist/bundlers/vite/generate-bundle/css-handler-options.d.ts

@@ -21,5 +21,10 @@ export interface CssHandlerOptionsCache {
     getCssHandlerOptions: (file: string) => CssHandlerOptions;
     getCssUserHandlerOptions: (file: string) => CssHandlerOptions;
 }
+export declare function resolveViteCssHandlerExtraOptions(file: string): {
+    isMainChunk: boolean;
+} | {
+    isMainChunk?: never;
+};
 export declare function createCssHandlerOptionsCache(options: CssHandlerOptionsCacheOptions): CssHandlerOptionsCache;
 export {};

package/dist/bundlers/vite/generate-bundle/css-output.d.ts

@@ -1,14 +1,16 @@
 import type { InternalUserDefinedOptions } from '../../../types';
 export declare const SOURCE_STYLE_OUTPUT_EXT_RE: RegExp;
 export declare const CSS_SOURCE_OUTPUT_EXT_RE: RegExp;
-export declare const MINI_PROGRAM_STYLE_OUTPUT_EXT_RE: RegExp;
+export declare function resolveMiniProgramStyleOutputExtension(options?: {
+    cssMatcher?: ((file: string) => boolean) | undefined;
+    fallback?: string | undefined;
+    files?: Iterable<string> | undefined;
+    stem?: string | undefined;
+}): string;
 export declare function resolveReplayCssOutputFile(rootDir: string, file: string): string;
-export declare function resolveViteCssOutputFile(file: string, opts: InternalUserDefinedOptions, isWebGeneratorTarget: boolean, preserveCssExtension?: boolean): string;
-export declare function resolveViteCssPipelineOutputFile(file: string, _opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget?: boolean, preserveCssExtension?: boolean): string;
+export declare function resolveReplayCssOutputFileFromSourceRoot(rootDir: string, file: string, sourceRoot: string | undefined): string;
+export declare function resolveViteCssOutputFile(file: string, opts: InternalUserDefinedOptions, isWebGeneratorTarget: boolean, preserveCssExtension?: boolean, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): string;
+export declare function resolveViteCssPipelineOutputFile(file: string, opts: Pick<InternalUserDefinedOptions, 'cssMatcher' | 'platform'>, rootDir: string, isWebGeneratorTarget?: boolean, preserveCssExtension?: boolean, sourceRoot?: string | undefined, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): string;
 export declare function canProcessViteSourceStyleAsCss(source: string, file: string): boolean;
 export declare function normalizeCssSourceForCompare(css: string): string;
 export declare function stripStyleFileExtension(file: string): string;
-export declare function isAppOriginCssFile(file: string): boolean;
-export declare function isMainAppCssFile(file: string): boolean;
-export declare function isMainStyleEntryCssFile(file: string): boolean;
-export declare function isTailwindEntryCssFile(file: string): boolean;

package/dist/bundlers/vite/generate-bundle/env-flags.d.ts

@@ -0,0 +1,7 @@
+export declare function resolveGenerateBundleEnvFlags(): {
+    forceRuntimeRefreshByEnv: boolean;
+    disableDirtyOptimization: boolean;
+    disableJsPrecheck: boolean;
+    debugCssDiff: boolean;
+    disableV3OxideSourceRuntime: boolean;
+};

package/dist/bundlers/vite/generate-bundle/finalize.d.ts

@@ -0,0 +1,58 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleBuildState, BundleSnapshot } from '../bundle-state';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext } from './types';
+interface FinalizeGenerateBundleOptions {
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    activeViteCssCacheFiles: Set<string>;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    bundleFiles: string[];
+    cache: GenerateBundleContext['opts']['cache'];
+    cssTaskFactories: Array<() => Promise<void>>;
+    debug: GenerateBundleContext['debug'];
+    defaultStyleOutputExtension: string;
+    formatIteration: number;
+    generatorCandidateSignature: string;
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
+    getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    hmrTimingRecorder: GenerateBundleContext['hmrTimingRecorder'];
+    hmrTimingStartedAt: number;
+    isHarmonyAppStyleTarget: boolean;
+    isNativeAppStyleTarget: boolean;
+    isViteProcessedCssAsset: GenerateBundleContext['isViteProcessedCssAsset'];
+    isWebGeneratorTarget: boolean;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    linkedByEntry: Map<string, Set<string>> | undefined;
+    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
+    metrics: BundleMetrics;
+    onEnd: GenerateBundleContext['opts']['onEnd'];
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    outDir: string;
+    pendingLinkedUpdates: Array<() => void>;
+    pruneViteCssCaches: GenerateBundleContext['pruneViteCssCaches'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    recordTimingDetail: (name: string, startedAt: number) => void;
+    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
+    rootDir: string;
+    runtime: Set<string>;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    shouldPreserveAppCssExtension: boolean;
+    snapshot: BundleSnapshot;
+    sourceCandidates: Set<string>;
+    sourceRoot: string | undefined;
+    state: BundleBuildState;
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    tasks: Promise<void>[];
+    timingDetails: Record<string, number>;
+    transformRuntime: Set<string>;
+    useIncrementalMode: boolean;
+}
+export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;
+export {};

package/dist/bundlers/vite/generate-bundle/js-processing.d.ts

@@ -0,0 +1,31 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext } from './types';
+import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types';
+interface ProcessJsBundleEntryOptions {
+    applyLinkedUpdates: (linked?: Record<string, LinkedJsModuleResult>) => void;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    cache: GenerateBundleContext['opts']['cache'];
+    createHandlerOptions: (absoluteFilename: string, extra?: CreateJsHandlerOptions) => CreateJsHandlerOptions;
+    debug: GenerateBundleContext['debug'];
+    disableJsPrecheck: boolean;
+    entry: BundleStateEntry;
+    getJsEntry: ReturnType<typeof import('./js-entries').createJsEntryResolver>;
+    jsHandler: GenerateBundleContext['opts']['jsHandler'];
+    jsTaskFactories: Array<() => Promise<void>>;
+    linkedByEntry: Map<string, Set<string>> | undefined;
+    metrics: BundleMetrics;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    outDir: string;
+    processFiles: BundleSnapshot['processFiles'];
+    rememberProcessCacheKey: (cacheKey: string, hashKey?: string | number) => void;
+    runtimeSignature: string;
+    snapshot: BundleSnapshot;
+    timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
+    transformRuntime: Set<string>;
+    uniAppX: GenerateBundleContext['opts']['uniAppX'];
+    useIncrementalMode: boolean;
+}
+export declare function processJsBundleEntry(options: ProcessJsBundleEntryOptions): void;
+export {};

package/dist/bundlers/vite/generate-bundle/memory-debug.d.ts

@@ -0,0 +1,77 @@
+import type { GenerateBundleContext } from './types';
+export declare function resolveViteMemoryDebugStats(context: {
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    cache: GenerateBundleContext['opts']['cache'];
+    generatorRuntimeSize: number;
+    getViteCssCacheStats?: (() => Record<string, unknown>) | undefined;
+    lastCssResultByFile: Map<string, string>;
+    phase: string;
+    runtimeSize: number;
+    sourceCandidatesSize: number;
+    transformRuntimeSize: number;
+    useIncrementalMode: boolean;
+}): {
+    phase: string;
+    mode: string;
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    runtime: {
+        sourceCandidates: number;
+        runtime: number;
+        transformRuntime: number;
+        generatorRuntime: number;
+    };
+    processCache: {
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        activeHashKeys: number;
+    };
+    viteCss: {
+        lastCssResultByFile: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
+    };
+    tailwind: {
+        v3: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            entries: {
+                key: string;
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+                exactResults: number;
+            }[];
+            keys: string[];
+        };
+        v4: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            taskMax: number;
+            taskSize: number;
+            entries: {
+                key: string;
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+            }[];
+            keys: string[];
+            taskKeys: string[];
+        };
+    };
+} | undefined;

package/dist/bundlers/vite/generate-bundle/remembered-css-replay.d.ts

@@ -0,0 +1,53 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleMetrics } from './metrics';
+import type { GenerateBundleContext, RememberedCssSource } from './types';
+interface ProcessRememberedCssReplayOptions {
+    addWatchFile: (id: string) => void;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    bundleFiles: string[];
+    cache: GenerateBundleContext['opts']['cache'];
+    createScopedGeneratorRuntime: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }, runtime: Set<string>, rawSource?: string | undefined, sourceFile?: string | undefined) => Promise<Set<string>>;
+    createScopedSourceCandidateGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => GenerateBundleContext['getSourceCandidatesForEntries'];
+    createScopedSourceCandidateSourceGetter: (outputFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    cssTaskFactories: Array<() => Promise<void>>;
+    debug: GenerateBundleContext['debug'];
+    defaultStyleOutputExtension: string;
+    emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset;
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
+    getRememberedCssSignature?: ((file: string) => string | undefined) | undefined;
+    getRememberedCssSources?: (() => Iterable<[string, RememberedCssSource]>) | undefined;
+    isNativeAppStyleTarget: boolean;
+    isWebGeneratorTarget: boolean;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
+    metrics: BundleMetrics;
+    normalizeViteCssCacheKey: (file: string) => string;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
+    refreshRememberedCssSource?: GenerateBundleContext['refreshRememberedCssSource'];
+    rootDir: string;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    setRememberedCssSignature?: ((file: string, cssRuntimeSignature: string) => void) | undefined;
+    shouldInjectCssIntoMainFromOutput: (outputFile: string, sourceFile: string, cssHandlerOptions: {
+        isMainChunk?: boolean | undefined;
+    }) => boolean;
+    shouldPreserveAppCssExtension: boolean;
+    sourceRoot: string | undefined;
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    timeTask: (name: string, task: () => Promise<void>) => Promise<void>;
+    useIncrementalMode: boolean;
+    activeViteCssCacheFiles: Set<string>;
+}
+export declare function processRememberedCssReplay(options: ProcessRememberedCssReplayOptions): Promise<void>;
+export {};

package/dist/bundlers/vite/generate-bundle/remembered-css.d.ts

@@ -5,7 +5,7 @@ export declare function createRememberedCssRuntimeSignature(cssRuntimeSignature:
 export declare function resolveRememberedCssSourceForTest(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource | undefined;
 export declare function findRememberedCssSources(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource[];
 export declare function mergeRememberedCssSources(sources: RememberedCssSource[], outputFile: string): RememberedCssSource | undefined;
-export declare function collectRememberedCssReplayGroups(sources: Iterable<[string, RememberedCssSource]> | undefined, opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget: boolean, preserveCssExtension: boolean): Map<string, {
+export declare function collectRememberedCssReplayGroups(sources: Iterable<[string, RememberedCssSource]> | undefined, opts: Pick<InternalUserDefinedOptions, 'cssMatcher'>, rootDir: string, isWebGeneratorTarget: boolean, preserveCssExtension: boolean, sourceRoot?: string | undefined, styleOutputExtension?: string | undefined, styleOutputFiles?: Iterable<string> | undefined): Map<string, {
     key: string;
     remembered: RememberedCssSource;
 }[]>;