weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.30

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

@@ -0,0 +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, 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.d.ts

@@ -1,43 +1,37 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
+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, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
+export { resolveGeneratorSource, } from './generator-css/source-resolver';
 export interface GenerateCssByGeneratorOptions {
     opts: InternalUserDefinedOptions;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
-        patchPromise: Promise<void>;
+        readyPromise: Promise<void>;
     };
     runtime: Set<string>;
     rawSource: string;
     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' | 'generator-forced';
+    source: 'generator';
+    dependencies: string[];
+    incremental?: boolean | undefined;
 }
-export declare function createCssAppend(base: string, extra: string): string;
-export declare function splitTailwindV4GeneratedCss(rawSource: string, rawTailwindCss: string): string | undefined;
-export declare function removeTailwindGeneratedCssByBanner(rawSource: string): string | undefined;
-export declare function stripTailwindBanner(css: string): string;
-export declare function stripTailwindBanners(css: string): string;
-export declare function stripGeneratorPlaceholderMarkers(css: string): string;
-export declare function hasTailwindGeneratedCss(rawSource: string): boolean;
-export declare function hasTailwindGeneratedCssMarkers(rawSource: string): boolean;
-export declare function inheritLegacyUnitConvertedDeclarations(css: string, legacyCss: string): string;
-export declare function removeTailwindSourceDirectives(rawSource: string): string;
-export declare function hasTailwindSourceDirectives(rawSource: string): boolean;
-export declare function resolveCssEntrySource(rawSource: string, base: string, options?: {
-    removeConfig?: boolean;
-}): {
-    css: string;
-    config: string | undefined;
-    configRequest: string | undefined;
-    base: string;
-} | undefined;
-export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GenerateCssByGeneratorOptions['runtimeState'], rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource>;
 export declare function isPureLocalCssImportWrapper(css: string): boolean;
 export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;
+export interface ValidateCandidatesByGeneratorOptions extends Omit<GenerateCssByGeneratorOptions, 'runtime'> {
+    candidates: Set<string>;
+}
+export declare function validateCandidatesByGenerator(options: ValidateCandidatesByGeneratorOptions): Promise<Set<string>>;

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;

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

@@ -1,11 +1,12 @@
 import type { OutputAsset } from 'rollup';
 import type { Plugin, ResolvedConfig } from 'vite';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CssFinalizerContext {
     opts: InternalUserDefinedOptions;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
-        patchPromise: Promise<void>;
+        readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
     isCssAssetProcessed: (asset: OutputAsset, file?: string) => boolean;
@@ -13,10 +14,15 @@ interface CssFinalizerContext {
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     recordCssAssetResult?: (file: string, css: string) => void;
+    recordViteProcessedCssAssetResult?: (file: string, css: string) => void;
+    getViteProcessedCssAssetResults?: () => Iterable<[string, string]>;
     getRecordedGeneratorCandidates?: () => Set<string> | undefined;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string) => void;
+    getRememberedMainCssSource?: (file: string) => string | undefined;
+    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
 }
 export declare function createViteCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;
 export {};

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

@@ -0,0 +1,2 @@
+export declare function collectUnescapedDynamicCandidates(source: string): string[];
+export declare function collectLegacyContainerCompatCandidates(sourceCandidates: Set<string>, candidates: Set<string>): Set<string>;

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

@@ -0,0 +1,24 @@
+import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types';
+type CssHandlerOptions = IStyleHandlerOptions & {
+    postcssOptions: {
+        options: {
+            from: string;
+        };
+    };
+    majorVersion: number | undefined;
+    sourceOptions?: {
+        outputRoot?: string | undefined;
+    } | undefined;
+};
+interface CssHandlerOptionsCacheOptions {
+    getAppType: () => InternalUserDefinedOptions['appType'];
+    mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
+    getMajorVersion: () => number | undefined;
+    getOutputRoot?: (() => string | undefined) | undefined;
+}
+export interface CssHandlerOptionsCache {
+    getCssHandlerOptions: (file: string) => CssHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => CssHandlerOptions;
+}
+export declare function createCssHandlerOptionsCache(options: CssHandlerOptionsCacheOptions): CssHandlerOptionsCache;
+export {};

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

@@ -0,0 +1,4 @@
+import type { InternalUserDefinedOptions } from '../../../types';
+export declare function createCssTransformShareScope(file: string, rawSource: string): string;
+export declare function createCssTransformShareScopeKey(opts: InternalUserDefinedOptions, file: string, rawSource: string): string;
+export declare function createCssRuntimeSignature(runtimeSignature: string, generatorCandidateSignature: string): string;

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

@@ -0,0 +1 @@
+export declare function hasOmittedKnownBundleFiles(currentBundleFiles: string[], previousBundleFiles: Iterable<string>): boolean;

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

@@ -0,0 +1,2 @@
+import type { OutputEntry } from '../bundle-entries';
+export declare function createJsEntryResolver(jsEntries: Map<string, OutputEntry>): (id: string) => OutputEntry | undefined;

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

@@ -0,0 +1,8 @@
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types';
+interface JsHandlerOptionsFactoryOptions {
+    getMajorVersion: () => number | undefined;
+    moduleGraph: CreateJsHandlerOptions['moduleGraph'];
+}
+export declare function resolveUniAppXJsTransformEnabled(uniAppX: InternalUserDefinedOptions['uniAppX'] | undefined): boolean;
+export declare function createJsHandlerOptionsFactory(options: JsHandlerOptionsFactoryOptions): (absoluteFilename: string, extra?: CreateJsHandlerOptions) => CreateJsHandlerOptions;
+export {};

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

@@ -0,0 +1,13 @@
+import type { OutputEntry } from '../bundle-entries';
+import type { LinkedJsModuleResult } from '../../../types';
+interface LinkedUpdateHelpersOptions {
+    jsEntries: Map<string, OutputEntry>;
+    onUpdate: (fileName: string, previous: string, next: string) => void;
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function createLinkedUpdateHelpers(options: LinkedUpdateHelpersOptions): {
+    applyLinkedUpdates: (linked?: Record<string, LinkedJsModuleResult>) => void;
+    pendingLinkedUpdates: (() => void)[];
+};
+export declare function collectLinkedFileNames(linked: Record<string, LinkedJsModuleResult> | undefined, getJsEntry: (id: string) => OutputEntry | undefined, linkedSet: Set<string> | undefined): void;
+export {};

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

@@ -0,0 +1,17 @@
+export interface BundleMetric {
+    total: number;
+    transformed: number;
+    cacheHits: number;
+    elapsed: number;
+}
+export interface BundleMetrics {
+    runtimeSet: number;
+    html: BundleMetric;
+    js: BundleMetric;
+    css: BundleMetric;
+}
+export declare function formatDebugFileList(files: Set<string>, limit?: number): string;
+export declare function createEmptyMetrics(): BundleMetrics;
+export declare function measureElapsed(start: number): number;
+export declare function formatCacheHitRate(metric: BundleMetric): string;
+export declare function formatMs(value: number): string;

package/dist/bundlers/vite/generate-bundle/process-plan.d.ts

@@ -0,0 +1,9 @@
+import type { BundleSnapshot } from '../bundle-state';
+interface LogBundleProcessPlanOptions {
+    debug: (format: string, ...args: unknown[]) => void;
+    snapshot: BundleSnapshot;
+    useIncrementalMode: boolean;
+    iteration: number;
+}
+export declare function logBundleProcessPlan(options: LogBundleProcessPlanOptions): void;
+export {};

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

@@ -0,0 +1,7 @@
+import type { OutputAsset } from 'rollup';
+interface GeneratorDependencyContext {
+    addWatchFile?: (id: string) => void;
+}
+export declare function createReplayCssAsset(fileName: string, source: string): OutputAsset;
+export declare function registerGeneratorDependencies(ctx: GeneratorDependencyContext, dependencies: readonly string[] | undefined): void;
+export {};

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

@@ -0,0 +1,8 @@
+import type { EntryType } from '../bundle-state';
+export declare function summarizeStringDiff(previous: string, next: string): string;
+export declare function createLinkedImpactSignature(entry: string, linkedImpactsByEntry: Map<string, Set<string>>, sourceHashByFile: Map<string, string>): string | undefined;
+export declare function createJsHashSalt(runtimeSignature: string, linkedImpactSignature?: string): string;
+export declare function createStableTextSignature(input: string): string;
+export declare function createCandidateSignature(candidates: Set<string>): string;
+export declare function getSnapshotHash(snapshotMap: Map<string, string>, file: string, fallback: string): string;
+export declare function hasRuntimeAffectingSourceChanges(changedByType: Record<EntryType, Set<string>>): boolean;

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

@@ -1,33 +1,45 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { ResolvedConfig } from 'vite';
+import type { HmrTimingRecorder } from '../shared/hmr-timing';
 import type { BundleSnapshot } from './bundle-state';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
-        patchPromise: Promise<void>;
+        readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
+    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
     recordCssAssetResult?: (file: string, css: string) => void;
+    recordViteProcessedCssAssetResult?: (file: string, css: string) => void;
+    getViteProcessedCssAssetResults?: () => Iterable<[string, string]>;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string, cssRuntimeSignature: string) => void;
     getRememberedMainCssSources?: () => Map<string, string>;
     getRememberedMainCssSignature?: (file: string) => string | undefined;
     setRememberedMainCssSignature?: (file: string, cssRuntimeSignature: string) => void;
     recordGeneratorCandidates?: (candidates: Set<string>) => void;
+    hmrTimingRecorder?: HmrTimingRecorder;
 }
 interface GenerateBundleThis {
+    addWatchFile?: (id: string) => void;
     emitFile?: (emittedFile: {
         type: 'asset';
         fileName: string;
         source: string;
     }) => string;
 }
+export declare function resolveReplayCssOutputFile(rootDir: string, file: string): string;
 export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;
 export {};

package/dist/bundlers/vite/incremental-runtime-class-set.d.ts

@@ -10,9 +10,13 @@ type ExtractValidCandidatesFn = (options?: MemoryExtractValidCandidatesOptions)
 type ExtractRawCandidateResult = Awaited<ReturnType<typeof extractRawCandidatesWithPositions>>;
 type ExtractRawCandidatesFn = (content: string, extension?: string) => Promise<ExtractRawCandidateResult>;
 export interface BundleRuntimeClassSetManager {
-    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot) => Promise<Set<string>>;
+    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
     reset: () => Promise<void>;
 }
+export interface BundleRuntimeClassSetSyncOptions {
+    baseClassSet?: Set<string> | undefined;
+    skipInitialFullScanWithBase?: boolean | undefined;
+}
 interface CreateBundleRuntimeClassSetManagerOptions {
     extractCandidates?: ExtractValidCandidatesFn;
     extractRawCandidates?: ExtractRawCandidatesFn;

package/dist/bundlers/vite/index.d.ts

@@ -1,3 +1,6 @@
-import type { Plugin } from 'vite';
 import type { UserDefinedOptions } from '../../types';
-export declare function UnifiedViteWeappTailwindcssPlugin(options?: UserDefinedOptions): Plugin[] | undefined;
+export interface WeappTailwindcssVitePlugin {
+    name: string;
+    [hook: string]: any;
+}
+export declare function WeappTailwindcss(options?: UserDefinedOptions): WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/official-tailwind-plugins.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+export declare function getPostcssPluginName(plugin: unknown): string | undefined;
+export declare function removeTailwindPostcssPlugins(plugins: unknown[]): number;
+export declare function removeTailwindVitePlugins(plugins: Plugin[]): number;
+export declare function disableAndRemoveTailwindVitePlugins(plugins: unknown[]): number;

package/dist/bundlers/vite/postcss-config.d.ts

@@ -0,0 +1,6 @@
+import postcssrc from 'postcss-load-config';
+export declare function resolveFilteredPostcssConfig(root: string): Promise<{
+    options: import("postcss").ProcessOptions<import("postcss").Document | import("postcss").Root>;
+    plugins: postcssrc.ResultPlugin[];
+    removed: number;
+} | undefined>;

package/dist/bundlers/vite/processed-css-assets.d.ts

@@ -0,0 +1,32 @@
+import type { OutputAsset, OutputBundle } from 'rollup';
+import type { InternalUserDefinedOptions } from '../../types';
+interface CssAssetMarkerMatcher {
+    (asset: OutputAsset, file?: string): boolean;
+}
+interface CssAssetProcessedMarker {
+    (asset: OutputAsset, file?: string): void;
+}
+interface CssAssetResultRecorder {
+    (file: string, css: string): void;
+}
+interface CssAssetResultsGetter {
+    (): Iterable<[string, string]>;
+}
+interface CollectViteProcessedCssAssetOptions {
+    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    recordViteProcessedCssAssetResult?: CssAssetResultRecorder | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+}
+interface InjectViteProcessedCssAssetOptions {
+    opts: InternalUserDefinedOptions;
+    getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
+}
+export declare function collectViteProcessedCssAssetResults(bundle: OutputBundle, options: CollectViteProcessedCssAssetOptions): number;
+export declare function injectViteProcessedCssIntoMainCssAssets(bundle: OutputBundle, options: InjectViteProcessedCssAssetOptions): number;
+export {};

package/dist/bundlers/vite/rewrite-css-imports.d.ts

@@ -1,11 +1,16 @@
 import type { Plugin } from 'vite';
 import type { AppType } from '../../types';
 interface RewriteCssImportsOptions {
-    appType?: AppType;
-    getAppType?: () => AppType | undefined;
+    appType?: AppType | undefined;
+    getAppType?: (() => AppType | undefined) | undefined;
+    generateTailwindCss?: ((id: string, code: string, hookContext?: {
+        addWatchFile?: (id: string) => void;
+    }) => Promise<string | undefined> | string | undefined) | undefined;
+    shouldOwnTailwindGeneration?: boolean | undefined;
     shouldRewrite: boolean;
-    rootImport?: string;
+    rootImport?: string | undefined;
     weappTailwindcssDirPosix: string;
+    onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
 }
 export declare function createRewriteCssImportsPlugins(options: RewriteCssImportsOptions): Plugin[];
 export {};

package/dist/bundlers/vite/runtime-class-set.d.ts

@@ -0,0 +1,25 @@
+import type { BundleSnapshot } from './bundle-state';
+import type { InternalUserDefinedOptions } from '../../types';
+interface CreateViteRuntimeClassSetOptions {
+    opts: InternalUserDefinedOptions;
+    initialTwPatcher: InternalUserDefinedOptions['twPatcher'];
+    refreshTailwindcssPatcher: InternalUserDefinedOptions['refreshTailwindcssPatcher'];
+    uniAppXEnabled: boolean;
+    customAttributesEntities: unknown;
+    disabledDefaultTemplateHandler: boolean;
+    debug: (format: string, ...args: unknown[]) => void;
+}
+export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClassSetOptions): {
+    runtimeState: {
+        twPatcher: import("@/types").TailwindcssPatcherLike;
+        readyPromise: Promise<void>;
+        refreshTailwindcssPatcher: (options?: import("@/types").RefreshTailwindcssPatcherOptions) => Promise<import("@/types").TailwindcssPatcherLike>;
+    };
+    refreshRuntimeState: (force: boolean) => Promise<void>;
+    ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
+};
+export {};

package/dist/bundlers/vite/serve-css-generation.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+interface ViteServeCssGenerationOptions {
+    generateCss: (id: string, code: string, hookContext?: {
+        addWatchFile?: (id: string) => void;
+    }) => Promise<string | undefined> | string | undefined;
+    getCommand: () => string | undefined;
+    onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
+    shouldGenerate: () => boolean;
+}
+export declare function createViteServeCssGenerationPlugins(options: ViteServeCssGenerationOptions): Plugin[];
+export {};

package/dist/bundlers/vite/source-candidates.d.ts

@@ -1,14 +1,32 @@
+import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 export interface SourceCandidateCollector {
     sync: (id: string, source: string) => Promise<void>;
+    syncCss: (id: string, source: string) => Promise<void>;
+    merge: (id: string, source: string) => Promise<void>;
     syncFile: (id: string) => Promise<void>;
+    syncCurrentFile: (id: string) => Promise<void>;
     scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
+    syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
     remove: (id: string) => void;
     values: () => Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined) => Set<string>;
+    snapshot: () => SourceCandidateCollectorSnapshot;
+    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
     clear: () => void;
 }
+export interface SourceCandidateCollectorSnapshot {
+    candidatesById: Array<[string, string[]]>;
+    cssCandidatesById?: Array<[string, string[]]> | undefined;
+    scanCandidatesById?: Array<[string, string[]]> | undefined;
+    transformCandidatesById?: Array<[string, string[]]> | undefined;
+    inlineExcludedCandidates: string[];
+    inlineIncludedCandidates: string[];
+}
 interface ScanSourceCandidateRootOptions {
     root: string;
-    outDir?: string;
+    outDir?: string | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
 }
 export declare function isSourceCandidateRequest(id: string): boolean;
 export declare function createSourceCandidateCollector(): SourceCandidateCollector;

package/dist/bundlers/vite/source-scan.d.ts

@@ -0,0 +1,26 @@
+import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
+import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../types';
+export interface ResolvedTailwindV4CssEntries {
+    entries: TailwindSourceEntry[];
+    explicit: boolean;
+    inlineCandidates: TailwindInlineSourceCandidates;
+    dependencies: string[];
+}
+export interface ResolvedViteSourceScan {
+    dependencies?: string[] | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
+    inlineCandidates?: TailwindInlineSourceCandidates | undefined;
+}
+interface ResolveViteSourceScanOptions {
+    root?: string | undefined;
+    outDir?: string | undefined;
+}
+export declare function mergeTailwindInlineSourceCandidates(allInlineCandidates: Array<TailwindInlineSourceCandidates | undefined>): TailwindInlineSourceCandidates | undefined;
+export declare function resolveTailwindV4EntriesFromCss(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function resolveViteTailwindV4CssDependencies(css: string, base: string): Promise<string[]>;
+export declare function resolveTailwindV4EntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function discoverTailwindV4CssEntries(root: string, outDir: string | undefined): Promise<string[]>;
+export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike, scanOptions?: ResolveViteSourceScanOptions): Promise<ResolvedViteSourceScan | undefined>;
+export declare function createViteSourceScanMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export {};

package/dist/bundlers/vite/static-config-content.d.ts

@@ -0,0 +1,5 @@
+type StaticContentValue = string | StaticContentValue[] | {
+    files: StaticContentValue;
+};
+export declare function readStaticConfigContent(configPath: string): StaticContentValue | undefined;
+export {};

package/dist/bundlers/vite/tailwind-basedir.d.ts

@@ -0,0 +1 @@
+export declare function resolveImplicitTailwindcssBasedirFromViteRoot(root: string): string;

package/dist/bundlers/webpack/BaseUnifiedPlugin/shared.d.ts

@@ -15,6 +15,12 @@ interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
     removedFiles?: Set<string>;
 }
+interface RuntimeWatchDependenciesLike {
+    files?: Iterable<string>;
+    contexts?: Iterable<string>;
+}
 export declare function createAssetHashByChunkMap(chunks: Iterable<ChunkLike>): Map<string, string>;
+export declare function createRuntimeAwareCssHash(assetHash: string | undefined, sourceHash: string, runtimeSetHash: string): string;
 export declare function hasWatchChanges(compiler: WebpackWatchChangeLike): boolean;
+export declare function isWatchFileInRuntimeDependencies(file: string, dependencies: RuntimeWatchDependenciesLike): boolean;
 export {};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets.d.ts

@@ -1,16 +1,20 @@
 import type { Compiler } from 'webpack';
+import type { BundleRuntimeClassSetManager } from '../../vite/incremental-runtime-class-set';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5ProcessAssetsHookOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
-        patchPromise: Promise<void>;
+        readyPromise: Promise<void>;
     };
     getRuntimeRefreshRequirement: () => boolean;
     refreshRuntimeMetadata: (force: boolean) => Promise<void>;
+    isWebpackProcessedCssAsset?: ((file: string, rawSource: string) => boolean) | undefined;
     consumeRuntimeRefreshRequirement: () => void;
+    isWatchMode?: (() => boolean) | undefined;
+    runtimeClassSetManager?: BundleRuntimeClassSetManager | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function setupWebpackV5ProcessAssetsHook(options: SetupWebpackV5ProcessAssetsHookOptions): void;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.d.ts

@@ -1,18 +1,24 @@
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
 import type { Compiler } from 'webpack';
+import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5LoadersOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     weappTailwindcssPackageDir: string;
     shouldRewriteCssImports: boolean;
-    runtimeLoaderPath?: string;
-    runtimeCssImportRewriteLoaderPath?: string;
+    runtimeLoaderPath?: string | undefined;
+    registerAutoCssSource?: ((source: TailwindV4CssSource) => Promise<void> | void) | undefined;
+    runtimeState: TailwindRuntimeState;
     getClassSetInLoader: () => Promise<void>;
+    getRuntimeSetInLoader: () => Promise<Set<string>>;
+    markWebpackProcessedCssSource?: ((file: string) => void) | undefined;
     getRuntimeWatchDependencies: () => {
         files: ReadonlySet<string>;
         contexts: ReadonlySet<string>;
     };
+    runtimeRegistryKey?: string | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function setupWebpackV5Loaders(options: SetupWebpackV5LoadersOptions): void;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5.d.ts

@@ -1,9 +1,10 @@
 import type { Compiler } from 'webpack';
 import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
 export declare const weappTailwindcssPackageDir: string;
-export declare class UnifiedWebpackPluginV5 implements IBaseWebpackPlugin {
+export declare class WeappTailwindcss implements IBaseWebpackPlugin {
     options: InternalUserDefinedOptions;
     appType?: AppType;
+    private hasInitialTailwindCssRoots;
     constructor(options?: UserDefinedOptions);
     apply(compiler: Compiler): void;
 }