weapp-tailwindcss 5.0.13 → 5.1.1

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

@@ -0,0 +1,199 @@
+import type { TailwindV4CssSource } from '../../../shared/generator-css/source-resolver/types';
+import type { createEscapeFragments } from '../../../vite/incremental-runtime-class-set/escaped-candidates';
+import type { SourceCandidateStore } from '../../../vite/source-candidates';
+import type { SetupWebpackV5ProcessAssetsHookOptions, WebpackSourceLike } from './helpers';
+import type { WebpackSourceCandidateScanMemoryStats } from './source-candidate-cache';
+import type { TailwindcssRuntimeLike } from '../../../../types';
+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 function removeTailwindV4StandaloneHostPreflightRule(source: string): string;
+export interface WebpackSourceCandidateCache {
+    getSourceCandidatesForEntries: SourceCandidateStore['valuesForEntries'];
+    signatureHash: string;
+    tokenSources: ReturnType<SourceCandidateStore['sourcesForEntries']>;
+}
+export declare function isRuntimeTransformCandidate(candidate: string): boolean;
+export declare function collectRuntimeTokenSignatureParts(source: string): [] | RegExpMatchArray;
+export declare function hasMissingRuntimeCandidates(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;
+export declare function resolveWebpackGeneratorRawSource(rawSource: string, cssHandlerOptions: WebpackCssHandlerOptions): string;
+export interface WebpackGeneratorUserCssSource {
+    css: string;
+    processed: boolean;
+}
+export declare function hasUsableWebpackGeneratorCssSources(cssSources: TailwindV4CssSource[] | undefined): cssSources is TailwindV4CssSource[];
+export declare function normalizeWebpackGeneratorCssSources(cssSources: TailwindV4CssSource[] | undefined): import("@tailwindcss-mangle/engine").TailwindV4CssSource[] | undefined;
+export declare function hasProcessedCssAssetUrl(css: string): boolean;
+export declare function shouldUseWebpackAssetAsGeneratorUserCss(rawSource: string, generatorRawSource: string, options?: {
+    processed?: boolean | undefined;
+}): boolean;
+export declare function collectWebpackAssetUserCssMarkers(source: string): Set<string>;
+export declare function parseWebpackCssLayerNames(params: string): string[];
+export declare function removeWebpackTailwindGeneratedAssetCss(source: string): string;
+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;
+export declare function isWebpackTailwindImportRequest(request: string | undefined): boolean | undefined;
+export declare function removeWebpackGeneratorNonTailwindImports(source: string | undefined): string | undefined;
+export declare function isWebpackCssSourceRepresentedInAsset(rawSource: string, sourceCss: string | undefined): boolean;
+export declare function createWebpackGeneratorCssSource(file: string | undefined, css: string | undefined): {
+    file: string;
+    base: string;
+    css: string;
+    dependencies: string[];
+} | undefined;
+export declare function createWebpackUserCssSourceAppend(sources: Iterable<{
+    css: string | undefined;
+    file: string;
+    processed?: boolean | undefined;
+}>, generatorRawSource: string, currentSourceFile?: string | undefined, shouldIncludeSource?: ((file: string) => boolean) | undefined): {
+    css: string;
+    processed: boolean;
+} | undefined;
+export declare function createWebpackGeneratorUserCssSourceAppend(...sources: Array<WebpackGeneratorUserCssSource | undefined>): WebpackGeneratorUserCssSource | undefined;
+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'>): 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;
+export declare function resolveWebpackCssAssetModuleResource(resource: string, issuer: {
+    context?: string;
+    resource?: string;
+} | undefined, options: {
+    appType?: SetupWebpackV5ProcessAssetsHookOptions['appType'] | undefined;
+    cssMatcher: (file: string) => boolean;
+}): string | undefined;
+export declare function isSameWebpackCssSourceScope(options: {
+    candidateSourceFile: string;
+    currentSourceFile?: string | undefined;
+    outputFile: string;
+    resourcesByAsset: ReadonlyMap<string, ReadonlySet<string>>;
+}): boolean;
+export declare function shouldAppendCurrentWebpackAssetUserCss(options: {
+    currentAssetHasBundlerGeneratedMarker: boolean;
+    currentAssetHasUserCss: boolean;
+    currentAssetLooksGenerated: boolean;
+    registeredUserRawSource: WebpackGeneratorUserCssSource | undefined;
+    shouldPreserveGeneratedWebAssetUserCss: boolean;
+    sourceCssProcessed: boolean;
+}): boolean;
+export declare function createWebpackCurrentAssetUserRawSource(options: {
+    currentAssetHasUserCss: boolean;
+    currentAssetLooksGenerated: boolean;
+    currentAssetUserCssSource: string;
+    shouldAppendCurrentAssetUserCss: boolean;
+    sourceCssProcessed: boolean;
+}): WebpackGeneratorUserCssSource | undefined;
+export declare function finalizeTracedWebpackCssAsset(css: string, cssHandlerOptions: WebpackCssHandlerOptions, options: {
+    annotateCss: (css: string) => string;
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    isWebGeneratorTarget: boolean;
+}): string;
+export declare function finalizeWebpackCssAssetSource(source: string, compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'], isWebGeneratorTarget: boolean, options?: {
+    generatedCss?: 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/source-candidate-cache.d.ts

@@ -0,0 +1,28 @@
+import type { SourceCandidateStore } from '../../../vite/source-candidates';
+import type { ResolvedViteSourceScan } from '../../../vite/source-scan';
+export interface WebpackSourceCandidateCacheRecord {
+    getSourceCandidatesForEntries: SourceCandidateStore['valuesForEntries'];
+    signatureHash: string;
+    tokenSources: ReturnType<SourceCandidateStore['sourcesForEntries']>;
+}
+export interface WebpackSourceCandidateScanMemoryStats {
+    entries: number;
+    files: number;
+    lastHit: boolean;
+    signatureHash?: string | undefined;
+    snapshots: number;
+}
+interface ResolveWebpackSourceCandidateCacheOptions {
+    changedFiles?: Iterable<string> | undefined;
+    collector: SourceCandidateStore;
+    outDir: string;
+    root: string;
+    sourceScan: ResolvedViteSourceScan | undefined;
+    watchMode: boolean;
+}
+export declare function createWebpackSourceCandidateScanCache(): {
+    getMemoryStats: () => WebpackSourceCandidateScanMemoryStats;
+    resolve: ({ changedFiles, collector, outDir, root, sourceScan, watchMode, }: ResolveWebpackSourceCandidateCacheOptions) => Promise<WebpackSourceCandidateCacheRecord>;
+};
+export type WebpackSourceCandidateScanCache = ReturnType<typeof createWebpackSourceCandidateScanCache>;
+export {};

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-assets/source-candidate-refresh.d.ts

@@ -0,0 +1,11 @@
+import type { SetupWebpackV5ProcessAssetsHookOptions } from './helpers';
+import type { createWebpackSourceCandidateScanCache } from './source-candidate-cache';
+export declare function refreshWebpackSourceCandidates(options: {
+    compilerOptions: SetupWebpackV5ProcessAssetsHookOptions['options'];
+    debug: SetupWebpackV5ProcessAssetsHookOptions['debug'];
+    outputDir: string;
+    runtimeState: SetupWebpackV5ProcessAssetsHookOptions['runtimeState'];
+    scanCache: ReturnType<typeof createWebpackSourceCandidateScanCache>;
+    watchChangedFiles: ReadonlySet<string>;
+    watchMode: boolean;
+}): Promise<import("./source-candidate-cache").WebpackSourceCandidateCacheRecord | undefined>;

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

@@ -1,2 +1,3 @@
 import type { SetupWebpackV5ProcessAssetsHookOptions } from './v5-assets/helpers';
+export * from './v5-assets/pipeline-helpers';
 export declare function setupWebpackV5ProcessAssetsHook(options: SetupWebpackV5ProcessAssetsHookOptions): void;

package/dist/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.d.ts

@@ -1,6 +1,6 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { Compiler } from 'webpack';
-import type { WebpackCssSourceRegistration } from '../loaders/runtime-registry';
+import type { WebpackCssSourceRegistration, WebpackGeneratedCssRegistration } from '../loaders/runtime-registry';
 import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5LoadersOptions {
@@ -15,6 +15,8 @@ interface SetupWebpackV5LoadersOptions {
     getClassSetInLoader: () => Promise<void>;
     getRuntimeSetInLoader: () => Promise<Set<string>>;
     markWebpackProcessedCssSource?: ((file: string) => void) | undefined;
+    markWebpackCssSourceModule?: ((file: string) => void) | undefined;
+    registerWebpackGeneratedCss?: ((source: WebpackGeneratedCssRegistration) => void) | undefined;
     registerWebpackCssSourceFile?: ((source: WebpackCssSourceRegistration) => void) | undefined;
     getRuntimeWatchDependencies: () => {
         files: ReadonlySet<string>;

package/dist/bundlers/webpack/loaders/runtime-registry.d.ts

@@ -1,4 +1,4 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindV4CssSource } from '@tailwindcss-mangle/engine';
 import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 export interface WebpackRuntimeClassSetLoaderOptions {
@@ -13,6 +13,13 @@ export interface RuntimeLoaderWatchDependencies {
 export interface WebpackCssSourceRegistration {
     css?: string | undefined;
     file: string;
+    processed?: boolean | undefined;
+}
+export interface WebpackGeneratedCssRegistration {
+    classSet: Set<string>;
+    css: string;
+    dependencies: string[];
+    file: string;
 }
 export interface WebpackCssImportRewriteRuntimeOptions {
     pkgDir: string;
@@ -22,6 +29,8 @@ export interface WebpackCssImportRewriteRuntimeOptions {
     registerCssSource?: (source: TailwindV4CssSource) => Promise<void> | void;
     getRuntimeSet?: () => Promise<Set<string>> | Set<string>;
     markGeneratedCssSource?: (file: string) => void;
+    registerGeneratedCss?: (source: WebpackGeneratedCssRegistration) => void;
+    registerCssSourceFile?: (source: WebpackCssSourceRegistration) => void;
 }
 export interface WebpackCssImportRewriteLoaderOptions {
     tailwindcssImportRewrite?: WebpackCssImportRewriteRuntimeOptions;

package/dist/bundlers/webpack/shared/css-loader-runtime.d.ts

@@ -0,0 +1 @@
+export declare function isWebpackCssLoaderRuntimeSource(source: string): boolean;

package/dist/cache/index.d.ts

@@ -35,6 +35,7 @@ export interface ICreateCacheReturnType {
         cacheKeys?: Iterable<string> | undefined;
         hashKeys?: Iterable<HashMapKey> | undefined;
     }) => void;
+    pruneHashKeys?: (hashKeys: Iterable<HashMapKey>) => void;
     process: <T extends CacheValue>(options: CacheProcessOptions<T>) => Promise<T>;
 }
 declare function createCache(options?: boolean): ICreateCacheReturnType;

package/dist/cli/mount-options.d.ts

@@ -1,4 +1,4 @@
-import type { TailwindcssPatchCliMountOptions } from 'tailwindcss-patch';
 export declare const PATCH_COMMAND_OBSOLETE_NOTICE = "\u63D0\u793A\uFF1Aweapp-tailwindcss@5 \u5DF2\u7531\u6784\u5EFA\u8FD0\u884C\u65F6\u63A5\u7BA1 Tailwind CSS \u5904\u7406\uFF0Cweapp-tw patch \u5DF2\u65E0\u9700\u6267\u884C\uFF1B\u8BF7\u79FB\u9664 package.json \u4E2D\u7684 postinstall \u94A9\u5B50\u3002";
+export declare const obsoletePatchCommands: readonly ["extract", "tokens", "init", "migrate", "restore", "validate"];
 export declare function logPatchCommandObsoleteNotice(): void;
-export declare const mountOptions: TailwindcssPatchCliMountOptions;
+export declare function logObsoletePatchCommand(command: string): void;