weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.31

package/dist/tailwindcss/patcher-options.d.ts

@@ -1,56 +1,8 @@
-import type { PackageResolvingOptions } from 'local-pkg';
-import type { ILengthUnitsPatchOptions, NormalizedTailwindCssPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
+import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
 type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
-type ResolvedTailwindUserOptions = TailwindUserOptions | NormalizedTailwindCssPatchOptions['tailwind'];
 type TailwindApplyOptions = NonNullable<TailwindCssPatchOptions['apply']>;
-type TailwindExtractOptions = NonNullable<TailwindCssPatchOptions['extract']>;
 type TailwindExtendLengthUnitsOption = TailwindApplyOptions['extendLengthUnits'];
-export interface LegacyTailwindcssPatcherOptions {
-    cache?: boolean | {
-        enabled?: boolean;
-        cwd?: string;
-        dir?: string;
-        file?: string;
-        strategy?: 'merge' | 'overwrite';
-    };
-    patch?: {
-        overwrite?: boolean;
-        basedir?: string;
-        cwd?: string;
-        filter?: (className: string) => boolean;
-        resolve?: PackageResolvingOptions;
-        tailwindcss?: TailwindUserOptions;
-        applyPatches?: {
-            exportContext?: boolean;
-            extendLengthUnits?: boolean | ILengthUnitsPatchOptions;
-        };
-        output?: {
-            filename?: string;
-            loose?: boolean;
-            removeUniversalSelector?: boolean;
-        };
-    };
-}
-export interface LegacyTailwindcssOutputOptions {
-    enabled?: boolean;
-    file?: string;
-    format?: TailwindExtractOptions['format'];
-    pretty?: TailwindExtractOptions['pretty'];
-    removeUniversalSelector?: boolean;
-}
-export interface LegacyTailwindcssFeatureOptions {
-    exposeContext?: TailwindApplyOptions['exposeContext'];
-    extendLengthUnits?: boolean | ILengthUnitsPatchOptions | TailwindExtendLengthUnitsOption;
-}
-export type CompatTailwindCssPatchOptions = TailwindCssPatchOptions & {
-    cwd?: string;
-    overwrite?: boolean;
-    features?: LegacyTailwindcssFeatureOptions;
-    output?: LegacyTailwindcssOutputOptions;
-    tailwind?: ResolvedTailwindUserOptions;
-};
-export declare function resolveTailwindcssOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): ResolvedTailwindUserOptions | undefined;
+export declare function resolveTailwindcssOptions(options?: TailwindCssPatchOptions): TailwindUserOptions | undefined;
 export declare function normalizeExtendLengthUnits(value: boolean | ILengthUnitsPatchOptions | undefined): TailwindExtendLengthUnitsOption | undefined;
-export declare function normalizeTailwindcssPatcherOptions(options?: CompatTailwindCssPatchOptions | LegacyTailwindcssPatcherOptions): TailwindCssPatchOptions | undefined;
-export declare function toModernTailwindcssPatchOptions(options?: CompatTailwindCssPatchOptions): TailwindCssPatchOptions | undefined;
+export declare function normalizeTailwindcssPatcherOptions(options?: TailwindCssPatchOptions): TailwindCssPatchOptions | undefined;
 export {};

package/dist/tailwindcss/patcher.d.ts

@@ -1,5 +1,4 @@
 import type { ILengthUnitsPatchOptions, TailwindCssPatchOptions } from 'tailwindcss-patch';
-import type { LegacyTailwindcssPatcherOptions } from './patcher-options';
 import type { TailwindcssPatcherLike } from '../types';
 type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
 export interface CreateTailwindcssPatcherOptions {
@@ -7,7 +6,7 @@ export interface CreateTailwindcssPatcherOptions {
     cacheDir?: string;
     supportCustomLengthUnitsPatch?: boolean | ILengthUnitsPatchOptions;
     tailwindcss?: TailwindUserOptions;
-    tailwindcssPatcherOptions?: TailwindCssPatchOptions | LegacyTailwindcssPatcherOptions;
+    tailwindcssPatcherOptions?: TailwindCssPatchOptions;
 }
 export declare function createTailwindcssPatcher(options?: CreateTailwindcssPatcherOptions): TailwindcssPatcherLike;
 export {};

package/dist/tailwindcss/remove-unsupported-css.d.ts

@@ -1,2 +1 @@
-import type postcss from 'postcss';
-export declare function removeUnsupportedCascadeLayers(root: postcss.Root): void;
+export { removeUnsupportedCascadeLayers, } from '@weapp-tailwindcss/postcss';

package/dist/tailwindcss/runtime/cache.d.ts

@@ -1,11 +1,12 @@
 import type { TailwindcssPatcherLike } from '../../types';
 interface RuntimeClassSetCacheEntry {
-    value?: Set<string>;
-    promise?: Promise<Set<string>>;
-    signature?: string;
+    value?: Set<string> | undefined;
+    promise?: Promise<Set<string>> | undefined;
+    signature?: string | undefined;
 }
 export declare const runtimeSignaturePatchersSymbol: unique symbol;
 export declare function invalidateRuntimeClassSet(twPatcher?: TailwindcssPatcherLike): void;
 export declare function getRuntimeClassSetCacheEntry(twPatcher: TailwindcssPatcherLike): RuntimeClassSetCacheEntry;
 export declare function getRuntimeClassSetSignature(twPatcher: TailwindcssPatcherLike): string;
+export declare function getRuntimeClassSetSignatureWithSources(twPatcher: TailwindcssPatcherLike): Promise<string>;
 export {};

package/dist/tailwindcss/runtime-patch.d.ts

@@ -0,0 +1,5 @@
+import type { TailwindcssPatcherLike } from '../types';
+export interface EnsureTailwindcssRuntimePatchOptions {
+    clearRequireCache?: boolean;
+}
+export declare function ensureTailwindcssRuntimePatch(twPatcher: TailwindcssPatcherLike, options?: EnsureTailwindcssRuntimePatchOptions): Promise<void>;

package/dist/tailwindcss/runtime.d.ts

@@ -2,27 +2,26 @@ import type { RefreshTailwindcssPatcherOptions, TailwindcssPatcherLike } from '.
 import { invalidateRuntimeClassSet } from './runtime/cache';
 export declare const refreshTailwindcssPatcherSymbol: unique symbol;
 export interface CollectRuntimeClassSetOptions {
-    force?: boolean;
-    skipRefresh?: boolean;
-    clearCache?: boolean;
+    force?: boolean | undefined;
+    skipRefresh?: boolean | undefined;
+    clearCache?: boolean | undefined;
 }
 export interface RefreshTailwindRuntimeStateOptions {
     force: boolean;
-    clearCache?: boolean;
+    clearCache?: boolean | undefined;
 }
-export declare function createTailwindPatchPromise(twPatcher: TailwindcssPatcherLike, onPatched?: () => Promise<void> | void): Promise<void>;
+export declare function createTailwindRuntimeReadyPromise(twPatcher: TailwindcssPatcherLike): Promise<void>;
 export interface TailwindRuntimeState {
     twPatcher: TailwindcssPatcherLike;
-    patchPromise: Promise<void>;
-    refreshTailwindcssPatcher?: (options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>;
-    onPatchCompleted?: () => Promise<void> | void;
+    readyPromise: Promise<void>;
+    refreshTailwindcssPatcher?: ((options?: RefreshTailwindcssPatcherOptions) => Promise<TailwindcssPatcherLike>) | undefined;
 }
 export declare function refreshTailwindRuntimeState(state: TailwindRuntimeState, forceOrOptions: boolean | RefreshTailwindRuntimeStateOptions): Promise<boolean>;
 export interface EnsureRuntimeClassSetOptions {
-    forceRefresh?: boolean;
-    forceCollect?: boolean;
-    clearCache?: boolean;
-    allowEmpty?: boolean;
+    forceRefresh?: boolean | undefined;
+    forceCollect?: boolean | undefined;
+    clearCache?: boolean | undefined;
+    allowEmpty?: boolean | undefined;
 }
 export declare function ensureRuntimeClassSet(state: TailwindRuntimeState, options?: EnsureRuntimeClassSetOptions): Promise<Set<string>>;
 declare function collectRuntimeClassSet(twPatcher: TailwindcssPatcherLike, options?: CollectRuntimeClassSetOptions): Promise<Set<string>>;

package/dist/tailwindcss/source-scan.d.ts

@@ -0,0 +1,35 @@
+import type { Root } from 'postcss';
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+export interface TailwindSourceEntry {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+export interface TailwindInlineSourceCandidates {
+    included: Set<string>;
+    excluded: Set<string>;
+}
+export declare const DEFAULT_SOURCE_SCAN_EXTENSIONS: string[];
+export declare const FULL_SOURCE_SCAN_EXTENSIONS: string[];
+export declare function createSourceScanPattern(extensions?: string[]): string;
+export declare const FULL_SOURCE_SCAN_PATTERN: string;
+export declare const FULL_SOURCE_SCAN_EXTENSION_RE: RegExp;
+export declare function toPosixPath(value: string): string;
+export declare function resolveSourceScanPath(value: string): string;
+export declare function isFileExcludedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function isFileMatchedByTailwindSourceEntries(file: string, entries: TailwindSourceEntry[] | undefined): boolean;
+export declare function createTailwindSourceEntryMatcher(entries: TailwindSourceEntry[] | undefined): ((file: string) => boolean) | undefined;
+export declare function resolveTailwindV4CssSourceBase(source: Pick<TailwindV4CssSource, 'base' | 'file'>, fallbackBase: string): string;
+export declare function parseConfigParam(params: string): string | undefined;
+export declare function expandInlineSourceCandidatePattern(pattern: string): string[];
+export declare function collectCssInlineSourceCandidates(root: Root): TailwindInlineSourceCandidates;
+export declare function normalizeLegacyContentEntries(content: unknown, base: string): TailwindSourceEntry[];
+export declare function resolveTailwindSourceEntry(sourcePath: string, base: string, negated: boolean, defaultPattern?: string): Promise<TailwindSourceEntry>;
+export declare function parseSourceFileParam(params: string): {
+    negated: boolean;
+    sourcePath: string;
+} | undefined;
+export declare function resolveCssSourceEntries(root: Root, base: string, defaultPattern?: string): Promise<TailwindSourceEntry[]>;
+export declare function expandTailwindSourceEntries(entries: TailwindSourceEntry[], options?: {
+    ignore?: string[];
+}): Promise<string[]>;

package/dist/tailwindcss/targets.d.ts

@@ -1,6 +1,2 @@
 import type { TailwindcssPatcherLike } from '../types';
-import { __resetPatchTargetRecordWarningsForTests, saveCliPatchTargetRecord } from './targets/record-io';
-import { createPatchTargetRecorder } from './targets/recorder';
-export type { PatchTargetRecorder, PatchTargetRecorderOptions, SavePatchTargetRecordOptions } from './targets/types';
-export declare function logTailwindcssTarget(kind: 'cli' | 'runtime', patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;
-export { __resetPatchTargetRecordWarningsForTests, createPatchTargetRecorder, saveCliPatchTargetRecord, };
+export declare function logTailwindcssTarget(patcher: TailwindcssPatcherLike | undefined, baseDir?: string): void;

package/dist/tailwindcss/v3-engine/types.d.ts

@@ -3,7 +3,7 @@ import type { Config } from 'tailwindcss';
 export type TailwindV3GenerateTarget = 'weapp' | 'web' | 'tailwind';
 export interface TailwindV3CandidateSource {
     content: string;
-    extension?: string;
+    extension?: string | undefined;
 }
 export interface TailwindV3SourcePattern {
     base: string;
@@ -11,13 +11,13 @@ export interface TailwindV3SourcePattern {
     negated: boolean;
 }
 export interface TailwindV3SourceOptions {
-    projectRoot?: string;
-    cwd?: string;
-    base?: string;
-    css?: string;
-    config?: string;
-    packageName?: string;
-    postcssPlugin?: string;
+    projectRoot?: string | undefined;
+    cwd?: string | undefined;
+    base?: string | undefined;
+    css?: string | undefined;
+    config?: string | undefined;
+    packageName?: string | undefined;
+    postcssPlugin?: string | undefined;
 }
 export interface TailwindV3ResolvedSource {
     version: 3;
@@ -25,21 +25,24 @@ export interface TailwindV3ResolvedSource {
     cwd: string;
     base: string;
     css: string;
-    config?: string;
-    configObject?: Config;
+    config?: string | undefined;
+    configObject?: Config | undefined;
     dependencies: string[];
     packageName: string;
     postcssPlugin: string;
 }
 export interface TailwindV3GenerateOptions {
-    candidates?: Iterable<string>;
-    sources?: TailwindV3CandidateSource[];
-    target?: TailwindV3GenerateTarget;
-    styleOptions?: Partial<IStyleHandlerOptions>;
+    candidates?: Iterable<string> | undefined;
+    sources?: TailwindV3CandidateSource[] | undefined;
+    incrementalCache?: boolean | undefined;
+    target?: TailwindV3GenerateTarget | undefined;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
 }
 export interface TailwindV3GenerateResult {
     css: string;
     rawCss: string;
+    incrementalCss?: string | undefined;
+    incrementalRawCss?: string | undefined;
     classSet: Set<string>;
     rawCandidates: Set<string>;
     dependencies: string[];

package/dist/tailwindcss/v4/css-entries.d.ts

@@ -1,7 +1,7 @@
 export declare function guessBasedirFromEntries(entries?: string[]): string | undefined;
 export declare function normalizeCssEntries(entries: string[] | undefined, anchor: string): string[] | undefined;
 export interface GroupCssEntriesOptions {
-    preferredBaseDir?: string;
-    workspaceRoot?: string;
+    preferredBaseDir?: string | undefined;
+    workspaceRoot?: string | undefined;
 }
 export declare function groupCssEntriesByBase(entries: string[], options?: GroupCssEntriesOptions): Map<string, string[]>;

package/dist/tailwindcss/v4/css-sources.d.ts

@@ -0,0 +1,5 @@
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { UserDefinedOptions } from '../../types';
+export declare function hasCssSourcesValue(value: unknown): boolean;
+export declare function hasConfiguredTailwindV4CssRoots(options: Pick<UserDefinedOptions, 'cssEntries' | 'tailwindcss' | 'tailwindcssPatcherOptions'>): boolean;
+export declare function upsertTailwindV4CssSource(opts: UserDefinedOptions, source: TailwindV4CssSource): boolean;

package/dist/tailwindcss/v4/patcher-options.d.ts

@@ -1,24 +1,2 @@
 import type { TailwindCssPatchOptions } from 'tailwindcss-patch';
-type TailwindUserOptions = NonNullable<TailwindCssPatchOptions['tailwindcss']>;
-export interface LegacyTailwindcssPatcherOptionsLike {
-    patch?: {
-        basedir?: string;
-        cwd?: string;
-        tailwindcss?: TailwindUserOptions & {
-            v4?: {
-                base?: string;
-                cssEntries?: string[];
-                sources?: Array<{
-                    base?: string;
-                    pattern: string;
-                    negated?: boolean;
-                }>;
-            };
-        };
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
-type TailwindcssPatcherOptionsForBase = TailwindCssPatchOptions | LegacyTailwindcssPatcherOptionsLike | undefined;
-export declare function overrideTailwindcssPatcherOptionsForBase(options: TailwindcssPatcherOptionsForBase, baseDir: string, cssEntries: string[]): TailwindcssPatcherOptionsForBase;
-export {};
+export declare function overrideTailwindcssPatcherOptionsForBase(options: TailwindCssPatchOptions | undefined, baseDir: string, cssEntries: string[]): TailwindCssPatchOptions | undefined;

package/dist/tailwindcss/v4/patcher.d.ts

@@ -9,6 +9,7 @@ export interface TailwindcssPatcherFactoryOptions {
     tailwindcssPatcherOptions?: CreateTailwindcssPatcherOptions['tailwindcssPatcherOptions'];
     supportCustomLengthUnitsPatch: InternalUserDefinedOptions['supportCustomLengthUnitsPatch'];
     appType: InternalUserDefinedOptions['appType'];
+    bareArbitraryValues?: InternalUserDefinedOptions['arbitraryValues']['bareArbitraryValues'];
 }
 export declare function createPatcherForBase(baseDir: string, cssEntries: string[] | undefined, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike;
 export declare function tryCreateMultiTailwindcssPatcher(groups: Map<string, string[]>, options: TailwindcssPatcherFactoryOptions): TailwindcssPatcherLike | undefined;

package/dist/tailwindcss/v4-engine/source.d.ts

@@ -1,7 +1,7 @@
-import type { TailwindV4SourceOptions } from './types';
+import type { TailwindV4SourceOptions, TailwindV4SourceOptionsWithSources } from './types';
 import type { TailwindcssPatcherLike } from '../../types';
 import { resolveTailwindV4SourceFromPatchOptions } from 'tailwindcss-patch';
-export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptions;
+export declare function resolveTailwindV4SourceOptionsFromPatcher(patcher: TailwindcssPatcherLike): TailwindV4SourceOptionsWithSources;
 export declare function resolveTailwindV4Source(options?: TailwindV4SourceOptions): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
 export declare function resolveTailwindV4SourceFromPatcher(patcher: TailwindcssPatcherLike): Promise<import("tailwindcss-patch").TailwindV4ResolvedSource>;
 export { resolveTailwindV4SourceFromPatchOptions };

package/dist/tailwindcss/v4-engine/types.d.ts

@@ -1,15 +1,27 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
 import type { TailwindV4Engine as PatchTailwindV4Engine, TailwindV4GenerateOptions as PatchTailwindV4GenerateOptions, TailwindV4GenerateResult as PatchTailwindV4GenerateResult, TailwindV4CandidateSource, TailwindV4DesignSystem, TailwindV4ResolvedSource, TailwindV4SourceOptions } from 'tailwindcss-patch';
 export type TailwindV4GenerateTarget = 'weapp' | 'web' | 'tailwind';
-export interface TailwindV4GenerateOptions extends PatchTailwindV4GenerateOptions {
-    target?: TailwindV4GenerateTarget;
-    styleOptions?: Partial<IStyleHandlerOptions>;
-    tailwindcssV3Compatibility?: boolean;
-    scanSources?: boolean;
+export interface TailwindV4SourcePattern {
+    base: string;
+    pattern: string;
+    negated: boolean;
+}
+type TailwindV4PatchGenerateOptions = Omit<PatchTailwindV4GenerateOptions, 'target' | 'styleOptions' | 'tailwindcssV3Compatibility' | 'scanSources'>;
+export interface TailwindV4GenerateOptions extends TailwindV4PatchGenerateOptions {
+    incrementalCache?: boolean | undefined;
+    target?: TailwindV4GenerateTarget | undefined;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+    tailwindcssV3Compatibility?: boolean | undefined;
+    scanSources?: PatchTailwindV4GenerateOptions['scanSources'] | undefined;
+}
+export interface TailwindV4SourceOptionsWithSources extends TailwindV4SourceOptions {
+    sources?: TailwindV4SourcePattern[] | undefined;
 }
 export interface TailwindV4GenerateResult extends Omit<PatchTailwindV4GenerateResult, 'css'> {
     css: string;
     rawCss: string;
+    incrementalCss?: string | undefined;
+    incrementalRawCss?: string | undefined;
     target: TailwindV4GenerateTarget;
 }
 export interface TailwindV4Engine extends Omit<PatchTailwindV4Engine, 'generate'> {

package/dist/tailwindcss/version.d.ts

@@ -0,0 +1,4 @@
+export type SupportedTailwindcssMajorVersion = 3 | 4;
+export declare const DEFAULT_TAILWINDCSS_GENERATOR_MAJOR_VERSION: SupportedTailwindcssMajorVersion;
+export declare function normalizeSupportedTailwindcssMajorVersion(version: number | undefined): SupportedTailwindcssMajorVersion | undefined;
+export declare function readInstalledPackageMajorVersion(packageName: string, base: string): SupportedTailwindcssMajorVersion | undefined;