weapp-tailwindcss 5.1.14 → 5.1.16

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';
+import type { InternalUserDefinedOptions } from '../../../types';
+export { isCssOutputFile } from './style-files';
+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").resolveGeneratorRuntimeBranch>;
+    currentGeneratorOptions: ReturnType<typeof import("../../..").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';
+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';

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

@@ -10,6 +10,7 @@ interface RewriteCssImportsOptions {
             fileName: string;
             source: string;
         }) => string;
+        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     }) => Promise<string | undefined> | string | undefined) | undefined;
     shouldOwnTailwindGeneration?: boolean | undefined;
     shouldRewrite: boolean;

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

@@ -1,5 +1,5 @@
 import type { Plugin } from 'vite';
-interface ViteServeCssGenerationOptions {
+interface ViteCssGenerationOptions {
     generateCss: (id: string, code: string, hookContext?: {
         addWatchFile?: (id: string) => void;
         emitFile?: (emittedFile: {
@@ -7,10 +7,12 @@ interface ViteServeCssGenerationOptions {
             fileName: string;
             source: string;
         }) => string;
+        frameworkPostcssStage?: 'complete' | 'pending' | undefined;
     }) => Promise<string | undefined> | string | undefined;
     getCommand: () => string | undefined;
     onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
     shouldGenerate: () => boolean;
+    shouldGenerateBuild?: (() => boolean) | undefined;
 }
-export declare function createViteServeCssGenerationPlugins(options: ViteServeCssGenerationOptions): Plugin[];
+export declare function createViteCssGenerationPlugins(options: ViteCssGenerationOptions): Plugin[];
 export {};

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,19 +1,20 @@
 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 { getCompilerContext } from '../../../context';
-import { toCustomAttributesEntities } from '../../../context/custom-attributes';
-import { createViteRuntimeClassSet } from '../runtime-class-set';
 export interface WeappTailwindcssVitePlugin {
     name: string;
     [hook: string]: any;
 }
 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/source-candidates/collector.d.ts

@@ -0,0 +1,8 @@
+import type { SourceCandidateCollector, SourceCandidateCollectorOptions } from './types-and-cache';
+export declare function createSourceCandidateCollector(options?: SourceCandidateCollectorOptions): SourceCandidateCollector;
+export declare function getSourceCandidateContentCacheStatsForTest(): {
+    max: number;
+    size: number;
+    keys: string[];
+};
+export declare function clearSourceCandidateContentCacheForTest(): void;

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

@@ -0,0 +1,2 @@
+import type { SourceCandidateCollectorOptions, SourceCandidateStore } from './types-and-cache';
+export declare function createSourceCandidateStore(options?: SourceCandidateCollectorOptions): SourceCandidateStore;

package/dist/bundlers/vite/source-candidates/types-and-cache.d.ts

@@ -0,0 +1,69 @@
+import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { ICustomAttributesEntities } from '../../../types';
+import type { IArbitraryValues } from '../../../types/shared';
+import { LRUCache } from 'lru-cache';
+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>;
+    syncFile: (id: string) => Promise<void>;
+    syncCurrentSource: (id: string, source: string) => Promise<SourceCandidateChange>;
+    syncCurrentFile: (id: string) => Promise<SourceCandidateChange>;
+    scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
+    syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
+    remove: (id: string) => SourceCandidateChange;
+    source: (id: string) => string | undefined;
+    sources: () => IterableIterator<[string, string]>;
+    values: () => Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>;
+    sourcesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>;
+    snapshot: () => SourceCandidateCollectorSnapshot;
+    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
+    clearScan: () => void;
+    resetScan: () => void;
+    clear: () => void;
+}
+export interface SourceCandidateCollector extends SourceCandidateStore {
+}
+export interface SourceCandidateChange {
+    addedCandidates: Set<string>;
+    removedCandidates: Set<string>;
+}
+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[];
+}
+export interface SourceCandidateFilterOptions {
+    excludeEntries?: TailwindSourceEntry[] | undefined;
+}
+export interface ScanSourceCandidateRootOptions {
+    root: string;
+    outDir?: string | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
+}
+export interface SourceCandidateCollectorOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
+    customAttributesEntities?: ICustomAttributesEntities | undefined;
+    disabledDefaultTemplateHandler?: boolean | undefined;
+    extractor?: ((source: string, extension: string) => Promise<Iterable<string>> | Iterable<string>) | undefined;
+}
+export declare const SOURCE_CANDIDATE_CONTENT_CACHE_MAX = 128;
+export declare const sourceCandidateContentCache: LRUCache<string, string[], unknown>;
+export declare function cleanUrl(id: string): string;
+export declare function resolveSourceCandidateExtension(id: string): string;
+export declare function createSourceCandidateContentCacheKey(extension: string, source: string, bareArbitraryValues: IArbitraryValues['bareArbitraryValues'] | undefined, customAttributesEntities: ICustomAttributesEntities | undefined, disabledDefaultTemplateHandler: boolean | undefined, extractor: SourceCandidateCollectorOptions['extractor']): string;
+export declare function extractCandidates(source: string, extension: string, options: SourceCandidateCollectorOptions): Promise<Set<string>>;
+export declare function isSourceCandidateRequest(id: string): boolean;
+export declare function removeCandidateSet(candidateCount: Map<string, number>, candidates: Set<string>): void;
+export declare function addCandidateSet(candidateCount: Map<string, number>, candidates: Set<string>): void;
+export declare function diffCandidateSets(previous: Set<string>, next: Set<string>): SourceCandidateChange;

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

@@ -1,68 +1,4 @@
-import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
-import type { ICustomAttributesEntities } from '../../types';
-import type { IArbitraryValues } from '../../types/shared';
-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>;
-    syncFile: (id: string) => Promise<void>;
-    syncCurrentSource: (id: string, source: string) => Promise<SourceCandidateChange>;
-    syncCurrentFile: (id: string) => Promise<SourceCandidateChange>;
-    scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
-    syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
-    remove: (id: string) => SourceCandidateChange;
-    source: (id: string) => string | undefined;
-    sources: () => IterableIterator<[string, string]>;
-    values: () => Set<string>;
-    valuesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>;
-    sourcesForEntries: (entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>;
-    snapshot: () => SourceCandidateCollectorSnapshot;
-    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
-    clearScan: () => void;
-    resetScan: () => void;
-    clear: () => void;
-}
-export interface SourceCandidateCollector extends SourceCandidateStore {
-}
-export interface SourceCandidateChange {
-    addedCandidates: Set<string>;
-    removedCandidates: Set<string>;
-}
-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[];
-}
-export interface SourceCandidateFilterOptions {
-    excludeEntries?: TailwindSourceEntry[] | undefined;
-}
-interface ScanSourceCandidateRootOptions {
-    root: string;
-    outDir?: string | undefined;
-    entries?: TailwindSourceEntry[] | undefined;
-    explicit?: boolean | undefined;
-}
-export interface SourceCandidateCollectorOptions {
-    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
-    customAttributesEntities?: ICustomAttributesEntities | undefined;
-    disabledDefaultTemplateHandler?: boolean | undefined;
-    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;
-    size: number;
-    keys: string[];
-};
-export declare function clearSourceCandidateContentCacheForTest(): void;
-export {};
+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';

package/dist/bundlers/vite/watch-css-post.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedConfig } from 'vite';
+export interface FrameworkWatchCssAdaptationOptions {
+    enabled: boolean;
+    isWatchBuild: boolean;
+    isWebGeneratorBranch: boolean;
+    ownsTailwindGeneration: boolean;
+    platform?: string | undefined;
+}
+export declare function shouldAdaptFrameworkWatchCssBeforeCache(options: FrameworkWatchCssAdaptationOptions): boolean;
+export declare function wrapViteCssPostTransform(config: ResolvedConfig, transformCss: (css: string, id: string) => Promise<string>): boolean;

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

@@ -14,11 +14,13 @@ interface ChunkLike {
 interface ModuleLike {
     context?: string;
     dependencies?: Array<unknown> | Iterable<unknown>;
+    identifier?: () => string;
     modules?: ModuleLike[] | Iterable<ModuleLike>;
     request?: string;
     resource?: string;
     rootModule?: ModuleLike;
     userRequest?: string;
+    type?: string;
 }
 interface ChunkGraphLike {
     getChunkModulesIterable?: (chunk: ChunkLike) => Iterable<ModuleLike> | undefined;
@@ -42,6 +44,10 @@ export declare function createWebpackCssAssetResourceMap(chunks: Iterable<ChunkL
     context?: string;
     resource?: string;
 }) => string | undefined): Map<string, Set<string>>;
+export declare function createWebpackDirectCssAssetResourceMap(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

@@ -20,6 +20,7 @@ export declare function createWebpackCssSourceResolvers(options: {
     };
     cssAssetFiles: Iterable<string>;
     cssAssetResources: ReadonlyMap<string, ReadonlySet<string>>;
+    directCssAssetResources: ReadonlyMap<string, ReadonlySet<string>>;
     cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
     cssSources: Map<string, {
         css: string | undefined;

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

@@ -0,0 +1,2 @@
+export * from './pipeline-helpers';
+export declare function finalizeWebpackProcessAssets(context: any): Promise<void>;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/generated-css-result.d.ts

@@ -0,0 +1,3 @@
+export declare function finalizeWebpackGeneratedCssResult(context: any): Promise<{
+    result: any;
+}>;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/generated-css-task.d.ts

@@ -0,0 +1,2 @@
+import type { WebpackCssAssetTaskContext } from './processed-css-task';
+export declare function processWebpackGeneratedCssAsset(element: any, context: WebpackCssAssetTaskContext): Promise<void>;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/html-js-tasks.d.ts

@@ -0,0 +1,5 @@
+export * from './pipeline-helpers';
+export declare function enqueueWebpackHtmlAndJsTasks(context: any): Promise<{
+    htmlTaskFactories: (() => Promise<void>)[];
+    jsTaskFactories: (() => Promise<void>)[];
+}>;

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

@@ -0,0 +1,30 @@
+import type { createEscapeFragments } from '../../../../vite/incremental-runtime-class-set/escaped-candidates';
+import type { SetupWebpackV5ProcessAssetsHookOptions, WebpackSourceLike } from '../helpers';
+import type { WebpackCssHandlerOptions, WebpackSourceCandidateCache } from './preflight-runtime';
+export declare function finalizeTracedWebpackCssAsset(css: string, cssHandlerOptions: WebpackCssHandlerOptions, options: {
+    annotateCss: (css: string) => string;
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    finalized?: boolean | undefined;
+    isWebGeneratorTarget: boolean;
+}): string;
+export declare function finalizeWebpackCssAssetSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean, options?: {
+    cssPreflight?: boolean | undefined;
+    generatedCss?: boolean;
+    preserveExistingPreflight?: boolean | undefined;
+}): string;
+export declare function finalizeWebpackCssAssetOutputSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean): string;
+export declare function collectWebpackJsRuntimeCandidatesFromAssets(options: {
+    escapeFragments: ReturnType<typeof createEscapeFragments>;
+    getAssetSource: (file: string) => WebpackSourceLike | undefined;
+    isWebGeneratorTarget: boolean;
+    jsAssets: Iterable<string>;
+}): Set<string> | undefined;
+export declare function collectWebpackJsRuntimeTokenSignature(options: {
+    getAssetSource: (file: string) => WebpackSourceLike | undefined;
+    isWebGeneratorTarget: boolean;
+    jsAssets: Iterable<string>;
+}): string;
+export declare function addRuntimeTransformCandidates(target: Set<string>, candidates: ReadonlySet<string> | undefined): void;
+export declare function createWebpackCssSourceTraceTokenSources(compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], webpackSourceCandidates: WebpackSourceCandidateCache | undefined): import("../../../../shared/css-source-trace").CssTokenSourceMap | undefined;
+export declare function stringifyOptionalWebpackSourceValue(value: unknown): string;
+export declare function stringifyWebpackSourceLike(source: WebpackSourceLike): string;

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

@@ -0,0 +1,8 @@
+export declare function parseWebpackCssLayerNames(params: string): string[];
+export declare function removeWebpackTailwindGeneratedAssetCss(source: string): string;
+export declare function isOnlyWebpackTailwindGeneratedPreflightCss(source: string): boolean;
+export declare function collectWebpackCssRuleIdentityMarkers(source: string): Set<string>;
+export declare function unescapeCssIdentifier(value: string): string;
+export declare function collectGeneratedCssRuntimeCandidates(source: string): Set<string>;
+export declare function hasAdditionalWebpackAssetUserCssMarkers(rawSource: string, generatorRawSource: string): boolean;
+export declare function hasWebpackTailwindSourceDirectives(source: string | undefined): boolean;

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

@@ -0,0 +1,78 @@
+import type { SetupWebpackV5ProcessAssetsHookOptions } from '../helpers';
+import type { WebpackSourceCandidateScanMemoryStats } from '../source-candidate-cache';
+import type { WebpackCssHandlerOptions } from './preflight-runtime';
+export declare function resolveWebpackMemoryDebugStats(context: {
+    activeAssetFiles: number;
+    activeCssFiles: number;
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    cache: SetupWebpackV5ProcessAssetsHookOptions['options']['cache'];
+    cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>;
+    phase: string;
+    sourceCandidateScan: WebpackSourceCandidateScanMemoryStats;
+}): {
+    phase: string;
+    process: {
+        rssMb: number;
+        heapTotalMb: number;
+        heapUsedMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+    };
+    assets: {
+        active: number;
+        activeCss: number;
+    };
+    processCache: {
+        instance: number;
+        hashMap: number;
+        activeCacheKeys: number;
+        activeHashKeys: number;
+        staleCacheKeys: number;
+        staleHashKeys: number;
+        pruned: boolean;
+        pruneSkipped: boolean;
+    };
+    webpackCss: {
+        handlerOptions: number;
+        userHandlerOptions: number;
+        maxHandlerOptions: number;
+    };
+    sourceCandidateScan: WebpackSourceCandidateScanMemoryStats;
+    tailwind: {
+        v4: {
+            max: number;
+            entryCandidatesMax: number;
+            entryCssBytesMax: number;
+            size: number;
+            taskMax: number;
+            taskSize: number;
+            entries: {
+                candidates: number;
+                classSet: number;
+                cssBytes: number;
+                rawCssBytes: number;
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            keys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+            taskKeys: {
+                keyHash: string;
+                keyBytes: number;
+            }[];
+        };
+    };
+} | undefined;
+export declare function shouldInjectWebpackCssTracePreflight(_appType: SetupWebpackV5ProcessAssetsHookOptions['appType'], cssHandlerOptions: Pick<WebpackCssHandlerOptions, 'isMainChunk' | 'sourceOptions'>): boolean;
+export declare function finalizeMiniProgramUserCssAssetSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean, options?: {
+    cssPreflight?: boolean | undefined;
+}): string;
+export declare function shouldFallbackToWebpackUserCssOnGeneratorError(options: {
+    configuredMainCssEntryFilesLength: number;
+    generatorRawSource: string;
+    hasExplicitTailwindV4SourceCss: boolean;
+}): boolean;

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

@@ -0,0 +1,43 @@
+import type { TailwindV4CssSource } from '../../../../shared/generator-css/source-resolver/types';
+import type { SourceCandidateStore } from '../../../../vite/source-candidates';
+import type { SetupWebpackV5ProcessAssetsHookOptions } from '../helpers';
+import type { resolveStyleOptionsFromContext } from '../../../../../context/style-options';
+import type { TailwindcssRuntimeLike } from '../../../../../types';
+export { isRuntimeTransformCandidate } from './runtime-candidates';
+export interface WebpackCssHandlerOptions {
+    isMainChunk: boolean;
+    postcssOptions: {
+        options: {
+            from: string;
+        };
+    };
+    majorVersion?: 4 | undefined;
+    sourceOptions?: {
+        cssSources?: TailwindV4CssSource[] | undefined;
+        outputRoot?: string | undefined;
+        sourceCss?: string | undefined;
+        sourceFile?: string | undefined;
+    } | undefined;
+}
+export declare const WEBPACK_CSS_HANDLER_OPTIONS_CACHE_MAX = 128;
+export declare function resolveConfiguredWebpackCssPreflight(compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], styleOptions: ReturnType<typeof resolveStyleOptionsFromContext>): import("@weapp-tailwindcss/postcss").CssPreflightOptions;
+export declare function resolveExistingWebpackCssPreflight(compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], styleOptions: ReturnType<typeof resolveStyleOptionsFromContext>, source: string): import("@weapp-tailwindcss/postcss").CssPreflightOptions | undefined;
+export declare function removeMiniProgramPreflightSelectorRule(source: string): string;
+export declare function dedupeMiniProgramPreflightSelectorRules(source: string): string;
+export declare function hasMiniProgramPreflightSelector(source: string): boolean;
+export declare function ensureWebpackMiniProgramTwContentInit(source: string): string;
+export declare function removeTailwindV4StandaloneHostPreflightRule(source: string): string;
+export interface WebpackSourceCandidateCache {
+    getSourceCandidatesForEntries: SourceCandidateStore['valuesForEntries'];
+    signatureHash: string;
+    tokenSources: ReturnType<SourceCandidateStore['sourcesForEntries']>;
+}
+export declare function collectRuntimeTokenSignatureParts(source: string): [] | RegExpMatchArray;
+export declare function hasMissingRuntimeCandidates(classSet: ReadonlySet<string> | undefined, candidates: ReadonlySet<string> | undefined): boolean;
+export declare function hasStaleRuntimeCandidates(classSet: ReadonlySet<string> | undefined, candidates: ReadonlySet<string> | undefined): boolean;
+export declare function resolveGeneratedCssRuntimeCandidates(source: string, fallbackClassSet?: ReadonlySet<string> | undefined): ReadonlySet<string>;
+export declare function getRuntimeClassSetSync(tailwindRuntime: TailwindcssRuntimeLike): Set<string>;
+export declare function toMb(bytes: number): number;
+export declare function pruneMapToMaxSize<Key, Value>(map: Map<Key, Value>, maxSize: number): void;
+export declare function stripTrailingLineWhitespace(source: string): string;
+export declare function pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, cssUserHandlerOptionsCache: Map<string, WebpackCssHandlerOptions>, activeCssFiles: Set<string>): void;