weapp-tailwindcss 5.1.16 → 5.2.0

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

@@ -1,6 +1,6 @@
-import type { BundleSnapshot } from '../bundle-state';
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 interface CreateSubpackageSourceCandidateScopeOptions {
     cssSourceFiles?: Iterable<string> | undefined;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;

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

@@ -6,5 +6,10 @@ export interface ResolveCurrentSourceCandidateSourceOptions {
     rootDir: string;
     sourceRoot?: string | undefined;
 }
+export interface CurrentSourceCandidateFileMatch {
+    confidence: 'exact' | 'suffix';
+    file: string;
+}
+export declare function resolveCurrentSourceCandidateFileMatch(options: ResolveCurrentSourceCandidateSourceOptions): CurrentSourceCandidateFileMatch | undefined;
 export declare function resolveCurrentSourceCandidateFile(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;
 export declare function resolveCurrentSourceCandidateSource(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;

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

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleSnapshot } from '../bundle-state';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 export declare function normalizePackageRoot(root: string): string;
 export declare function collectMiniProgramSubpackageRoots(bundle: Record<string, OutputAsset | OutputChunk>): Set<string> | undefined;
 export declare function isSubpackageOutputFile(file: string, subpackageRoots: Set<string>): boolean;

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

@@ -1,9 +1,22 @@
-import type { RememberedCssSource } from './types';
+import type { RememberedCssSource } from './types.js';
 export interface TemporaryCssSourceEntry {
     file: string;
     outputFile: string;
     source: string;
 }
+export interface CollectTemporaryCssSourceEntriesOptions {
+    configuredEntries: TemporaryCssSourceEntry[];
+    configuredScopeEntries: TemporaryCssSourceEntry[];
+    currentSubpackageRoots: string[] | undefined;
+    explicitSourceFileKeys: ReadonlySet<string>;
+    isSubpackageOutputFile: (file: string, roots: string[]) => boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    rememberedEntries: TemporaryCssSourceEntry[];
+    resolveRuntimeLinkedSource: (file: string) => TemporaryCssSourceEntry | undefined;
+    runtimeLinkedCssFiles: Iterable<string>;
+    shouldSelectConfiguredRootOutput: (outputFile: string) => boolean;
+}
+export declare function collectTemporaryCssSourceEntries(options: CollectTemporaryCssSourceEntriesOptions): TemporaryCssSourceEntry[];
 export declare function isTemporaryCssAssetFile(file: string): boolean;
 export declare function createTemporaryCssAssetSourceResolver(entries: TemporaryCssSourceEntry[]): {
     entries: TemporaryCssSourceEntry[];

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

@@ -1,5 +1,5 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 type TransformMatcher = (id: string) => boolean;
 interface TransformFilter {
     include?: TransformMatcher | undefined;

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

@@ -0,0 +1 @@
+export declare function scheduleViteCssTransform(options: any): void;

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

@@ -1,11 +1,12 @@
 import type { OutputAsset } from 'rollup';
 import type { ResolvedConfig } from 'vite';
-import type { HmrTimingRecorder } from '../../shared/hmr-timing';
-import type { BundleSnapshot } from '../bundle-state';
-import type { ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { HmrTimingRecorder } from '../../shared/hmr-timing.js';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { ViteCssAssetIdentity } from '../css-asset-identity.js';
+import type { ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export interface GenerateBundleContext {
     processMarkupAndScripts?: boolean | undefined;
     processStyles?: boolean | undefined;
@@ -28,6 +29,7 @@ export interface GenerateBundleContext {
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
     isCssAssetProcessed?: (asset: OutputAsset, file?: string) => boolean;
     isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
+    resolveCssAssetIdentity?: (asset: OutputAsset, file?: string) => ViteCssAssetIdentity;
     recordCssAssetResult?: (file: string, css: string) => void;
     recordViteProcessedCssAssetResult?: (file: string, css: string, options?: {
         injectIntoMain?: boolean | undefined;
@@ -51,7 +53,6 @@ export interface GenerateBundleContext {
     getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberCssSource?: (entry: RememberedCssSource, cssRuntimeSignature?: string) => void;
-    refreshRememberedCssSource?: (entry: RememberedCssSource) => Promise<RememberedCssSource | undefined> | RememberedCssSource | undefined;
     getRememberedCssSources?: () => Iterable<[string, RememberedCssSource]>;
     getRememberedCssSignature?: (file: string) => string | undefined;
     setRememberedCssSignature?: (file: string, cssRuntimeSignature: string) => void;

package/dist/bundlers/vite/generate-bundle/uni-app-x-postprocess.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { CssHandlerOptionsCache } from './css-handler-options';
-import type { GenerateBundleContext } from './types';
+import type { CssHandlerOptionsCache } from './css-handler-options.js';
+import type { GenerateBundleContext } from './types.js';
 interface HandleUniAppXPostCssOptions {
     bundle: Record<string, OutputAsset | OutputChunk>;
     debug: GenerateBundleContext['debug'];
@@ -15,6 +15,7 @@ interface HandleUniAppXPostCssOptions {
     opts: GenerateBundleContext['opts'];
     runtimeState: GenerateBundleContext['runtimeState'];
     styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    deferStylePlaceholderInjection?: boolean;
 }
 export declare function handleUniAppXPostCssTasks(options: HandleUniAppXPostCssOptions): Promise<string[]>;
 export {};

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

@@ -0,0 +1,22 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { OutputAsset } from 'rollup';
+import type { GenerateBundleContext } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export interface ValidateRuntimeCandidatesOptions {
+    cssEntries: Array<{
+        file: string;
+        output: OutputAsset;
+    }>;
+    debug: GenerateBundleContext['debug'];
+    getCssHandlerOptions: (file: string) => IStyleHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => IStyleHandlerOptions;
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    hasMultipleConfiguredCssEntries: boolean;
+    normalizeMiniProgramGeneratorRawSource: (source: string, outputFile: string) => string;
+    opts: InternalUserDefinedOptions;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    sourceCandidates: Set<string>;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    transformRuntime: Set<string>;
+}
+export declare function validateRuntimeCandidates(options: ValidateRuntimeCandidatesOptions): Promise<void>;

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

@@ -1,8 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types';
-export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names';
-export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output';
-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';
+import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types.js';
+export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names.js';
+export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output.js';
+export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css.js';
+export { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output.js';
+export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types.js';
 export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, options: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;

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

@@ -1,4 +1 @@
-import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
-export declare function createRuntimeEntries(snapshot: BundleSnapshot): BundleStateEntry[];
-export declare function collectChangedRuntimeFiles(snapshot: BundleSnapshot): Set<string>;
-export declare function resolveEntryExtension(entry: BundleStateEntry): string;
+export { collectChangedRuntimeFiles, createRuntimeEntries, resolveEntryExtension, } from '../../shared/runtime-class-set/entries.js';

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

@@ -1,3 +1 @@
-export declare function createEscapeFragments(escapeMap: Record<string, string>): string[];
-export declare function collectEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;
-export declare function collectStrictEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;
+export { collectEscapedRuntimeCandidates, collectStrictEscapedRuntimeCandidates, createEscapeFragments, } from '../../shared/runtime-class-set/escaped-candidates.js';

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

@@ -1,30 +1,2 @@
-import type { BundleSnapshot } from './bundle-state';
-import type { TailwindcssRuntimeLike } from '../../types';
-import type { IArbitraryValues } from '../../types/shared';
-import { extractRawCandidatesWithPositions, extractValidCandidates } from '@tailwindcss-mangle/engine';
-type ExtractValidCandidatesOptions = Parameters<typeof extractValidCandidates>[0];
-type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
-    content?: string;
-    extension?: string;
-};
-type ExtractValidCandidatesFn = (options?: MemoryExtractValidCandidatesOptions) => Promise<string[]>;
-type ExtractRawCandidateResult = Awaited<ReturnType<typeof extractRawCandidatesWithPositions>>;
-type ExtractRawCandidatesFn = (content: string, extension?: string, options?: {
-    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
-}) => Promise<ExtractRawCandidateResult>;
-export interface BundleRuntimeClassSetManager {
-    sync: (runtime: TailwindcssRuntimeLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
-    reset: () => Promise<void>;
-}
-export interface BundleRuntimeClassSetSyncOptions {
-    baseClassSet?: Set<string> | undefined;
-    skipInitialFullScanWithBase?: boolean | undefined;
-}
-interface CreateBundleRuntimeClassSetManagerOptions {
-    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
-    escapeMap?: Record<string, string> | undefined;
-    extractCandidates?: ExtractValidCandidatesFn;
-    extractRawCandidates?: ExtractRawCandidatesFn;
-}
-export declare function createBundleRuntimeClassSetManager(options?: CreateBundleRuntimeClassSetManagerOptions): BundleRuntimeClassSetManager;
-export {};
+export { createRuntimeClassSetManager as createBundleRuntimeClassSetManager, } from '../shared/runtime-class-set.js';
+export type { RuntimeClassSetManager as BundleRuntimeClassSetManager, RuntimeClassSetSyncOptions as BundleRuntimeClassSetSyncOptions, CreateRuntimeClassSetManagerOptions as CreateBundleRuntimeClassSetManagerOptions, } from '../shared/runtime-class-set.js';

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

@@ -1,4 +1,4 @@
-import type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins';
-import type { UserDefinedOptions } from '../../types';
-export type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins';
+import type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins.js';
+import type { UserDefinedOptions } from '../../types/index.js';
+export type { WeappTailwindcssVitePlugin } from './shared/create-framework-plugins.js';
 export declare function WeappTailwindcss(options?: UserDefinedOptions): WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/js-precheck.d.ts

@@ -1 +1 @@
-export { shouldSkipJsTransform as shouldSkipViteJsTransform } from '../../js/precheck';
+export { shouldSkipJsTransform as shouldSkipViteJsTransform } from '../../js/precheck.js';

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

@@ -1,7 +1,8 @@
 import type { OutputAsset, OutputBundle } from 'rollup';
-import type { CollectViteProcessedCssAssetOptions } from './markers-imports';
+import type { CollectViteProcessedCssAssetOptions } from './markers-imports.js';
 export declare function restoreCssImportAtRules(source: string, filtered: string, file?: string): string;
 export declare function removeCommentOnlyAtRules(css: string): string;
+export declare function removeEmptyCssAtRules(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;

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

@@ -1,4 +1,4 @@
 import type { OutputBundle } from 'rollup';
-import type { CollectViteProcessedCssAssetOptions, InjectViteProcessedCssAssetOptions } from './markers-imports';
+import type { CollectViteProcessedCssAssetOptions, InjectViteProcessedCssAssetOptions } from './markers-imports.js';
 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

@@ -1,5 +1,5 @@
 import type { OutputBundle } from 'rollup';
-import type { CssAssetMarkerMatcher, CssAssetResultRecorder } from './markers-imports';
+import type { CssAssetMarkerMatcher, CssAssetResultRecorder } from './markers-imports.js';
 import { postcss } from '@weapp-tailwindcss/postcss';
 export declare function normalizeCssSignatureValue(value: string): string;
 export declare function collectRootScopedComparableCssCoverage(cssSources: string[]): {

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

@@ -0,0 +1 @@
+export declare function hasEmptyAtRuleBlockCandidate(css: string): boolean;

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

@@ -1,8 +1,8 @@
 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';
+import type { ComparableCssCoverage } from './coverage.js';
+import type { InjectViteProcessedCssAssetOptions } from './markers-imports.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export { isMiniProgramStyleOutputFile, isRootStyleOutputFile } from './style-files.js';
 export declare function shouldInjectViteProcessedCssResult(opts: InternalUserDefinedOptions, targetFile: string, sourceFile: string, options: {
     injectIntoMain?: boolean | undefined;
     outputFile?: string | undefined;

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

@@ -1,7 +1,7 @@
 import type { OutputAsset, OutputBundle } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { InternalUserDefinedOptions } from '../../../types';
-export { isCssOutputFile } from './style-files';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export { isCssOutputFile } from './style-files.js';
 export interface CssAssetMarkerMatcher {
     (asset: OutputAsset, file?: string): boolean;
 }
@@ -55,8 +55,8 @@ export interface InjectViteProcessedCssAssetOptions {
 }
 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>;
+    currentGeneratorBranch: ReturnType<typeof import("../../../runtime-branch.js").resolveGeneratorRuntimeBranch>;
+    currentGeneratorOptions: ReturnType<typeof import("../../../index.js").normalizeWeappTailwindcssGeneratorOptions>;
     opts: InternalUserDefinedOptions;
     resolvedConfig: import("vite").ResolvedConfig | undefined;
     resolveStylePlatform: () => string | undefined;

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

@@ -1,4 +1,4 @@
-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';
+export { isCssImportOnlyBundleAsset } from './processed-css-assets/cleanup.js';
+export { collectViteProcessedCssAssetResults, injectViteProcessedCssIntoMainCssAssets } from './processed-css-assets/collector.js';
+export { removeCssCoveredByRootStyleAssets, removeCssCoveredByRootStyleBundleSources, removeScopedTailwindPreflightCss } from './processed-css-assets/coverage.js';
+export { removeDuplicateUnlinkedRootCssAssetsReferencedByHtml } from './processed-css-assets/markers-imports.js';

package/dist/bundlers/vite/resolve-app-type.d.ts

@@ -1 +1 @@
-export { resolveImplicitAppTypeFromViteRoot } from '../../framework';
+export { resolveImplicitAppTypeFromViteRoot } from '../../framework/index.js';

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

@@ -1,5 +1,6 @@
 import type { Plugin } from 'vite';
-import type { AppType } from '../../types';
+import type { CssStage } from '../../compiler/index.js';
+import type { AppType } from '../../types/index.js';
 interface RewriteCssImportsOptions {
     appType?: AppType | undefined;
     getAppType?: (() => AppType | undefined) | undefined;
@@ -10,7 +11,7 @@ interface RewriteCssImportsOptions {
             fileName: string;
             source: string;
         }) => string;
-        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
+        cssStage?: CssStage | undefined;
     }) => Promise<string | undefined> | string | undefined) | undefined;
     shouldOwnTailwindGeneration?: boolean | undefined;
     shouldRewrite: boolean;

package/dist/bundlers/vite/runtime-affecting-signature.d.ts

@@ -1,2 +1 @@
-import type { EntryType } from './bundle-state';
-export declare function createRuntimeAffectingSourceSignature(source: string, type: EntryType): string;
+export { createRuntimeAffectingSourceSignature } from '../../compiler/runtime-affecting-signature.js';

package/dist/bundlers/vite/runtime-candidate-entry.d.ts

@@ -0,0 +1,9 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { RuntimeEntryType } from '../../compiler/index.js';
+interface RuntimeCandidateBundleEntry {
+    file: string;
+    output: OutputAsset | OutputChunk;
+    type: RuntimeEntryType;
+}
+export declare function isRuntimeCandidateBundleEntry(entry: RuntimeCandidateBundleEntry): boolean;
+export {};

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

@@ -1,5 +1,5 @@
-import type { BundleSnapshot } from './bundle-state';
-import type { InternalUserDefinedOptions } from '../../types';
+import type { BundleSnapshot } from './bundle-state.js';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
 interface CreateViteRuntimeClassSetOptions {
     opts: InternalUserDefinedOptions;
     initialTailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
@@ -11,9 +11,9 @@ interface CreateViteRuntimeClassSetOptions {
 }
 export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClassSetOptions): {
     runtimeState: {
-        tailwindRuntime: import("@/types").TailwindcssRuntimeLike;
+        tailwindRuntime: import("../../types/index.js").TailwindcssRuntimeLike;
         readyPromise: Promise<void>;
-        refreshTailwindcssRuntime: (options?: import("@/types").RefreshTailwindcssRuntimeOptions) => Promise<import("@/types").TailwindcssRuntimeLike>;
+        refreshTailwindcssRuntime: (options?: import("../../types/index.js").RefreshTailwindcssRuntimeOptions) => Promise<import("../../types/index.js").TailwindcssRuntimeLike>;
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;

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

@@ -1,4 +1,5 @@
 import type { Plugin } from 'vite';
+import type { CssStage } from '../../compiler/index.js';
 interface ViteCssGenerationOptions {
     generateCss: (id: string, code: string, hookContext?: {
         addWatchFile?: (id: string) => void;
@@ -7,7 +8,7 @@ interface ViteCssGenerationOptions {
             fileName: string;
             source: string;
         }) => string;
-        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
+        cssStage?: CssStage | undefined;
     }) => Promise<string | undefined> | string | undefined;
     getCommand: () => string | undefined;
     onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;

package/dist/bundlers/vite/serve-js-transform.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from 'vite';
-import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../types';
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../types/index.js';
 interface ViteServeJsTransformOptions {
     createHandlerOptions: (absoluteFilename: string, extra?: CreateJsHandlerOptions) => CreateJsHandlerOptions;
     getCommand: () => string | undefined;

package/dist/bundlers/vite/serve-root-import-shell.d.ts

@@ -1,4 +1,4 @@
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from './shared/framework-strategy.js';
 export declare function resolveViteServeRootMiniProgramImportShell(options: {
     css: string;
     cssPipelineContext: ViteFrameworkCssPipelineContext;

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 type { ViteFrameworkName } from '../../framework-selector.js';
+import type { createViteRuntimeClassSet } from '../runtime-class-set.js';
+import type { ViteFrameworkCssPipelineStrategy, ViteFrameworkExtraPluginPlatform, ViteFrameworkRuntimeFeatureContext } from './framework-strategy.js';
+import type { getCompilerContext } from '../../../context/index.js';
+import type { toCustomAttributesEntities } from '../../../context/custom-attributes.js';
+import type { ViteStyleInjectorDelegateFactory } from '../../../style-injector/internal.js';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../types/index.js';
 export interface WeappTailwindcssVitePlugin {
     name: string;
     [hook: string]: any;

package/dist/bundlers/vite/shared/framework-hmr-candidate-state.d.ts

@@ -0,0 +1,45 @@
+interface CandidateDelta {
+    addedCandidates: Set<string>;
+    removedCandidates: Set<string>;
+}
+export interface ViteSourceCandidateChange extends CandidateDelta {
+    file: string;
+    runtimeAffecting: boolean;
+}
+interface ViteHmrModule {
+    file?: string | null;
+    id?: string | null;
+    url?: string | null;
+}
+interface ViteHmrGeneratorOptions {
+    hmr: {
+        preserveDeletedCss: boolean;
+    };
+    target: string;
+}
+interface CreateViteHmrCandidateStateOptions {
+    cleanGeneratedCssByFile: Map<string, string>;
+    generatedClassSetByFile: Map<string, Set<string>>;
+    getCommand: () => string | undefined;
+    getGeneratorOptions: () => ViteHmrGeneratorOptions;
+    getSourceCandidate: (file: string) => string | undefined;
+}
+export declare function createViteHmrCandidateState(options: CreateViteHmrCandidateStateOptions): {
+    apply: (change: ViteSourceCandidateChange) => ViteSourceCandidateChange;
+    armTargets: (cssModules: ViteHmrModule[], fallbackCssIds: Iterable<string>) => void;
+    clear: () => void;
+    createChange: (file: string, change: CandidateDelta, changeOptions?: {
+        runtimeAffecting?: boolean;
+    }) => ViteSourceCandidateChange;
+    finishTarget: (file: string) => void;
+    hasPendingCandidateAppend: () => boolean;
+    hasPendingChange: () => boolean;
+    queueFullRegeneration: () => void;
+    resolve: (generatorCode: string, file: string) => ViteSourceCandidateChange | undefined;
+    shouldForceFullRegeneration: (resolved: boolean) => boolean;
+    snapshotDebugState: () => {
+        pendingAddedCandidates: number;
+        pendingCssTargets: number;
+    };
+};
+export {};

package/dist/bundlers/vite/shared/framework-post-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function createFrameworkPostPlugin(options: any): Plugin;

package/dist/bundlers/vite/shared/framework-processed-css-registry.d.ts

@@ -0,0 +1,22 @@
+export interface ViteProcessedCssRecord {
+    css: string;
+    injectIntoMain?: boolean | undefined;
+    outputFile?: string | undefined;
+}
+export declare function createFrameworkProcessedCssRegistry(): {
+    entries: () => MapIterator<[string, ViteProcessedCssRecord]>;
+    get: (file: string) => ViteProcessedCssRecord | undefined;
+    getStats: () => {
+        viteProcessedCssAssetResults: number;
+        viteProcessedCssAssetResultsRaw: {
+            bytes: number;
+            mb: number;
+            size: number;
+        };
+    };
+    markSource: (file: string) => void;
+    matchesIdentity: (candidate: string) => boolean;
+    prune: (activeFiles: Set<string>) => void;
+    record: (file: string, css: string, options?: Omit<ViteProcessedCssRecord, "css">) => void;
+    sourceFiles: Set<string>;
+};

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

@@ -0,0 +1 @@
+export declare function sameStringList(first?: readonly string[], second?: readonly string[]): boolean;

package/dist/bundlers/vite/shared/framework-source-candidates-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function createFrameworkSourceCandidatesPlugin(options: any): Plugin;

package/dist/bundlers/vite/shared/framework-source-scan-session.d.ts

@@ -0,0 +1,38 @@
+import type { createViteCssMemory } from '../css-memory.js';
+import type { createViteRuntimeClassSet } from '../runtime-class-set.js';
+import type { createSourceCandidateCollector } from '../source-candidates.js';
+import type { createViteHmrCandidateState } from './framework-hmr-candidate-state.js';
+type SourceCandidateCollector = ReturnType<typeof createSourceCandidateCollector>;
+type CssMemory = ReturnType<typeof createViteCssMemory>;
+type RuntimeState = ReturnType<typeof createViteRuntimeClassSet>['runtimeState'];
+type HmrCandidateState = ReturnType<typeof createViteHmrCandidateState>;
+interface FrameworkSourceScanSessionOptions {
+    cssMemory: CssMemory;
+    debug: (...args: any[]) => void;
+    getResolvedConfig: () => any;
+    hmrCandidateState: HmrCandidateState;
+    isCandidateRequest: (id: string) => boolean;
+    isWatchLikeBuild: () => boolean;
+    opts: any;
+    runtimeState: RuntimeState;
+    shouldOwnTailwindGeneration: boolean;
+    sourceCandidateCollector: SourceCandidateCollector;
+}
+export declare function createFrameworkSourceScanSession(options: FrameworkSourceScanSessionOptions): {
+    cacheCurrent: () => void;
+    getStats: () => {
+        pendingSourceCandidateSyncByFile: number;
+        pendingSourceCandidateSyncs: number;
+        sourceCandidateScanCache: number;
+    };
+    invalidate: () => void;
+    isDependency: (file: string) => boolean;
+    matches: (file: string) => boolean;
+    shouldDiscoverAutoCssSources: (autoCssSourcesDiscovered: boolean) => boolean;
+    sync: (syncOptions?: {
+        force?: boolean;
+    }) => Promise<void>;
+    syncChangedFile: (id: string, sourceOverride?: string) => any;
+    waitForPendingSyncs: () => Promise<void>;
+};
+export {};

package/dist/bundlers/vite/shared/framework-strategy.d.ts

@@ -1,9 +1,9 @@
 import type { OutputBundle } from 'rollup';
 import type { ResolvedConfig } from 'vite';
-import type { getCompilerContext } from '../../../context';
-import type { normalizeWeappTailwindcssGeneratorOptions } from '../../../generator';
-import type { resolveGeneratorRuntimeBranch } from '../../../runtime-branch';
-import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types';
+import type { getCompilerContext } from '../../../context/index.js';
+import type { normalizeWeappTailwindcssGeneratorOptions } from '../../../generator/index.js';
+import type { resolveGeneratorRuntimeBranch } from '../../../runtime-branch.js';
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types/index.js';
 export interface ViteFrameworkExtraPluginPlatform {
     isIosPlatform?: boolean | undefined;
 }

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

@@ -1,13 +1,2 @@
-import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
-export interface SourceCandidateScanRoot {
-    root: string;
-    entries?: TailwindSourceEntry[] | undefined;
-    explicit?: boolean | undefined;
-}
-export interface SourceCandidateScanSignatureInput {
-    inlineCandidates?: TailwindInlineSourceCandidates | undefined;
-    outDir?: string | undefined;
-    roots: SourceCandidateScanRoot[];
-    scanAllSources?: boolean | undefined;
-}
-export declare function createSourceCandidateScanSignature(input: SourceCandidateScanSignatureInput): string;
+export { createSourceCandidateScanSignature, } from '../shared/source-candidate-scan-signature.js';
+export type { SourceCandidateScanRoot, SourceCandidateScanSignatureInput, } from '../shared/source-candidate-scan-signature.js';

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

@@ -1,10 +1 @@
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-interface ResolveSourceCandidateScanFilesOptions {
-    entries?: TailwindSourceEntry[] | undefined;
-    explicit?: boolean | undefined;
-    filter: (id: string) => boolean;
-    outDir?: string | undefined;
-    root: string;
-}
-export declare function resolveSourceCandidateScanFiles(options: ResolveSourceCandidateScanFilesOptions): Promise<string[]>;
-export {};
+export { resolveSourceCandidateScanFiles } from '../../shared/source-candidates/scan-root.js';

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

@@ -1,4 +1 @@
-export { clearSourceCandidateContentCacheForTest, createSourceCandidateCollector, getSourceCandidateContentCacheStatsForTest } from './source-candidates/collector';
-export { createSourceCandidateStore } from './source-candidates/store';
-export { isSourceCandidateRequest } from './source-candidates/types-and-cache';
-export type { SourceCandidateChange, SourceCandidateCollector, SourceCandidateCollectorOptions, SourceCandidateCollectorSnapshot, SourceCandidateFilterOptions, SourceCandidateStore } from './source-candidates/types-and-cache';
+export * from '../shared/source-candidates.js';