weapp-tailwindcss 5.1.15 → 5.1.16

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/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-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;

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

@@ -0,0 +1,89 @@
+import type { OutputAsset, OutputBundle } from 'rollup';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
+import type { InternalUserDefinedOptions } from '../../../types';
+export { isCssOutputFile } from './style-files';
+export interface CssAssetMarkerMatcher {
+    (asset: OutputAsset, file?: string): boolean;
+}
+interface CssAssetProcessedMarker {
+    (asset: OutputAsset, file?: string): void;
+}
+interface CssAssetResultRecordOptions {
+    injectIntoMain?: boolean | undefined;
+    outputFile?: string | undefined;
+}
+export interface CssAssetResultRecorder {
+    (file: string, css: string, options?: CssAssetResultRecordOptions): void;
+}
+interface CssAssetResultsGetter {
+    (): Iterable<[string, string | {
+        css: string;
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }]>;
+}
+export interface CollectViteProcessedCssAssetOptions {
+    opts?: InternalUserDefinedOptions | undefined;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
+    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    recordViteProcessedCssAssetResult?: CssAssetResultRecorder | undefined;
+    resolveViteProcessedCssOutputFile?: ((file: string) => string | undefined) | undefined;
+    subpackageRoots?: Set<string> | undefined;
+    transformCss?: ((css: string, file: string) => string) | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+}
+export interface InjectViteProcessedCssAssetOptions {
+    opts: InternalUserDefinedOptions;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
+    getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    shouldRemoveInjectedSourceAsset?: ((file: string, record: {
+        file: string;
+        css: string;
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }) => boolean) | undefined;
+    transformCss?: ((css: string, file: string) => string) | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
+    recordTimingDetail?: ((name: string, startedAt: number) => void) | undefined;
+}
+export declare function createCssAssetPipelineContext(options: Pick<CollectViteProcessedCssAssetOptions & InjectViteProcessedCssAssetOptions, 'createCssPipelineContext'>, file: string, bundle: OutputBundle): {
+    bundle: OutputBundle;
+    currentGeneratorBranch: ReturnType<typeof import("../../../runtime-branch").resolveGeneratorRuntimeBranch>;
+    currentGeneratorOptions: ReturnType<typeof import("../../..").normalizeWeappTailwindcssGeneratorOptions>;
+    opts: InternalUserDefinedOptions;
+    resolvedConfig: import("vite").ResolvedConfig | undefined;
+    resolveStylePlatform: () => string | undefined;
+} | undefined;
+export declare function getAssetFile(bundleFile: string, asset: OutputAsset): string;
+export declare function readAssetSource(asset: OutputAsset): string;
+export declare function clearAssetSource(asset: OutputAsset): void;
+export declare function appendCss(baseCss: string, css: string): string;
+export declare function hasNonCommentCss(css: string): boolean;
+export declare function dedupeViteCssResults<T extends {
+    css: string;
+    outputFile?: string | undefined;
+}>(records: T[]): T[];
+export declare function removeTailwindEntryDirectivesFromCss(css: string): string;
+interface NormalizeInjectableCssResult {
+    css: string;
+    importedStyleFiles: Set<string>;
+}
+export declare function normalizeInjectableCssForTarget(css: string, file: string): string;
+export declare function normalizeInjectableCssForTargetWithImports(css: string, file: string): NormalizeInjectableCssResult;
+export declare function isStyleImportRequest(request: string | undefined): boolean;
+export declare function collectImportedStyleFiles(css: string, targetFile: string): Set<string>;
+export declare function normalizeMarkerOutputFile(markerFile: string, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): string;
+export declare function isMatchingGeneratedCssMarkerFile(targetFile: string, markerFile: string | undefined, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): boolean;
+export declare function resolveViteProcessedCssAssetSource(file: string, rawSource: string, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): string;
+export declare function collectMatchingGeneratedCssMarkerFiles(file: string, rawSource: string, resolveViteProcessedCssOutputFile: ((file: string) => string | undefined) | undefined): string[];
+export declare function collectRootStyleBundleCssSources(bundle: OutputBundle, excludedFile: string): string[];
+export declare function removeDuplicateUnlinkedRootCssAssetsReferencedByHtml(bundle: OutputBundle, options?: {
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+}): number;

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

@@ -0,0 +1,3 @@
+export declare function isCssOutputFile(file: string): boolean;
+export declare function isRootStyleOutputFile(file: string): boolean;
+export declare function isMiniProgramStyleOutputFile(file: string): boolean;

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

@@ -1,71 +1,4 @@
-import type { OutputAsset, OutputBundle } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy';
-import type { InternalUserDefinedOptions } from '../../types';
-interface CssAssetMarkerMatcher {
-    (asset: OutputAsset, file?: string): boolean;
-}
-interface CssAssetProcessedMarker {
-    (asset: OutputAsset, file?: string): void;
-}
-interface CssAssetResultRecordOptions {
-    injectIntoMain?: boolean | undefined;
-    outputFile?: string | undefined;
-}
-interface CssAssetResultRecorder {
-    (file: string, css: string, options?: CssAssetResultRecordOptions): void;
-}
-interface CssAssetResultsGetter {
-    (): Iterable<[string, string | {
-        css: string;
-        injectIntoMain?: boolean | undefined;
-        outputFile?: string | undefined;
-    }]>;
-}
-interface CollectViteProcessedCssAssetOptions {
-    opts?: InternalUserDefinedOptions | undefined;
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
-    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
-    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
-    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
-    recordCssAssetResult?: CssAssetResultRecorder | undefined;
-    recordViteProcessedCssAssetResult?: CssAssetResultRecorder | undefined;
-    resolveViteProcessedCssOutputFile?: ((file: string) => string | undefined) | undefined;
-    subpackageRoots?: Set<string> | undefined;
-    transformCss?: ((css: string, file: string) => string) | undefined;
-    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
-}
-interface InjectViteProcessedCssAssetOptions {
-    opts: InternalUserDefinedOptions;
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
-    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
-    getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
-    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
-    recordCssAssetResult?: CssAssetResultRecorder | undefined;
-    shouldRemoveInjectedSourceAsset?: ((file: string, record: {
-        file: string;
-        css: string;
-        injectIntoMain?: boolean | undefined;
-        outputFile?: string | undefined;
-    }) => boolean) | undefined;
-    transformCss?: ((css: string, file: string) => string) | undefined;
-    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
-    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
-}
-export declare function removeDuplicateUnlinkedRootCssAssetsReferencedByHtml(bundle: OutputBundle, options?: {
-    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
-}): number;
-export declare function removeScopedTailwindPreflightCss(css: string): string;
-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;
-export declare function isCssImportOnlyBundleAsset(bundle: OutputBundle, file: string, css: string): boolean;
-export declare function collectViteProcessedCssAssetResults(bundle: OutputBundle, options: CollectViteProcessedCssAssetOptions): number;
-export declare function injectViteProcessedCssIntoMainCssAssets(bundle: OutputBundle, options: InjectViteProcessedCssAssetOptions): number;
-export {};
+export { isCssImportOnlyBundleAsset } from './processed-css-assets/cleanup';
+export { collectViteProcessedCssAssetResults, injectViteProcessedCssIntoMainCssAssets } from './processed-css-assets/collector';
+export { removeCssCoveredByRootStyleAssets, removeCssCoveredByRootStyleBundleSources, removeScopedTailwindPreflightCss } from './processed-css-assets/coverage';
+export { removeDuplicateUnlinkedRootCssAssetsReferencedByHtml } from './processed-css-assets/markers-imports';

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

@@ -10,6 +10,7 @@ interface RewriteCssImportsOptions {
             fileName: string;
             source: string;
         }) => string;
+        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     }) => Promise<string | undefined> | string | undefined) | undefined;
     shouldOwnTailwindGeneration?: boolean | undefined;
     shouldRewrite: boolean;

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

@@ -7,6 +7,7 @@ interface ViteCssGenerationOptions {
             fileName: string;
             source: string;
         }) => string;
+        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     }) => Promise<string | undefined> | string | undefined;
     getCommand: () => string | undefined;
     onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;

package/dist/bundlers/vite/shared/create-framework-plugins-runtime.d.ts

@@ -0,0 +1,2 @@
+declare function createViteFrameworkPlugins(options: {} | undefined, frameworkBranch: any): any;
+export { createViteFrameworkPlugins };

package/dist/bundlers/vite/shared/create-framework-plugins.d.ts

@@ -1,11 +1,11 @@
 import type { Plugin, ResolvedConfig } from 'vite';
 import type { ViteFrameworkName } from '../../framework-selector';
+import type { createViteRuntimeClassSet } from '../runtime-class-set';
 import type { ViteFrameworkCssPipelineStrategy, ViteFrameworkExtraPluginPlatform, ViteFrameworkRuntimeFeatureContext } from './framework-strategy';
+import type { getCompilerContext } from '../../../context';
+import type { toCustomAttributesEntities } from '../../../context/custom-attributes';
 import type { ViteStyleInjectorDelegateFactory } from '../../../style-injector/internal';
 import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
-import { getCompilerContext } from '../../../context';
-import { toCustomAttributesEntities } from '../../../context/custom-attributes';
-import { createViteRuntimeClassSet } from '../runtime-class-set';
 export interface WeappTailwindcssVitePlugin {
     name: string;
     [hook: string]: any;
@@ -14,7 +14,7 @@ export interface ViteFrameworkBranchContext {
     frameworkName: ViteFrameworkName;
     adaptWatchCssBeforeFrameworkCache?: boolean;
     createExtraPlugins?: (context: ViteFrameworkExtraPluginContext) => Plugin[];
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy;
     getExtraPluginPlatform?: () => ViteFrameworkExtraPluginPlatform;
     styleInjectorDelegate: ViteStyleInjectorDelegateFactory;
     isRuntimeClassSetFeatureEnabled?: (context: ViteFrameworkRuntimeFeatureContext) => boolean;

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

@@ -0,0 +1,8 @@
+import type { SourceCandidateCollector, SourceCandidateCollectorOptions } from './types-and-cache';
+export declare function createSourceCandidateCollector(options?: SourceCandidateCollectorOptions): SourceCandidateCollector;
+export declare function getSourceCandidateContentCacheStatsForTest(): {
+    max: number;
+    size: number;
+    keys: string[];
+};
+export declare function clearSourceCandidateContentCacheForTest(): void;

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

@@ -0,0 +1,2 @@
+import type { SourceCandidateCollectorOptions, SourceCandidateStore } from './types-and-cache';
+export declare function createSourceCandidateStore(options?: SourceCandidateCollectorOptions): SourceCandidateStore;