weapp-tailwindcss 5.1.14 → 5.1.16

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

@@ -0,0 +1,10 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { InternalUserDefinedOptions } from '../../../../types';
+export declare function transformGeneratorUserCss(source: string, options: {
+    generatorTarget: string;
+    generatorStyleOptions: Partial<IStyleHandlerOptions>;
+    cssUserHandlerOptions: IStyleHandlerOptions;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    importFallback: boolean;
+    processed?: boolean | undefined;
+}): Promise<string>;

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

@@ -0,0 +1,15 @@
+import { postcss } from '@weapp-tailwindcss/postcss';
+export declare function splitUserCssLayerBlocks(source: string): {
+    layer: string;
+    rest: string;
+};
+export declare function hasUserCssLayerBlocks(source: string): boolean;
+export declare function extractGeneratedCssForUserLayerSelectors(css: string, userLayerSource: string): {
+    layer: string;
+    rest: string;
+};
+export declare function normalizeGeneratedSelector(selector: string): string;
+export declare function collectApplyOnlySourceSelectors(source: string): Set<string>;
+export declare function hasOnlyApplyBackedSourceRules(source: string): boolean;
+export declare function removeCssComments(css: string): string;
+export declare function isEmptyCustomVariantBlock(rule: postcss.AtRule): boolean;

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

@@ -1,33 +1,5 @@
-import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import type { InternalUserDefinedOptions } from '../../../types';
-export declare function removeTailwindV4GeneratedUserCssArtifacts(source: string): string;
-export declare function removeTailwindV4GeneratorAtRules(source: string): string;
-export declare function isCommentOnlyCss(source: string): boolean;
-export declare function removeMiniProgramHoverSelectors(source: string, enabled?: boolean | undefined): string;
-export declare function stripTailwindSourceMediaFragments(source: string): string;
-export declare function stripUnmatchedTailwindSourceMediaCloseFragments(source: string): string;
-export declare function splitUserCssLayerBlocks(source: string): {
-    layer: string;
-    rest: string;
-};
-export declare function hasUserCssLayerBlocks(source: string): boolean;
-export declare function extractGeneratedCssForUserLayerSelectors(css: string, userLayerSource: string): {
-    layer: string;
-    rest: string;
-};
-export declare function normalizeEmptyTailwindCustomVariants(css: string): string;
-export declare function filterApplyOnlyGeneratedCss(css: string, source: string, options?: {
-    preserveVariables?: boolean | undefined;
-}): string;
-export declare function shouldFilterApplyOnlyGeneratedCss(_majorVersion: number | undefined, target: string, source: string, options: {
-    hasGeneratedCss: boolean;
-    hasGeneratedMarkers: boolean;
-}): boolean;
-export declare function transformGeneratorUserCss(source: string, options: {
-    generatorTarget: string;
-    generatorStyleOptions: Partial<IStyleHandlerOptions>;
-    cssUserHandlerOptions: IStyleHandlerOptions;
-    styleHandler: InternalUserDefinedOptions['styleHandler'];
-    importFallback: boolean;
-    processed?: boolean | undefined;
-}): Promise<string>;
+export { filterApplyOnlyGeneratedCss, normalizeEmptyTailwindCustomVariants, shouldFilterApplyOnlyGeneratedCss } from './user-css/apply-only';
+export { removeTailwindV4GeneratedUserCssArtifacts } from './user-css/generated-cleanup';
+export { isCommentOnlyCss, removeMiniProgramHoverSelectors, removeTailwindV4GeneratorAtRules, stripTailwindSourceMediaFragments, stripUnmatchedTailwindSourceMediaCloseFragments } from './user-css/source-fragments';
+export { transformGeneratorUserCss } from './user-css/transform';
+export { extractGeneratedCssForUserLayerSelectors, hasUserCssLayerBlocks, splitUserCssLayerBlocks } from './user-css/user-layers';

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

@@ -1,10 +1,9 @@
-import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './generator-css/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 { isPureLocalCssImportWrapper, } from './generator-css/local-imports';
 export { createCssAppend, hasTailwindGeneratedCss, hasTailwindGeneratedCssMarkers, removeTailwindGeneratedCssByBanner, splitGeneratorPlaceholderCssBySourceOrder, splitTailwindGeneratedCssByBanner, splitTailwindV4GeneratedCss, splitTailwindV4GeneratedCssBySourceOrder, stripGeneratorPlaceholderMarkers, stripTailwindBanner, stripTailwindBanners, } from './generator-css/markers';
+export { generateCssByGenerator } from './generator-css/pipeline';
 export { resolveGeneratorSource, } from './generator-css/source-resolver';
 export type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult, } from './generator-css/types';
 export { validateCandidatesByGenerator, } from './generator-css/validate';
-export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

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

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

package/dist/bundlers/shared/v4-generation-core.d.ts

@@ -1,5 +1,8 @@
 import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from './generator-css';
+import type { InternalUserDefinedOptions } from '../../types';
 export interface TailwindV4GenerationCoreInput extends GenerateCssByGeneratorOptions {
+    frameworkPostcssOwner?: InternalUserDefinedOptions | undefined;
+    frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     outputFile?: string | undefined;
     sourceCandidates?: Set<string> | undefined;
 }

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

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

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

@@ -0,0 +1,54 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { OutputAsset } from 'rollup';
+import type { ResolvedConfig } from 'vite';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { InternalUserDefinedOptions } from '../../../types';
+interface RememberedMainCssSource {
+    rawSource: string;
+    sourceFile: string;
+}
+export interface CssFinalizerContext {
+    opts: InternalUserDefinedOptions;
+    runtimeState: {
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
+        readyPromise: Promise<void>;
+    };
+    ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    isCssAssetProcessed: (asset: OutputAsset, file?: string) => boolean;
+    markCssAssetProcessed: (asset: OutputAsset, file?: string) => void;
+    debug: (format: string, ...args: unknown[]) => void;
+    getResolvedConfig: () => ResolvedConfig | undefined;
+    recordCssAssetResult?: (file: string, css: string) => void;
+    recordViteProcessedCssAssetResult?: (file: string, css: string, options?: {
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }) => void;
+    getViteProcessedCssAssetResults?: () => Iterable<[string, string | {
+        css: string;
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }]>;
+    getRecordedGeneratorCandidates?: () => Set<string> | undefined;
+    getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+    getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Map<string, Set<string>>) | undefined;
+    waitForSourceCandidateSyncs?: () => Promise<void>;
+    rememberMainCssSource?: (file: string, rawSource: string) => void;
+    getRememberedMainCssSource?: (file: string) => RememberedMainCssSource | undefined;
+    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
+    frameworkRootImportShellTargetByFile?: ReadonlyMap<string, string> | undefined;
+}
+export interface CssFinalizerThis {
+    addWatchFile?: (id: string) => void;
+}
+export declare function inferPlatformFromViteOutDir(outDir: string | undefined): string | undefined;
+export declare function registerGeneratorDependencies(ctx: CssFinalizerThis, dependencies: readonly string[] | undefined): void;
+export declare function createCssHandlerOptions(opts: InternalUserDefinedOptions, majorVersion: number | undefined, file: string, outputRoot: string | undefined, extraOptions?: Record<string, unknown>): IStyleHandlerOptions;
+export declare function shouldGenerateCssByGenerator(opts: InternalUserDefinedOptions, majorVersion: number | undefined, file: string, rawSource: string, processed: boolean): boolean;
+export declare function collectViteProcessedCssSources(getViteProcessedCssAssetResults: CssFinalizerContext['getViteProcessedCssAssetResults']): string[];
+export declare function finalizeWebCss(css: string, context: ViteFrameworkCssPipelineContext & {
+    file: string;
+}, cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined): string;
+export {};

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

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { CssFinalizerContext } from './options';
+export declare function createViteCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;

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

@@ -1,43 +1 @@
-import type { OutputAsset } from 'rollup';
-import type { Plugin, ResolvedConfig } from 'vite';
-import type { ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy';
-import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
-import type { InternalUserDefinedOptions } from '../../types';
-interface RememberedMainCssSource {
-    rawSource: string;
-    sourceFile: string;
-}
-interface CssFinalizerContext {
-    opts: InternalUserDefinedOptions;
-    runtimeState: {
-        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
-        readyPromise: Promise<void>;
-    };
-    ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
-    isCssAssetProcessed: (asset: OutputAsset, file?: string) => boolean;
-    markCssAssetProcessed: (asset: OutputAsset, file?: string) => void;
-    debug: (format: string, ...args: unknown[]) => void;
-    getResolvedConfig: () => ResolvedConfig | undefined;
-    recordCssAssetResult?: (file: string, css: string) => void;
-    recordViteProcessedCssAssetResult?: (file: string, css: string, options?: {
-        injectIntoMain?: boolean | undefined;
-        outputFile?: string | undefined;
-    }) => void;
-    getViteProcessedCssAssetResults?: () => Iterable<[string, string | {
-        css: string;
-        injectIntoMain?: boolean | undefined;
-        outputFile?: string | undefined;
-    }]>;
-    getRecordedGeneratorCandidates?: () => Set<string> | undefined;
-    getSourceCandidates?: () => Set<string>;
-    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
-    getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Map<string, Set<string>>) | undefined;
-    waitForSourceCandidateSyncs?: () => Promise<void>;
-    rememberMainCssSource?: (file: string, rawSource: string) => void;
-    getRememberedMainCssSource?: (file: string) => RememberedMainCssSource | undefined;
-    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
-    frameworkRootImportShellTargetByFile?: ReadonlyMap<string, string> | undefined;
-}
-export declare function createViteCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;
-export {};
+export { createViteCssFinalizerOutputPlugin } from './css-finalizer/plugin';

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

@@ -0,0 +1,20 @@
+import type { BundleSnapshot } from '../bundle-state';
+import type { SourceCandidateFilterOptions } from '../source-candidates';
+import type { createTransformFilter } from './transform-filter';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+interface CollectBundleMarkupCandidatesOptions {
+    extractSourceCandidates?: ((file: string, source: string) => Promise<Set<string>>) | undefined;
+    previousCandidatesByFile?: ReadonlyMap<string, Set<string>> | undefined;
+    preserveMissingFiles?: boolean | undefined;
+    resolveSourceCandidateFile: (file: string) => string | undefined;
+    rootDir: string;
+    snapshot: BundleSnapshot;
+    transformFilter: ReturnType<typeof createTransformFilter>;
+}
+export interface BundleMarkupCandidateCollection {
+    candidatesByFile: Map<string, Set<string>>;
+    values: Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>;
+}
+export declare function collectBundleMarkupCandidates(options: CollectBundleMarkupCandidatesOptions): Promise<BundleMarkupCandidateCollection>;
+export {};

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

@@ -8,6 +8,7 @@ type CssHandlerOptions = IStyleHandlerOptions & {
     majorVersion?: 4 | undefined;
     sourceOptions?: {
         outputRoot?: string | undefined;
+        requestFile?: string | undefined;
     } | undefined;
 };
 interface CssHandlerOptionsCacheOptions {

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

@@ -0,0 +1,2 @@
+import type { FinalizeGenerateBundleOptions } from './root-import-shell';
+export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;

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

@@ -0,0 +1,69 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleBuildState, BundleSnapshot } from '../../bundle-state';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy';
+import type { BundleMetrics } from '../metrics';
+import type { GenerateBundleContext } from '../types';
+export 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>>;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
+    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;
+    jsAfterCss: boolean;
+    jsTaskFactories: Array<() => Promise<void>>;
+    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>;
+    transformWebTargetCss?: ((css: string, file: string) => string) | undefined;
+    useIncrementalMode: boolean;
+}
+export declare function finalizeWebviewCssCompat(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<FinalizeGenerateBundleOptions, 'debug' | 'onUpdate' | 'opts' | 'recordCssAssetResult'>): number;
+export declare function normalizeRootMiniProgramImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'cssMatcher'> & {
+    debug: GenerateBundleContext['debug'];
+    enabled: boolean;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+}): number;

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

@@ -1,70 +1,2 @@
-import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleBuildState, BundleSnapshot } from '../bundle-state';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-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>>;
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
-    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
-    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;
-    jsAfterCss: boolean;
-    jsTaskFactories: Array<() => Promise<void>>;
-    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>;
-    transformWebTargetCss?: ((css: string, file: string) => string) | undefined;
-    useIncrementalMode: boolean;
-}
-export declare function normalizeRootMiniProgramImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'cssMatcher'> & {
-    debug: GenerateBundleContext['debug'];
-    enabled: boolean;
-    onUpdate: GenerateBundleContext['opts']['onUpdate'];
-    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
-}): number;
-export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;
-export {};
+export { finalizeGenerateBundle } from './finalize/bundle';
+export { normalizeRootMiniProgramImportShellAssets } from './finalize/root-import-shell';

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

@@ -55,5 +55,6 @@ interface ProcessRememberedCssReplayOptions {
     useIncrementalMode: boolean;
     activeViteCssCacheFiles: Set<string>;
 }
+export declare function shouldSkipRawRememberedCssSource(rawSource: string, sourceFile: string): boolean;
 export declare function processRememberedCssReplay(options: ProcessRememberedCssReplayOptions): Promise<void>;
 export {};

package/dist/bundlers/vite/generate-bundle/sfc-style-source.d.ts

@@ -1,6 +1,7 @@
 import type { OutputChunk } from 'rollup';
 import type { BundleSnapshot } from '../bundle-state';
 import type { RememberedCssSource } from './types';
+export declare function isSfcStyleSourceFile(file: string): boolean;
 export interface SfcStyleBlock {
     attrs: string;
     index: number;
@@ -10,7 +11,7 @@ export interface SfcStyleBlock {
 export declare function extractSfcStyleBlocks(source: string): SfcStyleBlock[];
 export declare function extractSfcStyleSources(source: string): string[];
 export declare function hasSfcStyleSources(source: string): boolean;
-export declare function resolveSfcStyleRequestFromKnownSource(sourceFile: string, sfcSource: string | undefined, styleSource: string): string;
+export declare function resolveSfcStyleRequestFromKnownSource(sourceFile: string, sfcSource: string | undefined, styleSource: string, currentRequest?: string): string;
 export declare function hasTailwindGenerationSource(source: string, options?: {
     allowRootDirectives?: boolean | undefined;
 }): boolean;

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

@@ -6,4 +6,5 @@ export interface ResolveCurrentSourceCandidateSourceOptions {
     rootDir: string;
     sourceRoot?: string | undefined;
 }
+export declare function resolveCurrentSourceCandidateFile(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;
 export declare function resolveCurrentSourceCandidateSource(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;

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

@@ -7,6 +7,10 @@ import type { SourceCandidateFilterOptions } from '../source-candidates';
 import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 export interface GenerateBundleContext {
+    processMarkupAndScripts?: boolean | undefined;
+    processStyles?: boolean | undefined;
+    shouldProcessBundle?: (() => boolean) | undefined;
+    shouldProcessStyles?: (() => boolean) | undefined;
     opts: InternalUserDefinedOptions;
     runtimeState: {
         tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
@@ -42,6 +46,7 @@ export interface GenerateBundleContext {
     getSourceCandidates?: () => Set<string>;
     getSourceCandidateSource?: (file: string) => string | undefined;
     getSourceCandidateSources?: () => Iterable<[string, string]>;
+    extractSourceCandidates?: (file: string, source: string) => Promise<Set<string>>;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;
     getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;

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

@@ -0,0 +1,6 @@
+import { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names';
+import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output';
+import { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css';
+import { shouldKeepRootMiniProgramStyleAsImportShell as shouldKeepRootMiniProgramStyleAsImportShell2, shouldMoveRootMiniProgramStyleToImportShellOrigin as shouldMoveRootMiniProgramStyleToImportShellOrigin2 } from './generate-bundle/root-style-output';
+declare function createGenerateBundleHook(context: any): any;
+export { createGenerateBundleHook, normalizeBundleFileNameKeysForTest, resolveMiniProgramStyleOutputExtension2 as resolveMiniProgramStyleOutputExtension, resolveRememberedCssSourceForTest, resolveReplayCssOutputFile2 as resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile2 as resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile, shouldKeepRootMiniProgramStyleAsImportShell2 as shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin2 as shouldMoveRootMiniProgramStyleToImportShellOrigin };

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

@@ -5,4 +5,4 @@ export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, res
 export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css';
 export { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output';
 export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types';
-export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;
+export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, options: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;

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

@@ -0,0 +1,12 @@
+import type { OutputAsset, OutputBundle } from 'rollup';
+import type { CollectViteProcessedCssAssetOptions } from './markers-imports';
+export declare function restoreCssImportAtRules(source: string, filtered: string, file?: string): string;
+export declare function removeCommentOnlyAtRules(css: string): string;
+export declare function collectImportedBundleCssSources(bundle: OutputBundle, importedStyleFiles: Set<string>): string[];
+export declare function collectBundleAssetFiles(bundle: OutputBundle): Set<string>;
+export declare function resolveConfiguredCssEntryRootInjectionTarget(bundle: OutputBundle, options: Pick<CollectViteProcessedCssAssetOptions, 'cssPipelineStrategy' | 'createCssPipelineContext' | 'opts'>, sourceFile: string | undefined, outputFile: string): string | undefined;
+export declare function findBundleAssetByOutputFile(bundle: OutputBundle, file: string): OutputAsset | undefined;
+export declare function isCssImportOnlyBundleAsset(bundle: OutputBundle, file: string, css: string): boolean;
+export declare function isCoveredViteGeneratedSourceAsset(file: string, existingAssetFiles: Set<string>, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): boolean;
+export declare function resolveViteGeneratedCssMarkerOutputFile(file: string, markerFile: string | undefined, existingAssetFiles: Set<string>, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): string;
+export declare function isSourceRootPrefixedOutputFile(file: string, outputFile: string): boolean;

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

@@ -0,0 +1,4 @@
+import type { OutputBundle } from 'rollup';
+import type { CollectViteProcessedCssAssetOptions, InjectViteProcessedCssAssetOptions } from './markers-imports';
+export declare function collectViteProcessedCssAssetResults(bundle: OutputBundle, options: CollectViteProcessedCssAssetOptions): number;
+export declare function injectViteProcessedCssIntoMainCssAssets(bundle: OutputBundle, options: InjectViteProcessedCssAssetOptions): number;

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

@@ -0,0 +1,34 @@
+import type { OutputBundle } from 'rollup';
+import type { CssAssetMarkerMatcher, CssAssetResultRecorder } from './markers-imports';
+import { postcss } from '@weapp-tailwindcss/postcss';
+export declare function normalizeCssSignatureValue(value: string): string;
+export declare function collectRootScopedComparableCssCoverage(cssSources: string[]): {
+    rules: Set<string>;
+    atRules: Set<string>;
+    declarationsBySelector: Map<string, Set<string>>;
+    normalizedRuleCss: Set<string>;
+};
+export type ComparableCssCoverage = ReturnType<typeof collectRootScopedComparableCssCoverage>;
+export declare function prepareImportedCssCoverage(importedCssSources: string[]): {
+    coverage: {
+        rules: Set<string>;
+        atRules: Set<string>;
+        declarationsBySelector: Map<string, Set<string>>;
+        normalizedRuleCss: Set<string>;
+    };
+    sources: string[];
+} | undefined;
+export declare function isRuleCoveredByRootCss(rule: postcss.Rule, coverage: ReturnType<typeof collectRootScopedComparableCssCoverage>): boolean;
+export declare function removeScopedTailwindPreflightCss(css: string): string;
+export declare function collectSingleViteGeneratedCssMarkerFile(rawSource: string): string | undefined;
+export declare function shouldFilterRootGeneratedCssMarkerForScopedAsset(targetFile: string, markerFile: string, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): boolean;
+export declare function removeCssCoveredByRootStyleBundleSources(bundle: OutputBundle, file: string, css: string): string;
+export declare function removeCssCoveredByRootStyleAssets(bundle: OutputBundle, options: {
+    cssMatcher: (file: string) => boolean;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+    includeTailwindGeneratedCssAssets?: boolean | undefined;
+    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
+    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    subpackageRoots?: Set<string> | undefined;
+}): number;

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

@@ -0,0 +1,42 @@
+import type { OutputBundle } from 'rollup';
+import type { ComparableCssCoverage } from './coverage';
+import type { InjectViteProcessedCssAssetOptions } from './markers-imports';
+import type { InternalUserDefinedOptions } from '../../../types';
+export { isMiniProgramStyleOutputFile, isRootStyleOutputFile } from './style-files';
+export declare function shouldInjectViteProcessedCssResult(opts: InternalUserDefinedOptions, targetFile: string, sourceFile: string, options: {
+    injectIntoMain?: boolean | undefined;
+    outputFile?: string | undefined;
+}): boolean;
+export declare function shouldReplayViteProcessedCssIntoMainCss(opts: InternalUserDefinedOptions, file: string, sourceFile: string | undefined, outputFile: string, subpackageRoots: Set<string> | undefined): boolean;
+export declare function shouldPreserveMiniProgramImportShell(options: Pick<InjectViteProcessedCssAssetOptions, 'cssPipelineStrategy' | 'createCssPipelineContext' | 'opts'>, bundle: OutputBundle, file: string, css: string): boolean;
+export declare function resolvePreservedImportShellInjectionTarget(options: Pick<InjectViteProcessedCssAssetOptions, 'cssPipelineStrategy' | 'createCssPipelineContext'>, bundle: OutputBundle, file: string, css: string): string | undefined;
+export declare function shouldUseCssAssetAsMainInjectionTarget(opts: InternalUserDefinedOptions, file: string, records: Array<{
+    injectIntoMain?: boolean | undefined;
+    outputFile?: string | undefined;
+}>, options: Pick<InjectViteProcessedCssAssetOptions, 'cssPipelineStrategy' | 'createCssPipelineContext'>, bundle: OutputBundle): boolean;
+export declare function isViteProcessedCssResultImported(record: {
+    file: string;
+    outputFile?: string | undefined;
+}, importedStyleFiles: Set<string>): boolean;
+export declare function isViteProcessedCssResultCoveredByImportedBundleAsset(record: {
+    file: string;
+    outputFile?: string | undefined;
+}, importedStyleFiles: Set<string>, assetFiles: Set<string>): boolean;
+export declare function removeCoveredInjectedSourceAssets(bundle: OutputBundle, targetFile: string, targetCss: string, records: Array<{
+    file: string;
+    css: string;
+    injectIntoMain?: boolean | undefined;
+    outputFile?: string | undefined;
+}>, options: Pick<InjectViteProcessedCssAssetOptions, 'shouldRemoveInjectedSourceAsset' | 'debug'>): number;
+export declare function removeCssCoveredByImportedViteResults(css: string, importedCssSources: string[], prepared?: {
+    coverage: {
+        rules: Set<string>;
+        atRules: Set<string>;
+        declarationsBySelector: Map<string, Set<string>>;
+        normalizedRuleCss: Set<string>;
+    };
+    sources: string[];
+} | undefined): string;
+export declare function removeCssRulesCoveredBySources(css: string, sources: string[], options?: {
+    exactOnly?: boolean | undefined;
+}, preparedCoverage?: ComparableCssCoverage | undefined): string;