weapp-tailwindcss 5.1.15 → 5.2.0

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

@@ -1,49 +1,22 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { OutputEntry } from './bundle-entries';
-import type { InternalUserDefinedOptions } from '../../types';
-export type EntryType = 'html' | 'js' | 'css' | 'other';
-export interface BundleStateEntry {
-    file: string;
+import type { OutputEntry } from './bundle-entries.js';
+import type { RuntimeCompilationBuildState, RuntimeCompilationSnapshot, RuntimeEntryType, RuntimeSnapshotEntry, UpdateRuntimeCompilationBuildStateOptions } from '../../compiler/index.js';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
+export type EntryType = RuntimeEntryType;
+export interface BundleStateEntry extends RuntimeSnapshotEntry {
     output: OutputAsset | OutputChunk;
-    source: string;
-    type: EntryType;
 }
-export interface ProcessFileSets {
-    html: Set<string>;
-    js: Set<string>;
-    css: Set<string>;
-}
-export interface BundleSnapshot {
-    entries: BundleStateEntry[];
+export interface BundleSnapshot extends RuntimeCompilationSnapshot<BundleStateEntry> {
     jsEntries: Map<string, OutputEntry>;
-    sourceHashByFile: Map<string, string>;
-    runtimeAffectingSignatureByFile: Map<string, string>;
-    runtimeAffectingHashByFile: Map<string, string>;
-    hasOmittedKnownFiles: boolean;
-    changedByType: Record<EntryType, Set<string>>;
-    runtimeAffectingChangedByType: Record<EntryType, Set<string>>;
-    processFiles: ProcessFileSets;
-    linkedImpactsByEntry: Map<string, Set<string>>;
-}
-export interface BundleBuildState {
-    iteration: number;
-    sourceHashByFile: Map<string, string>;
-    runtimeAffectingSignatureByFile: Map<string, string>;
-    runtimeAffectingHashByFile: Map<string, string>;
-    linkedByEntry: Map<string, Set<string>>;
-    dependentsByLinkedFile: Map<string, Set<string>>;
-    bundleMarkupCandidatesByFile: Map<string, Set<string>>;
-    generatorCandidateSignature?: string | undefined;
-}
-interface UpdateBundleBuildStateOptions {
-    incremental?: boolean;
 }
-interface BuildBundleSnapshotOptions {
+export type BundleBuildState = RuntimeCompilationBuildState;
+export interface BuildBundleSnapshotOptions {
     hasOmittedKnownFiles?: boolean | undefined;
+    removedFiles?: Iterable<string> | undefined;
 }
+export declare function runWithRemovedBundleFiles<T>(removedFiles: Iterable<string>, run: () => Promise<T>): Promise<T>;
 export declare function createBundleBuildState(): BundleBuildState;
 export declare function classifyBundleEntry(file: string, opts: InternalUserDefinedOptions): EntryType;
 export declare function buildBundleSnapshot(bundle: Record<string, OutputAsset | OutputChunk>, opts: InternalUserDefinedOptions, outDir: string, state: BundleBuildState, forceAll?: boolean, options?: BuildBundleSnapshotOptions): BundleSnapshot;
 export declare function buildBundleSnapshotForBuild(bundle: Record<string, OutputAsset | OutputChunk>, opts: InternalUserDefinedOptions, outDir: string): BundleSnapshot;
-export declare function updateBundleBuildState(state: BundleBuildState, snapshot: BundleSnapshot, linkedByEntry: Map<string, Set<string>>, options?: UpdateBundleBuildStateOptions): void;
-export {};
+export declare function updateBundleBuildState(state: BundleBuildState, snapshot: BundleSnapshot, linkedByEntry: Map<string, Set<string>>, options?: UpdateRuntimeCompilationBuildStateOptions): void;

package/dist/bundlers/vite/css-asset-identity.d.ts

@@ -0,0 +1,11 @@
+import type { OutputAsset } from 'rollup';
+export type ViteCssAssetIdentityKind = 'user' | 'generator-placeholder' | 'bundler-generated';
+export interface ViteCssAssetIdentity {
+    kind: ViteCssAssetIdentityKind;
+    sourceFile?: string | undefined;
+}
+export interface CreateViteCssAssetIdentityResolverOptions {
+    generatorPlaceholderFile: string;
+    isKnownProcessedSource: (file: string) => boolean;
+}
+export declare function createViteCssAssetIdentityResolver(options: CreateViteCssAssetIdentityResolverOptions): (asset: OutputAsset, file?: string) => ViteCssAssetIdentity;

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.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+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.js';
+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.js';

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

@@ -1,4 +1,4 @@
-import type { RememberedCssSource } from './generate-bundle';
+import type { RememberedCssSource } from './generate-bundle.js';
 export declare function normalizeCssSourceIdentity(sourceFile: string): string;
 export declare function shouldCollectTransformedSourceCandidates(id: string): boolean;
 export declare function createViteCssMemory(options: {
@@ -33,7 +33,6 @@ export declare function createViteCssMemory(options: {
     };
     rememberCssSource: (entry: RememberedCssSource, cssRuntimeSignature?: string) => void;
     rememberKnownSfcSource: (id: string, code: string) => void;
-    refreshRememberedCssSource: (remembered: RememberedCssSource) => Promise<RememberedCssSource | undefined>;
     refreshRememberedCssSourceByCurrentFile: (sourceFile: string) => Promise<void>;
     refreshRememberedCssSourceBySourceFile: (sourceFile: string, rawSource: string) => void;
     setRememberedCssSignature: (file: string, cssRuntimeSignature: string) => void;

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

@@ -1,2 +1,2 @@
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
-export declare function createGenericVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
+export declare function createGenericVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../../index.js").WeappTailwindcssVitePlugin[] | undefined;

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

@@ -1,4 +1,4 @@
-import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy';
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
 export declare const taroCssPipelineStrategy: ViteFrameworkCssPipelineStrategy;
 export declare function createTaroVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): any[];

package/dist/bundlers/vite/frameworks/uni-app/index.d.ts

@@ -1,4 +1,4 @@
-import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy';
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
 export declare const uniAppCssPipelineStrategy: ViteFrameworkCssPipelineStrategy;
-export declare function createUniAppVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;
+export declare function createUniAppVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../../index.js").WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/frameworks/uni-app-x/index.d.ts

@@ -1,4 +1,4 @@
-import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy';
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
+import type { ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
 export declare const uniAppXCssPipelineStrategy: ViteFrameworkCssPipelineStrategy;
-export declare function createUniAppXVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;
+export declare function createUniAppXVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../../index.js").WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/frameworks/weapp-vite/index.d.ts

@@ -1,2 +1,2 @@
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types';
-export declare function createWeappVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../..").WeappTailwindcssVitePlugin[] | undefined;
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
+export declare function createWeappVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): import("../../index.js").WeappTailwindcssVitePlugin[] | undefined;

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

@@ -0,0 +1,8 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { AssetEmissionPlan } from '../../../compiler/index.js';
+export interface ApplyViteAssetEmissionPlanOptions {
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    emitOrReplayAsset?: ((file: string, source: string) => OutputAsset | undefined) | undefined;
+    writeTargets?: ReadonlyMap<string, OutputAsset> | undefined;
+}
+export declare function applyViteAssetEmissionPlan(plan: AssetEmissionPlan, options: ApplyViteAssetEmissionPlanOptions): void;

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

@@ -1,7 +1,7 @@
-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';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { createTransformFilter } from './transform-filter.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 interface CollectBundleMarkupCandidatesOptions {
     extractSourceCandidates?: ((file: string, source: string) => Promise<Set<string>>) | undefined;
     previousCandidatesByFile?: ReadonlyMap<string, Set<string>> | undefined;

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

@@ -1,5 +1,5 @@
 import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export interface ConfiguredCssSourceEntry {
     file: string;
     source: string;

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

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

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

@@ -0,0 +1,34 @@
+import type { OutputAsset } from 'rollup';
+import type { RememberedCssSource } from './types.js';
+import type { ICreateCacheReturnType } from '../../../cache/index.js';
+export interface ApplyViteCssCacheResultOptions {
+    applyCssResult: (source: string) => void;
+    cssRuntimeAffectingHash: string;
+    generatorRawSource: string;
+    generatorSourceFile: string;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    markCssAssetProcessed?: ((asset: OutputAsset, file?: string) => void) | undefined;
+    originalSource: OutputAsset;
+    outputFile: string;
+    rememberedCssRuntimeSignature: string;
+    rememberedSourcesCount: number;
+    rememberCssSource?: ((entry: RememberedCssSource, cssRuntimeSignature?: string) => void) | undefined;
+    vitePipelineCssInjectionOutputFile: string;
+}
+export declare function applyViteCssCacheResult(options: ApplyViteCssCacheResultOptions, source: string): void;
+export interface ProcessViteCssCacheTaskOptions {
+    applyResult: (source: string) => void | Promise<void>;
+    cache: ICreateCacheReturnType;
+    cacheKey: string;
+    hashKey: string;
+    onCacheHit: () => void;
+    onSharedCacheHit: () => void;
+    onSharedResult: (source: string) => void;
+    onTransformResult: (source: string) => void;
+    sharedCacheKey?: string | undefined;
+    sharedResultCache: Map<string, Promise<string>>;
+    taskHash: string;
+    transform: () => Promise<string>;
+}
+export declare function processViteCssCacheTask(options: ProcessViteCssCacheTaskOptions): Promise<void>;

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

@@ -0,0 +1,58 @@
+import type { RememberedCssSource } from './types.js';
+export interface CssCompositionHandlerOptions {
+    isMainChunk?: boolean | undefined;
+    sourceOptions?: {
+        cssEntries?: string[] | undefined;
+        sourceFile?: string | undefined;
+    } | undefined;
+}
+export interface ResolveViteCssCompositionPlanOptions<HandlerOptions extends CssCompositionHandlerOptions> {
+    assetSourceFile: string;
+    configuredSourceFileKeys: ReadonlySet<string>;
+    cssEntries: string[] | undefined;
+    cssMatcher: (file: string) => boolean;
+    explicitSourceFileKeys: ReadonlySet<string>;
+    file: string;
+    getCssHandlerOptions: (file: string) => HandlerOptions;
+    getOriginalCssLayerSource: ((file: string) => string | undefined) | undefined;
+    isRootStyleOutputFile: (file: string) => boolean;
+    isWebGeneratorTarget: boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    normalizeGeneratorSource: (source: string, outputFile: string) => string;
+    normalizeGeneratorUserSource: (source: string, sourceFile: string, fallbackFile: string) => string;
+    outputCssHandlerOptions: HandlerOptions;
+    outputFile: string;
+    rawSource: string;
+    rememberedSources: RememberedCssSource[];
+    resolveConfiguredRootInjectionTarget: (sourceFile: string, outputFile: string) => string | undefined;
+    resolveMatchedOutputFile: (sourceFile: string) => string | undefined;
+    resolvedFromTemporarySource: boolean;
+    rootImportShellOutputFile: string;
+    shouldKeepImportedCssShell: boolean;
+    shouldKeepRootImportShell: boolean;
+    shouldMoveRootImportShellToOrigin: boolean;
+    shouldSkipRememberedSource: (source: RememberedCssSource) => boolean;
+    viteProcessedCssAsset: boolean;
+}
+export interface ViteCssCompositionPlan<HandlerOptions extends CssCompositionHandlerOptions> {
+    cssHandlerOptions: HandlerOptions;
+    generatorCssHandlerOptions: HandlerOptions;
+    generatorRawSource: string;
+    generatorSourceFile: string;
+    generatorUserLayerRawSource: string | undefined;
+    hasCurrentTailwindGenerationDirective: boolean;
+    hasRememberedApplySource: boolean;
+    hasSameOutputRememberedTailwindGenerationSource: boolean;
+    hasStaleViteProcessedCssSource: boolean;
+    outputCssHandlerOptions: HandlerOptions;
+    outputFile: string;
+    preserveImportedCssShell: boolean;
+    rememberedSource: RememberedCssSource | undefined;
+    rememberedSources: RememberedCssSource[];
+    rootImportShellTarget: string | undefined;
+    usedConfiguredSourceFile: string | undefined;
+    usesConfiguredTailwindV4FallbackSource: boolean;
+    vitePipelineCssAsset: boolean;
+    webviewRootCssInjectionTarget: string | undefined;
+}
+export declare function resolveViteCssCompositionPlan<HandlerOptions extends CssCompositionHandlerOptions>(options: ResolveViteCssCompositionPlanOptions<HandlerOptions>): ViteCssCompositionPlan<HandlerOptions>;

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

@@ -1,2 +1,2 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function normalizeRelativeCssConfigDirectives(source: string, file: string, outputRoot: string, opts: InternalUserDefinedOptions): string;

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

@@ -0,0 +1 @@
+export declare function processViteCssBundleEntry(options: any): Promise<void>;

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

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types';
+import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types/index.js';
 type CssHandlerOptions = IStyleHandlerOptions & {
     postcssOptions: {
         options: {

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

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function resolveCssBundleOutputFile(options: {
     bundleFiles: string[];
     defaultStyleOutputExtension: string;
@@ -28,6 +28,25 @@ export declare function createMatchedCssSourceOutputResolver(options: {
     originalFileNames?: string[] | undefined;
     resolveOutputFileFromMatchedCssSource: (sourceFile: string | undefined) => string | undefined;
 }): (sourceFile: string | undefined) => string | undefined;
+export type ResolveCssAssetOutputPlanOptions = Parameters<typeof resolveCssBundleOutputFile>[0] & {
+    assetSourceFile: string;
+    configuredEntries: Array<{
+        file: string;
+    }>;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    originalFileNames: string[] | undefined;
+    resolveOutputFileFromMatchedCssSource: (sourceFile: string | undefined) => string | undefined;
+    rootImportShellOutputFile: string;
+    rootImportShellTarget: string | undefined;
+    shouldReuseRootImportShell: () => boolean;
+};
+export interface CssAssetOutputPlan {
+    outputFile: string;
+    resolveMatchedOutputFile: (sourceFile: string | undefined) => string | undefined;
+    resolvedFromConfiguredOriginalCssEntry: boolean;
+    reusedRootImportShellTarget: boolean;
+}
+export declare function resolveCssAssetOutputPlan(options: ResolveCssAssetOutputPlanOptions): CssAssetOutputPlan;
 export declare function hasViteProcessedCssResultForSource(sourceFile: string, getViteProcessedCssAssetResults?: (() => Iterable<[string, unknown]> | undefined) | undefined): boolean;
 export declare function applyCssResultToBundle(options: {
     assetSourceFile: string;

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

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare const SOURCE_STYLE_OUTPUT_EXT_RE: RegExp;
 export declare const CSS_SOURCE_OUTPUT_EXT_RE: RegExp;
 export declare function resolveMiniProgramStyleOutputExtension(options?: {

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

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 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/css-source-plan.d.ts

@@ -0,0 +1,19 @@
+import type { ConfiguredCssSourceEntry } from './configured-css-sources.js';
+import type { RememberedCssSourcePlan, ResolveRememberedCssSourcePlanOptions } from './remembered-css-plan.js';
+export interface ResolveViteCssSourcePlanOptions extends ResolveRememberedCssSourcePlanOptions {
+    configuredEntries: ConfiguredCssSourceEntry[];
+    cwd: string | undefined;
+    getSourceStyleSource: ((file: string) => string | undefined) | undefined;
+    getSourceStyleSources: (() => Iterable<[string, string]>) | undefined;
+    inferenceSourceRoot: string | undefined;
+    isConfiguredSourceProcessed: (sourceFile: string) => boolean;
+    isConfiguredSourceUsed: (sourceFile: string) => boolean;
+    isCurrentRootMiniProgramStyleOutput: boolean;
+    projectRoot: string;
+    selectConfiguredRootSource: () => ConfiguredCssSourceEntry | undefined;
+    shouldKeepRootImportShell: (outputFile: string, rawSource: string) => boolean;
+}
+export interface ViteCssSourcePlan extends RememberedCssSourcePlan {
+    resolution: 'remembered' | 'configured' | 'inferred' | 'temporary' | 'unresolved';
+}
+export declare function resolveViteCssSourcePlan(options: ResolveViteCssSourcePlanOptions): Promise<ViteCssSourcePlan>;

package/dist/bundlers/vite/generate-bundle/css-transform-decision-plan.d.ts

@@ -0,0 +1,61 @@
+import type { ViteCssAssetIdentityKind } from '../css-asset-identity.js';
+export interface ResolveViteCssTransformDecisionPlanOptions {
+    alreadyProcessedCssAsset: boolean;
+    cssAssetIdentityKind: ViteCssAssetIdentityKind;
+    cssIsMainChunk: boolean;
+    generatorCandidateSignatureInitialized: boolean;
+    generatorCandidatesChanged: boolean;
+    generatorRawSource: string;
+    hasCurrentTailwindGenerationDirective: boolean;
+    hasRememberedApplySource: boolean;
+    hasRuntimeAffectingChanges: boolean;
+    hasSameOutputRememberedTailwindGenerationSource: boolean;
+    hasStaleViteProcessedCssSource: boolean;
+    isCollectedBundlerGeneratedCssFile: boolean;
+    isProcessCssFile: boolean;
+    isRuntimeLinkedCss: boolean;
+    rawSource: string;
+    rememberedRawSource?: string | undefined;
+    shouldProcessTailwindGeneration: boolean;
+    shouldRegenerateMainPackageCssWithScopedCandidates: boolean;
+    useIncrementalMode: boolean;
+    vitePipelineCssAsset: boolean;
+    viteProcessedCssAsset: boolean;
+}
+export interface ViteCssTransformDecisionPlan {
+    shouldPreserveCollectedViteCssAsset: boolean;
+    shouldPreserveStaleGeneratedCssAsset: boolean;
+    shouldRefreshViteProcessedCssByCandidates: boolean;
+    shouldRegenerateCollectedViteCss: boolean;
+    shouldReplayLastCss: boolean;
+    shouldReuseProcessedCss: boolean;
+    shouldTrackGeneratorRuntime: boolean;
+    strippedViteProcessedCss: string;
+}
+export declare function resolveViteCssTransformDecisionPlan(options: ResolveViteCssTransformDecisionPlanOptions): ViteCssTransformDecisionPlan;
+export interface ResolveViteCssTransformCachePlanOptions {
+    cssIsMainChunk: boolean;
+    cssRuntimeAffectingHash: string;
+    cssShareScope: string;
+    linkedImpactSignature: string;
+    outputFile: string;
+    runtimeSignature: string;
+    scopedGeneratorCandidateSignature: string;
+    sourceTraceSignature: string;
+    tailwindcssMajorVersion?: number | undefined;
+}
+export interface ViteCssTransformCachePlan {
+    cssCacheKey: string;
+    cssHashKey: string;
+    cssRuntimeSignature: string;
+    cssSharedCacheKey: string;
+    cssTaskHash: string;
+    rememberedCssRuntimeSignature: string;
+}
+export declare function resolveViteCssTransformCachePlan(options: ResolveViteCssTransformCachePlanOptions): ViteCssTransformCachePlan;
+export interface ResolveViteCssLinkedImpactSignatureOptions {
+    changedHtmlFiles: ReadonlySet<string>;
+    changedJsFiles: ReadonlySet<string>;
+    runtimeAffectingSignatureByFile: ReadonlyMap<string, string>;
+}
+export declare function resolveViteCssLinkedImpactSignature(options: ResolveViteCssLinkedImpactSignatureOptions): string;

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

@@ -0,0 +1,23 @@
+import type { ViteCssTransformTaskResult } from './css-transform-task.js';
+export interface ApplyViteCssTransformTaskResultOptions {
+    addWatchFile?: ((id: string) => void) | undefined;
+    debug: (format: string, ...args: unknown[]) => void;
+    debugCssDiff: boolean;
+    file: string;
+    generatorSourceFile: string;
+    outputFile: string;
+    outputIsMainChunk: boolean;
+    recordCssAssetResult?: ((file: string, css: string) => void) | undefined;
+    recordViteProcessedCssAssetResult?: ((file: string, css: string, options?: {
+        injectIntoMain?: boolean | undefined;
+        outputFile?: string | undefined;
+    }) => void) | undefined;
+    result: ViteCssTransformTaskResult;
+    shouldInjectVitePipelineCssIntoMain: boolean;
+    shouldRecordVitePipelineCssByOutput: boolean;
+    tailwindcssMajorVersion?: number | undefined;
+    transformRuntime: Set<string>;
+    vitePipelineCssAsset: boolean;
+    vitePipelineCssInjectionOutputFile: string;
+}
+export declare function applyViteCssTransformTaskResult(options: ApplyViteCssTransformTaskResultOptions): string;

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

@@ -0,0 +1,42 @@
+import type { TailwindV4GenerationCoreInput, TailwindV4GenerationCoreResult } from '../../shared/v4-generation-core.js';
+import { generateTailwindV4Css } from '../../shared/v4-generation-core.js';
+export type ViteCssTransformTaskKind = 'tailwind' | 'web' | 'import-shell' | 'style';
+export interface ViteCssTransformTaskResult {
+    classSet?: Set<string> | undefined;
+    css: string;
+    dependencies: string[];
+    diffSource?: string | undefined;
+    generatorTarget?: TailwindV4GenerationCoreResult['target'] | undefined;
+    kind: ViteCssTransformTaskKind;
+    shouldRecordCssAsset: boolean;
+}
+export interface ExecuteViteCssTransformTaskOptions {
+    annotateCss: (css: string) => string;
+    assetSourceFile?: string | undefined;
+    cssUserHandlerOptions: TailwindV4GenerationCoreInput['cssUserHandlerOptions'];
+    debug: TailwindV4GenerationCoreInput['debug'];
+    file: string;
+    generateCss?: typeof generateTailwindV4Css | undefined;
+    generatorPlatform?: string | undefined;
+    generatorCssHandlerOptions: TailwindV4GenerationCoreInput['cssHandlerOptions'];
+    generatorRawSource: string;
+    generatorSourceFile: string;
+    generatorUserLayerRawSource?: string | undefined;
+    getSourceCandidatesForEntries: TailwindV4GenerationCoreInput['getSourceCandidatesForEntries'];
+    isWebGeneratorTarget: boolean;
+    normalizeGeneratorUserRawSource: (source: string, sourceFile: string, fallbackFile?: string | undefined) => string;
+    normalizeMiniProgramGeneratorRawSource: (source: string, outputFile: string) => string;
+    opts: TailwindV4GenerationCoreInput['opts'];
+    outputFile: string;
+    previousCss?: string | undefined;
+    rawSource: string;
+    removeRootCoveredCssFromScopedAsset: (css: string) => string;
+    runtime: Set<string>;
+    runtimeState: TailwindV4GenerationCoreInput['runtimeState'];
+    styleHandlerOptions: TailwindV4GenerationCoreInput['cssHandlerOptions'];
+    styleHandler: TailwindV4GenerationCoreInput['styleHandler'];
+    transformWebTargetCss: (css: string) => string;
+    usesConfiguredTailwindV4FallbackSource: boolean;
+    vitePipelineCssAsset: boolean;
+}
+export declare function executeViteCssTransformTask(options: ExecuteViteCssTransformTaskOptions): Promise<ViteCssTransformTaskResult>;

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

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { GenerateBundleContext } from './types';
-import type { IStyleHandlerOptions } from '../../../types';
+import type { GenerateBundleContext } from './types.js';
+import type { IStyleHandlerOptions } from '../../../types/index.js';
 export declare function finalizeMiniProgramCssAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: {
     cssMatcher: GenerateBundleContext['opts']['cssMatcher'];
     getCssHandlerOptions: (file: string) => IStyleHandlerOptions;
@@ -9,5 +9,6 @@ export declare function finalizeMiniProgramCssAssets(bundle: Record<string, Outp
     onUpdate: GenerateBundleContext['opts']['onUpdate'];
     recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
     styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    useIncrementalMode?: boolean | undefined;
     debug?: GenerateBundleContext['debug'];
 }): Promise<number>;

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

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