weapp-tailwindcss 5.1.15 → 5.2.0

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

@@ -0,0 +1,13 @@
+import type { OutputAsset, OutputBundle } from 'rollup';
+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;
+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.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

@@ -0,0 +1,34 @@
+import type { OutputBundle } from 'rollup';
+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[]): {
+    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/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

@@ -0,0 +1,42 @@
+import type { OutputBundle } from 'rollup';
+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;
+}): 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.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export { isCssOutputFile } from './style-files.js';
+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.js").resolveGeneratorRuntimeBranch>;
+    currentGeneratorOptions: ReturnType<typeof import("../../../index.js").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.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,6 +11,7 @@ interface RewriteCssImportsOptions {
             fileName: string;
             source: string;
         }) => string;
+        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,6 +8,7 @@ interface ViteCssGenerationOptions {
             fileName: string;
             source: string;
         }) => string;
+        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-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 { ViteFrameworkCssPipelineStrategy, ViteFrameworkExtraPluginPlatform, ViteFrameworkRuntimeFeatureContext } from './framework-strategy';
-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';
+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;
@@ -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/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';