weapp-tailwindcss 5.0.0-next.11 → 5.0.0-next.14

package/dist/{bundle-state-BrtFgX-A.mjs → bundle-state-BOBbxYzQ.mjs}

@@ -1,4 +1,4 @@
-import { d as traverse, u as babelParse } from "./precheck-DtBGFS-n.mjs";
+import { d as traverse, u as babelParse } from "./precheck-DCresEiu.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { Buffer } from "node:buffer";
@@ -241,7 +241,8 @@ function createBundleBuildState() {
 		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
 		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
 		linkedByEntry: /* @__PURE__ */ new Map(),
-		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
 	};
 }
 function createChangedByType() {

package/dist/{bundle-state-BRkhpjio.js → bundle-state-CxtGmT4t.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_precheck = require("./precheck-D5eEdqeH.js");
+const require_precheck = require("./precheck-CZHcFX8k.js");
 let node_module = require("node:module");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
@@ -243,7 +243,8 @@ function createBundleBuildState() {
 		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
 		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
 		linkedByEntry: /* @__PURE__ */ new Map(),
-		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
 	};
 }
 function createChangedByType() {

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

@@ -1,3 +1,8 @@
+import type { CssPreflightOptions } from '../../types';
 export { removeUnsupportedAtSupports, removeUnsupportedMiniProgramAtRules } from './css-cleanup/at-rules';
+interface FinalizeMiniProgramCssOptions {
+    cssPreflight?: CssPreflightOptions | undefined;
+    preservePseudoContentInit?: boolean;
+}
 export declare function hoistTailwindPreflightBase(css: string): string;
-export declare function finalizeMiniProgramCss(css: string): string;
+export declare function finalizeMiniProgramCss(css: string, options?: FinalizeMiniProgramCssOptions): string;

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

@@ -1,11 +1,14 @@
+export interface SourceSideCssEntrySource {
+    css: string;
+    config?: string | undefined;
+    configRequest?: string | undefined;
+    base: string;
+    file: string;
+}
 export declare function resolveSourceSideCssEntrySource(file: string, sourceOptions: {
     projectRoot?: string;
     cwd?: string;
+    outputRoot?: string;
 }, resolveOptions?: {
     removeConfig?: boolean;
-}): {
-    css: string;
-    config: string | undefined;
-    configRequest: string | undefined;
-    base: string;
-} | undefined;
+}): SourceSideCssEntrySource | undefined;

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

@@ -1,10 +1,24 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { NormalizedWeappTailwindcssGeneratorOptions, TailwindResolvedSource } from '../../../generator';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../../types';
 interface GeneratorSourceRuntimeState {
     twPatcher: InternalUserDefinedOptions['twPatcher'];
 }
+interface GeneratorSourceSelectionOptions {
+    runtime?: Set<string> | undefined;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
+}
+export interface GeneratorSourceMetadata {
+    matchedCssSourceFile?: string | undefined;
+    sourceBase?: string | undefined;
+    sourceCss?: string | undefined;
+}
+export type GeneratorResolvedSource = TailwindResolvedSource & {
+    __weappTailwindcssMeta?: GeneratorSourceMetadata | undefined;
+};
 export declare function resolveCssSourceBase(file: string, cssHandlerOptions: IStyleHandlerOptions): string;
-export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<import("@/generator").TailwindV3ResolvedSource | import("tailwindcss-patch").TailwindV4ResolvedSource>;
-export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSource(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource | import("@/generator").TailwindV3ResolvedSource | undefined>;
+export declare function resolveGeneratorSources(majorVersion: number | undefined, runtimeState: GeneratorSourceRuntimeState, rawSource: string, file: string, cssHandlerOptions: IStyleHandlerOptions, generatorOptions?: NormalizedWeappTailwindcssGeneratorOptions, selectionOptions?: GeneratorSourceSelectionOptions): Promise<TailwindResolvedSource[]>;
+export declare function resolveGeneratorSourceEntries(source: TailwindResolvedSource, runtimeState?: GeneratorSourceRuntimeState): Promise<TailwindSourceEntry[] | undefined>;
 export {};

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

@@ -1,4 +1,5 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 export { hasTailwindSourceDirectives, normalizeTailwindSourceForGenerator, removeTailwindSourceDirectives, resolveCssEntrySource, } from './generator-css/directives';
 export { removeTailwindApplyRules, } from './generator-css/legacy-compat';
@@ -16,14 +17,17 @@ export interface GenerateCssByGeneratorOptions {
     file: string;
     cssHandlerOptions: IStyleHandlerOptions;
     cssUserHandlerOptions: IStyleHandlerOptions;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     styleHandler: InternalUserDefinedOptions['styleHandler'];
     debug: (format: string, ...args: unknown[]) => void;
+    previousCss?: string | undefined;
 }
 export interface GenerateCssByGeneratorResult {
     css: string;
     target: string;
     source: 'generator';
     dependencies: string[];
+    incremental?: boolean | undefined;
 }
 export declare function isPureLocalCssImportWrapper(css: string): boolean;
 export declare function generateCssByGenerator(options: GenerateCssByGeneratorOptions): Promise<GenerateCssByGeneratorResult | undefined>;

package/dist/bundlers/shared/hmr-timing.d.ts

@@ -1,5 +1,22 @@
 export interface HmrTimingDetails {
+    emit?: boolean;
     file?: string;
+    hooks?: Record<string, HmrTimingHookSummary>;
+    metric?: 'hook' | 'total';
+    wallMs?: number;
+}
+export interface HmrTimingHookSummary {
+    count: number;
+    durationMs: number;
+    maxMs: number;
+}
+type HmrTimingBundler = 'vite' | 'webpack' | 'gulp';
+export interface HmrTimingRecorder {
+    emitTotal: (phase?: string) => void;
+    measure: <T>(phase: string, task: () => T | Promise<T>, details?: HmrTimingDetails) => Promise<T>;
+    record: (phase: string, durationMs: number, details?: HmrTimingDetails) => void;
 }
 export declare function shouldEmitHmrTiming(): boolean;
-export declare function emitHmrTiming(bundler: 'vite' | 'webpack' | 'gulp', phase: string, durationMs: number, details?: HmrTimingDetails): void;
+export declare function emitHmrTiming(bundler: HmrTimingBundler, phase: string, durationMs: number, details?: HmrTimingDetails): void;
+export declare function createHmrTimingRecorder(bundler: HmrTimingBundler): HmrTimingRecorder;
+export {};

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

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

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

@@ -1,5 +1,6 @@
 import type { OutputAsset } from 'rollup';
 import type { Plugin, ResolvedConfig } from 'vite';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CssFinalizerContext {
     opts: InternalUserDefinedOptions;
@@ -15,6 +16,7 @@ interface CssFinalizerContext {
     recordCssAssetResult?: (file: string, css: string) => void;
     getRecordedGeneratorCandidates?: () => Set<string> | undefined;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string) => void;
 }

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

@@ -6,11 +6,15 @@ type CssHandlerOptions = IStyleHandlerOptions & {
         };
     };
     majorVersion: number | undefined;
+    sourceOptions?: {
+        outputRoot?: string | undefined;
+    } | undefined;
 };
 interface CssHandlerOptionsCacheOptions {
-    appType: InternalUserDefinedOptions['appType'];
+    getAppType: () => InternalUserDefinedOptions['appType'];
     mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
     getMajorVersion: () => number | undefined;
+    getOutputRoot?: (() => string | undefined) | undefined;
 }
 export interface CssHandlerOptionsCache {
     getCssHandlerOptions: (file: string) => CssHandlerOptions;

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

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

@@ -1,6 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { ResolvedConfig } from 'vite';
+import type { HmrTimingRecorder } from '../shared/hmr-timing';
 import type { BundleSnapshot } from './bundle-state';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
@@ -9,18 +11,23 @@ interface GenerateBundleContext {
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
     recordCssAssetResult?: (file: string, css: string) => void;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string, cssRuntimeSignature: string) => void;
     getRememberedMainCssSources?: () => Map<string, string>;
     getRememberedMainCssSignature?: (file: string) => string | undefined;
     setRememberedMainCssSignature?: (file: string, cssRuntimeSignature: string) => void;
     recordGeneratorCandidates?: (candidates: Set<string>) => void;
+    hmrTimingRecorder?: HmrTimingRecorder;
 }
 interface GenerateBundleThis {
     addWatchFile?: (id: string) => void;

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

@@ -15,6 +15,7 @@ export interface BundleRuntimeClassSetManager {
 }
 export interface BundleRuntimeClassSetSyncOptions {
     baseClassSet?: Set<string> | undefined;
+    skipInitialFullScanWithBase?: boolean | undefined;
 }
 interface CreateBundleRuntimeClassSetManagerOptions {
     extractCandidates?: ExtractValidCandidatesFn;

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

@@ -17,6 +17,9 @@ export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClas
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+    }) => Promise<Set<string>>;
 };
 export {};

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

@@ -1,13 +1,24 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 export interface SourceCandidateCollector {
     sync: (id: string, source: string) => Promise<void>;
+    merge: (id: string, source: string) => Promise<void>;
     syncFile: (id: string) => Promise<void>;
     scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
     syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
     remove: (id: string) => void;
     values: () => Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined) => Set<string>;
+    snapshot: () => SourceCandidateCollectorSnapshot;
+    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
     clear: () => void;
 }
+export interface SourceCandidateCollectorSnapshot {
+    candidatesById: Array<[string, string[]]>;
+    scanCandidatesById?: Array<[string, string[]]> | undefined;
+    transformCandidatesById?: Array<[string, string[]]> | undefined;
+    inlineExcludedCandidates: string[];
+    inlineIncludedCandidates: string[];
+}
 interface ScanSourceCandidateRootOptions {
     root: string;
     outDir?: string | undefined;

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

@@ -1,9 +1,26 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../types';
+export interface ResolvedTailwindV4CssEntries {
+    entries: TailwindSourceEntry[];
+    explicit: boolean;
+    inlineCandidates: TailwindInlineSourceCandidates;
+    dependencies: string[];
+}
 export interface ResolvedViteSourceScan {
+    dependencies?: string[] | undefined;
     entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
     inlineCandidates?: TailwindInlineSourceCandidates | undefined;
 }
+interface ResolveViteSourceScanOptions {
+    root?: string | undefined;
+    outDir?: string | undefined;
+}
+export declare function mergeTailwindInlineSourceCandidates(allInlineCandidates: Array<TailwindInlineSourceCandidates | undefined>): TailwindInlineSourceCandidates | undefined;
+export declare function resolveTailwindV4EntriesFromCss(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function resolveViteTailwindV4CssDependencies(css: string, base: string): Promise<string[]>;
-export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike): Promise<ResolvedViteSourceScan | undefined>;
+export declare function resolveTailwindV4EntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
+export declare function discoverTailwindV4CssEntries(root: string, outDir: string | undefined): Promise<string[]>;
+export declare function resolveViteSourceScanEntries(options: UserDefinedOptions, patcher: TailwindcssPatcherLike, scanOptions?: ResolveViteSourceScanOptions): Promise<ResolvedViteSourceScan | undefined>;
 export declare function createViteSourceScanMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export {};

package/dist/bundlers/vite/static-config-content.d.ts

@@ -0,0 +1,5 @@
+type StaticContentValue = string | StaticContentValue[] | {
+    files: StaticContentValue;
+};
+export declare function readStaticConfigContent(configPath: string): StaticContentValue | undefined;
+export {};

package/dist/bundlers/webpack/BaseUnifiedPlugin/shared.d.ts

@@ -15,7 +15,12 @@ interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
     removedFiles?: Set<string>;
 }
+interface RuntimeWatchDependenciesLike {
+    files?: Iterable<string>;
+    contexts?: Iterable<string>;
+}
 export declare function createAssetHashByChunkMap(chunks: Iterable<ChunkLike>): Map<string, string>;
 export declare function createRuntimeAwareCssHash(assetHash: string | undefined, sourceHash: string, runtimeSetHash: string): string;
 export declare function hasWatchChanges(compiler: WebpackWatchChangeLike): boolean;
+export declare function isWatchFileInRuntimeDependencies(file: string, dependencies: RuntimeWatchDependenciesLike): boolean;
 export {};