weapp-tailwindcss 5.0.13 → 5.1.1

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

@@ -3,7 +3,9 @@ import type { BundleSnapshot } from '../bundle-state';
 import type { RememberedCssSource } from './types';
 export declare function extractSfcStyleSources(source: string): string[];
 export declare function hasSfcStyleSources(source: string): boolean;
-export declare function hasTailwindGenerationSource(source: string): boolean;
+export declare function hasTailwindGenerationSource(source: string, options?: {
+    allowRootDirectives?: boolean | undefined;
+}): boolean;
 export declare function resolveSfcStyleSourceFromOutputFile(outputFile: string, snapshot: BundleSnapshot, outputRoot: string, sourceRoot: string | undefined, cssMatcher: ((file: string) => boolean) | undefined, getSfcSource: ((file: string) => string | undefined) | undefined, debug: (format: string, ...args: unknown[]) => void): Promise<RememberedCssSource | undefined>;
 export declare function normalizeSfcSourceFileForCompare(file: string): string;
 export declare function collectChunkModuleIds(output: OutputChunk): string[];

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

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

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

@@ -0,0 +1,9 @@
+export interface ResolveCurrentSourceCandidateSourceOptions {
+    file: string;
+    getSourceCandidateSource?: ((file: string) => string | undefined) | undefined;
+    getSourceCandidateSources?: (() => Iterable<[string, string]> | undefined) | undefined;
+    outDir: string;
+    rootDir: string;
+    sourceRoot?: string | undefined;
+}
+export declare function resolveCurrentSourceCandidateSource(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;

package/dist/bundlers/vite/generate-bundle/tailwind-v4-css-source.d.ts

@@ -0,0 +1,9 @@
+export interface TailwindV4GenerationCssSourceEntry {
+    file: string;
+    source: string;
+}
+export declare function collectTailwindV4SourceFingerprint(source: string): Set<string>;
+export declare function scoreConfiguredTailwindV4SourceForRawSource(rawSource: string | undefined, entrySource: string): number;
+export declare function resolveSubpackageRootForFile(file: string | undefined, subpackageRoots: Set<string> | undefined): string | undefined;
+export declare function isSameSubpackageScope(outputFile: string, sourceFile: string | undefined, subpackageRoots: Set<string> | undefined): boolean;
+export declare function selectTailwindV4GenerationCssSourceForOutput<T extends TailwindV4GenerationCssSourceEntry>(outputFile: string, entries: T[], rawSource?: string, subpackageRoots?: Set<string> | undefined): T | undefined;

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

@@ -0,0 +1,15 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { InternalUserDefinedOptions } from '../../../types';
+type TransformMatcher = (id: string) => boolean;
+interface TransformFilter {
+    include?: TransformMatcher | undefined;
+    exclude?: TransformMatcher | undefined;
+}
+export declare function createTransformFilter(options: InternalUserDefinedOptions['transform'], rootDir: string): {
+    include: ((id: string) => boolean) | undefined;
+    exclude: ((id: string) => boolean) | undefined;
+} | undefined;
+export declare function shouldSkipViteJsChunkTransform(chunk: OutputChunk, filter: TransformFilter | undefined): boolean;
+export declare function shouldSkipViteAssetTransform(asset: OutputAsset, file: string, rootDir: string, filter: TransformFilter | undefined): boolean;
+export declare function createTransformFilterSignature(options: InternalUserDefinedOptions['transform']): string;
+export {};

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

@@ -8,13 +8,14 @@ import type { InternalUserDefinedOptions } from '../../../types';
 export interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
     runtimeState: {
-        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
     ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
         allowBaselineOnlyInitialSync?: boolean | undefined;
         baseClassSet?: Set<string> | undefined;
+        refreshBySource?: boolean | undefined;
         transformOnly?: boolean | undefined;
     }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;

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

@@ -1,4 +1,4 @@
-export declare function resolveViteCssTaskConcurrency(useIncrementalMode: boolean): number;
+export declare function resolveViteCssTaskConcurrency(_useIncrementalMode: boolean, _majorVersion?: number | undefined): number;
 export declare function normalizeViteCssCacheKey(file: string): string;
 export declare function rememberLastCssResult(resultByFile: Map<string, string>, sourceHashByFile: Map<string, string>, file: string, css: string, sourceHash: string): void;
 export declare function getLastCssResult(resultByFile: Map<string, string>, ...files: Array<string | undefined>): string | undefined;

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

@@ -1,7 +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 } from './generate-bundle/css-output';
+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';
 export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;

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

@@ -1,2 +1,3 @@
 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>;

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

@@ -1,7 +1,7 @@
 import type { BundleSnapshot } from './bundle-state';
-import type { TailwindcssPatcherLike } from '../../types';
+import type { TailwindcssRuntimeLike } from '../../types';
 import type { IArbitraryValues } from '../../types/shared';
-import { extractRawCandidatesWithPositions, extractValidCandidates } from 'tailwindcss-patch';
+import { extractRawCandidatesWithPositions, extractValidCandidates } from '@tailwindcss-mangle/engine';
 type ExtractValidCandidatesOptions = Parameters<typeof extractValidCandidates>[0];
 type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
     content?: string;
@@ -13,7 +13,7 @@ type ExtractRawCandidatesFn = (content: string, extension?: string, options?: {
     bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
 }) => Promise<ExtractRawCandidateResult>;
 export interface BundleRuntimeClassSetManager {
-    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
+    sync: (runtime: TailwindcssRuntimeLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
     reset: () => Promise<void>;
 }
 export interface BundleRuntimeClassSetSyncOptions {

package/dist/bundlers/vite/plugin-cache.d.ts

@@ -0,0 +1,15 @@
+export declare function isMissingInternalCssSource(file: string, packageDir: string): boolean;
+export declare function normalizeVitePersistentCacheKey(file: string): string;
+export declare function toMb(bytes: number): number;
+export declare function summarizeStringCache(map: Map<string, string>): {
+    bytes: number;
+    mb: number;
+    size: number;
+};
+export declare function summarizeViteProcessedCssResults(map: Map<string, {
+    css: string;
+}>): {
+    bytes: number;
+    mb: number;
+    size: number;
+};

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

@@ -18,6 +18,7 @@ interface RewriteCssImportsOptions {
     onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
     onCssSourceTransform?: ((id: string, code: string) => Promise<void> | void) | undefined;
     shouldGenerateCss?: ((id: string, code: string) => boolean) | undefined;
+    shouldDeferGeneration?: ((id: string, code: string) => boolean) | undefined;
 }
 export declare function createRewriteCssImportsPlugins(options: RewriteCssImportsOptions): Plugin[];
 export declare function hasVitePipelineTailwindGenerationDirective(code: string): boolean;

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

@@ -2,8 +2,8 @@ import type { BundleSnapshot } from './bundle-state';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CreateViteRuntimeClassSetOptions {
     opts: InternalUserDefinedOptions;
-    initialTwPatcher: InternalUserDefinedOptions['twPatcher'];
-    refreshTailwindcssPatcher: InternalUserDefinedOptions['refreshTailwindcssPatcher'];
+    initialTailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
+    refreshTailwindcssRuntime: InternalUserDefinedOptions['refreshTailwindcssRuntime'];
     uniAppXEnabled: boolean;
     customAttributesEntities: unknown;
     disabledDefaultTemplateHandler: boolean;
@@ -11,15 +11,16 @@ interface CreateViteRuntimeClassSetOptions {
 }
 export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClassSetOptions): {
     runtimeState: {
-        twPatcher: import("@/types").TailwindcssPatcherLike;
+        tailwindRuntime: import("@/types").TailwindcssRuntimeLike;
         readyPromise: Promise<void>;
-        refreshTailwindcssPatcher: (options?: import("@/types").RefreshTailwindcssPatcherOptions) => Promise<import("@/types").TailwindcssPatcherLike>;
+        refreshTailwindcssRuntime: (options?: import("@/types").RefreshTailwindcssRuntimeOptions) => Promise<import("@/types").TailwindcssRuntimeLike>;
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
     ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
         allowBaselineOnlyInitialSync?: boolean | undefined;
         baseClassSet?: Set<string> | undefined;
+        refreshBySource?: boolean | undefined;
         transformOnly?: boolean | undefined;
     }) => Promise<Set<string>>;
 };

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

@@ -1,7 +1 @@
-import type { IArbitraryValues } from '../../../types/shared';
-interface ScriptCandidateExtractionOptions {
-    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
-    extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
-}
-export declare function extractScriptStringCandidates(source: string, extension: string, options: ScriptCandidateExtractionOptions): Promise<never[] | Set<string>>;
-export {};
+export { extractScriptStringCandidates } from '../../../tailwindcss/candidates';

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

@@ -1,7 +1,7 @@
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { IArbitraryValues } from '../../types/shared';
-export { createTailwindV3DefaultExtractor } from './source-candidates/tailwind-v3-default-extractor';
-export interface SourceCandidateCollector {
+export interface SourceCandidateStore {
+    syncSource: (id: string, source: string) => Promise<void>;
     sync: (id: string, source: string) => Promise<void>;
     syncCss: (id: string, source: string) => Promise<void>;
     merge: (id: string, source: string) => Promise<void>;
@@ -21,12 +21,17 @@ export interface SourceCandidateCollector {
     resetScan: () => void;
     clear: () => void;
 }
+export interface SourceCandidateCollector extends SourceCandidateStore {
+}
 export interface SourceCandidateCollectorSnapshot {
     candidatesById: Array<[string, string[]]>;
     cssCandidatesById?: Array<[string, string[]]> | undefined;
+    cssSourceById?: Array<[string, string]> | undefined;
     scanCandidatesById?: Array<[string, string[]]> | undefined;
+    scanSourceById?: Array<[string, string]> | undefined;
     sourceById?: Array<[string, string]> | undefined;
     transformCandidatesById?: Array<[string, string[]]> | undefined;
+    transformSourceById?: Array<[string, string]> | undefined;
     inlineExcludedCandidates: string[];
     inlineIncludedCandidates: string[];
 }
@@ -44,6 +49,7 @@ export interface SourceCandidateCollectorOptions {
     extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
 }
 export declare function isSourceCandidateRequest(id: string): boolean;
+export declare function createSourceCandidateStore(options?: SourceCandidateCollectorOptions): SourceCandidateStore;
 export declare function createSourceCandidateCollector(options?: SourceCandidateCollectorOptions): SourceCandidateCollector;
 export declare function getSourceCandidateContentCacheStatsForTest(): {
     max: number;
@@ -51,3 +57,4 @@ export declare function getSourceCandidateContentCacheStatsForTest(): {
     keys: string[];
 };
 export declare function clearSourceCandidateContentCacheForTest(): void;
+export {};

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

@@ -1,6 +1,6 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-import type { TailwindcssPatcherLike, UserDefinedOptions } from '../../../types';
+import type { UserDefinedOptions } from '../../../types';
 export interface ResolvedTailwindV4CssEntries {
     entries: TailwindSourceEntry[];
     explicit: boolean;
@@ -11,10 +11,6 @@ export declare function mergeTailwindInlineSourceCandidates(allInlineCandidates:
 export declare function resolveTailwindV4EntriesFromCss(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function resolveViteTailwindV4CssDependencies(css: string, base: string): Promise<string[]>;
 export declare function collectExistingCssEntries(options: UserDefinedOptions): string[];
-export declare function resolveTailwindV3CssEntryScan(options: UserDefinedOptions, patcher: TailwindcssPatcherLike): Promise<{
-    entries: TailwindSourceEntry[];
-    dependencies: Set<string>;
-}>;
 export declare function resolveTailwindV4EntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function resolveTailwindConfigEntriesFromCssCached(css: string, base: string): Promise<ResolvedTailwindV4CssEntries | undefined>;
 export declare function discoverTailwindV4CssEntries(root: string, outDir: string | undefined): Promise<string[]>;

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

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

package/dist/bundlers/vite/uni-app-x-css-options.d.ts

@@ -1,2 +1,2 @@
 import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../types';
-export declare function resolveUniAppXNativeCssHandlerOptions(opts: Pick<InternalUserDefinedOptions, 'appType' | 'uniAppX'>): Partial<IStyleHandlerOptions>;
+export declare function resolveUniAppXNativeCssHandlerOptions(opts: Pick<InternalUserDefinedOptions, 'appType' | 'generator' | 'platform' | 'cssOptions' | 'uniAppX'>): Partial<IStyleHandlerOptions>;

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

@@ -4,6 +4,7 @@ export declare function slash(p: string): string;
 export declare const isWindows: boolean;
 export declare const cssLangRE: RegExp;
 export declare function isCSSRequest(request: string): boolean;
+export declare function isHTMLRequest(request: string): boolean;
 export declare function normalizePath(id: string): string;
 export { cleanUrl };
 export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;

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

@@ -7,9 +7,24 @@ export declare function hasLoaderEntry(entries: Array<{
 }>, target?: string): boolean;
 interface ChunkLike {
     id?: string | number | null;
-    name?: string;
+    name?: string | undefined;
     hash?: string | null;
-    files?: Iterable<string> | Array<string>;
+    files?: Iterable<string> | Array<string> | undefined;
+    hasRuntime?: (() => boolean) | undefined;
+}
+interface ModuleLike {
+    context?: string;
+    dependencies?: Array<unknown> | Iterable<unknown>;
+    modules?: ModuleLike[] | Iterable<ModuleLike>;
+    request?: string;
+    resource?: string;
+    rootModule?: ModuleLike;
+    userRequest?: string;
+}
+interface ChunkGraphLike {
+    getChunkModulesIterable?: (chunk: ChunkLike) => Iterable<ModuleLike> | undefined;
+    getIssuer?: (module: ModuleLike) => ModuleLike | null | undefined;
+    getModule?: (dependency: unknown) => ModuleLike | null | undefined;
 }
 interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
@@ -19,6 +34,15 @@ interface RuntimeWatchDependenciesLike {
     files?: Iterable<string>;
     contexts?: Iterable<string>;
 }
+export declare function inferWebpackMainCssFiles(chunks: Iterable<ChunkLike>, cssMatcher: (file: string) => boolean, options?: {
+    mainSourceFiles?: ReadonlySet<string> | undefined;
+    resourcesByAsset?: ReadonlyMap<string, ReadonlySet<string>> | undefined;
+}): Set<string>;
+export declare function resolveSingleActiveWebpackCssResource(assetResources: ReadonlySet<string> | undefined, activeWebpackAssetResourceFiles: ReadonlySet<string>): string | undefined;
+export declare function createWebpackCssAssetResourceMap(chunks: Iterable<ChunkLike>, chunkGraph: ChunkGraphLike | undefined, cssMatcher: (file: string) => boolean, normalizeResource: (resource: string, issuer?: {
+    context?: string;
+    resource?: string;
+}) => string | undefined): Map<string, Set<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;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/css-source-resolvers.d.ts

@@ -0,0 +1,34 @@
+import type { SetupWebpackV5ProcessAssetsHookOptions } from './helpers';
+import type { WebpackCssHandlerOptions } from './pipeline-helpers';
+export declare function createWebpackCssSourceResolvers(options: {
+    activeWebpackAssetResourceFiles: ReadonlySet<string>;
+    appType: SetupWebpackV5ProcessAssetsHookOptions['appType'];
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    compilation: {
+        chunks: Iterable<{
+            files?: Iterable<string> | string[] | undefined;
+            hasRuntime?: () => boolean;
+            name?: string | undefined;
+        }>;
+    };
+    cssAssetResources: ReadonlyMap<string, ReadonlySet<string>>;
+    cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    cssSources: Map<string, {
+        css: string | undefined;
+        processed?: boolean | undefined;
+    }>;
+    cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    groupedCssEntriesLength: number;
+    singleCssAssetFile?: string | undefined;
+    isWebGeneratorTarget: boolean;
+    outputDir: string;
+    runtimeState: SetupWebpackV5ProcessAssetsHookOptions['runtimeState'];
+}): {
+    activeWebpackCssSourceFiles: Set<string>;
+    configuredMainCssEntryFiles: string[];
+    getCssHandlerOptions: (file: string, rawSource?: string | undefined) => WebpackCssHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => WebpackCssHandlerOptions;
+    hasConfiguredTailwindV4SourceRoots: () => boolean;
+    isSameWebpackSourceScope: (outputFile: string, candidateSourceFile: string, currentSourceFile?: string | undefined) => boolean;
+    resolveWebpackCssSourceFile: (file: string, rawSource?: string | undefined) => string | undefined;
+};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/helpers.d.ts

@@ -1,21 +1,37 @@
 import type { Compiler, sources as WebpackSources } from 'webpack';
+import type { BundleBuildState, BundleSnapshot } from '../../../vite/bundle-state';
 import type { BundleRuntimeClassSetManager } from '../../../vite/incremental-runtime-class-set';
+import type { WebpackGeneratedCssRegistration } from '../../loaders/runtime-registry';
 import type { AppType, InternalUserDefinedOptions } from '../../../../types';
 export interface SetupWebpackV5ProcessAssetsHookOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
     appType?: AppType | undefined;
     runtimeState: {
-        twPatcher: InternalUserDefinedOptions['twPatcher'];
+        tailwindRuntime: InternalUserDefinedOptions['tailwindRuntime'];
         readyPromise: Promise<void>;
     };
     getRuntimeRefreshRequirement: () => boolean;
     refreshRuntimeMetadata: (force: boolean) => Promise<void>;
-    isWebpackProcessedCssAsset?: ((file: string, rawSource: string) => boolean) | undefined;
+    isKnownWebpackProcessedCssAsset?: ((file: string, metadata?: {
+        isMainCssChunk?: boolean | undefined;
+    }) => boolean) | undefined;
+    isWebpackProcessedCssAsset?: ((file: string, rawSource: string, metadata?: {
+        isMainCssChunk?: boolean | undefined;
+    }) => boolean) | undefined;
     consumeRuntimeRefreshRequirement: () => void;
     isWatchMode?: (() => boolean) | undefined;
+    getWatchChangedFiles?: (() => Iterable<string>) | undefined;
     runtimeClassSetManager?: BundleRuntimeClassSetManager | undefined;
-    getWebpackCssSources?: (() => Iterable<[string, string | undefined]>) | undefined;
+    getWebpackCssSources?: (() => Iterable<[string, {
+        css: string | undefined;
+        processed?: boolean | undefined;
+    }]>) | undefined;
+    getWebpackGeneratedCssSources?: (() => Iterable<[string, WebpackGeneratedCssRegistration]>) | undefined;
+    pruneWebpackCssSources?: ((activeSourceFiles: ReadonlySet<string>, options?: {
+        watchMode?: boolean | undefined;
+    }) => void) | undefined;
+    prepareWebpackCssSources?: ((activeAssetResources?: ReadonlySet<string>) => ReadonlySet<string>) | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export type WebpackSourceLike = string | WebpackSources.Source;
@@ -27,15 +43,35 @@ interface WebpackAssetCompilationLike {
     } | undefined;
     updateAsset: Compiler['webpack']['Compilation']['prototype']['updateAsset'];
 }
-export declare function createWebpackSnapshotAssets(assets: Record<string, {
+export declare function buildWebpackBundleSnapshot(assets: Record<string, {
     source: () => unknown;
-}>): {
-    [k: string]: {
-        fileName: string;
-        source: string;
-        type: string;
+}>, opts: InternalUserDefinedOptions, state: BundleBuildState, compilation?: WebpackAssetCompilationLike | undefined): {
+    entries: import("../../../vite/bundle-state").BundleStateEntry[];
+    jsEntries: Map<any, any>;
+    sourceHashByFile: Map<string, string>;
+    runtimeAffectingSignatureByFile: Map<string, string>;
+    runtimeAffectingHashByFile: Map<string, string>;
+    hasOmittedKnownFiles: false;
+    changedByType: {
+        html: Set<string>;
+        js: Set<string>;
+        css: Set<string>;
+        other: Set<string>;
     };
+    runtimeAffectingChangedByType: {
+        html: Set<string>;
+        js: Set<string>;
+        css: Set<string>;
+        other: Set<string>;
+    };
+    processFiles: {
+        html: Set<string>;
+        js: Set<string>;
+        css: Set<string>;
+    };
+    linkedImpactsByEntry: Map<any, any>;
 };
+export declare function releaseWebpackBundleSnapshotSources(snapshot: BundleSnapshot): void;
 export declare function stringifyWebpackSource(source: unknown): string;
 export declare function createWebpackAssetUpdater(options: {
     compilation: WebpackAssetCompilationLike;
@@ -44,8 +80,9 @@ export declare function createWebpackAssetUpdater(options: {
     debug: (format: string, ...args: unknown[]) => void;
 }): {
     getCurrentAssetSource: (file: string) => string | undefined;
-    updateAssetIfChanged: (file: string, source: WebpackSourceLike, { notifyUpdate }?: {
-        notifyUpdate?: boolean;
+    updateAssetIfChanged: (file: string, source: WebpackSourceLike, { compare, notifyUpdate, }?: {
+        compare?: boolean | undefined;
+        notifyUpdate?: boolean | undefined;
     }) => boolean;
 };
 export {};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/js-module-graph.d.ts

@@ -0,0 +1,37 @@
+import type { sources as WebpackSources } from 'webpack';
+import type { SetupWebpackV5ProcessAssetsHookOptions } from './helpers';
+import type { LinkedJsModuleResult } from '../../../../types';
+export declare function createWebpackJsAssetModuleGraph(options: {
+    compilation: {
+        getAsset: (file: string) => {
+            source: {
+                source: () => unknown;
+            };
+        } | undefined;
+    };
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    entries: Array<[string, unknown]>;
+    outputDir: string;
+}): {
+    jsAssets: Map<string, string>;
+    moduleGraphOptions: {
+        resolve(specifier: string, importer: string): string | undefined;
+        load: (id: string) => string | undefined;
+        filter(id: string): boolean;
+    };
+};
+export declare function applyWebpackLinkedJsResults(options: {
+    ConcatSource: new (code: string) => WebpackSources.Source;
+    compilation: {
+        getAsset: (file: string) => {
+            source: {
+                source: () => unknown;
+            };
+        } | undefined;
+        updateAsset: (file: string, source: WebpackSources.Source) => void;
+    };
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    debug: SetupWebpackV5ProcessAssetsHookOptions['debug'];
+    jsAssets: ReadonlyMap<string, string>;
+    linked: Record<string, LinkedJsModuleResult> | undefined;
+}): void;