tailwindcss-patch 7.1.5 → 8.0.0

package/dist/index.d.mts

@@ -1,45 +1,128 @@
-import { PatchUserConfig } from '@tailwindcss-mangle/config';
-export { TailwindcssUserConfig, defineConfig } from '@tailwindcss-mangle/config';
-import { Node, Rule } from 'postcss';
+import postcss, { Node, Rule } from 'postcss';
 import { Config } from 'tailwindcss';
-import { PackageInfo } from 'local-pkg';
 import { SourceEntry } from '@tailwindcss/oxide';
+import { PackageResolvingOptions, PackageInfo } from 'local-pkg';
+import { TailwindLocatorOptions, TailwindNextOptions } from '@tailwindcss-mangle/config';
+export { defineConfig } from '@tailwindcss-mangle/config';
 import * as consola from 'consola';
 
 type CacheStrategy = 'merge' | 'overwrite';
-
-interface CacheOptions {
-    dir?: string;
+interface CacheUserOptions {
+    enabled?: boolean;
     cwd?: string;
+    dir?: string;
     file?: string;
     strategy?: CacheStrategy;
 }
-interface InternalCacheOptions extends CacheOptions {
-    enable?: boolean;
+interface OutputUserOptions {
+    enabled?: boolean;
+    file?: string;
+    format?: 'json' | 'lines';
+    pretty?: number | boolean;
+    removeUniversalSelector?: boolean;
+}
+interface ExposeContextUserOptions {
+    refProperty?: string;
+}
+interface ExtendLengthUnitsUserOptions extends Partial<ILengthUnitsPatchOptions> {
+    enabled?: boolean;
 }
-interface PatchOptions extends PatchUserConfig {
+interface FeatureUserOptions {
+    exposeContext?: boolean | ExposeContextUserOptions;
+    extendLengthUnits?: false | ExtendLengthUnitsUserOptions;
+}
+interface TailwindConfigUserOptions {
+    config?: string;
+    cwd?: string;
+    postcssPlugin?: string;
+}
+interface TailwindV4UserOptions {
+    base?: string;
+    css?: string;
+    cssEntries?: string[];
+    sources?: SourceEntry[];
+}
+interface TailwindUserOptions extends TailwindConfigUserOptions {
+    /**
+     * Optional hint for picking the patch strategy.
+     * When omitted we infer from the installed Tailwind CSS package version.
+     */
+    version?: 2 | 3 | 4;
+    packageName?: string;
+    resolve?: PackageResolvingOptions;
+    v2?: TailwindConfigUserOptions;
+    v3?: TailwindConfigUserOptions;
+    v4?: TailwindV4UserOptions;
+}
+interface TailwindcssPatchOptions {
+    /**
+     * Base directory used when resolving Tailwind resources.
+     * Defaults to `process.cwd()`.
+     */
+    cwd?: string;
     overwrite?: boolean;
-    paths?: string[];
-    basedir?: string;
-    applyPatches?: {
-        exportContext?: boolean;
-        extendLengthUnits?: boolean | ILengthUnitsPatchOptions;
-    };
+    tailwind?: TailwindUserOptions;
+    features?: FeatureUserOptions;
     filter?: (className: string) => boolean;
-    cwd?: string;
+    cache?: boolean | CacheUserOptions;
+    output?: OutputUserOptions;
+}
+interface NormalizedOutputOptions {
+    enabled: boolean;
+    file?: string;
+    format: 'json' | 'lines';
+    pretty: number | false;
+    removeUniversalSelector: boolean;
+}
+interface NormalizedCacheOptions {
+    enabled: boolean;
+    cwd: string;
+    dir: string;
+    file: string;
+    path: string;
+    strategy: CacheStrategy;
+}
+interface NormalizedExposeContextOptions {
+    enabled: boolean;
+    refProperty: string;
+}
+interface NormalizedExtendLengthUnitsOptions extends ILengthUnitsPatchOptions {
+    enabled: boolean;
+}
+interface NormalizedTailwindV4Options {
+    base: string;
+    css?: string;
+    cssEntries: string[];
+    sources: SourceEntry[];
 }
-interface InternalPatchOptions extends PatchOptions {
-    version?: string;
+interface NormalizedTailwindConfigOptions extends TailwindConfigUserOptions {
+    packageName: string;
+    versionHint?: 2 | 3 | 4;
+    resolve?: PackageResolvingOptions;
+    v2?: TailwindConfigUserOptions;
+    v3?: TailwindConfigUserOptions;
+    v4?: NormalizedTailwindV4Options;
 }
-interface TailwindcssPatcherOptions {
-    cache?: CacheOptions | boolean;
-    patch?: PatchOptions;
+interface NormalizedFeatureOptions {
+    exposeContext: NormalizedExposeContextOptions;
+    extendLengthUnits: NormalizedExtendLengthUnitsOptions | null;
 }
-type TailwindcssClassCache = Map<string, ({
+interface NormalizedTailwindcssPatchOptions {
+    projectRoot: string;
+    overwrite: boolean;
+    tailwind: NormalizedTailwindConfigOptions;
+    features: NormalizedFeatureOptions;
+    output: NormalizedOutputOptions;
+    cache: NormalizedCacheOptions;
+    filter: (className: string) => boolean;
+}
+
+type TailwindcssClassCacheEntry = Rule | {
     layer: string;
     options: Record<string, any>;
     sort: Record<string, any>;
-} | Rule)[]>;
+};
+type TailwindcssClassCache = Map<string, TailwindcssClassCacheEntry[]>;
 interface TailwindcssRuntimeContext {
     applyClassCache: Map<any, any>;
     candidateRuleCache: Map<string, Set<[
@@ -58,11 +141,11 @@ interface TailwindcssRuntimeContext {
     changedContent: any[];
     classCache: TailwindcssClassCache;
     disposables: any[];
-    getClassList: Function;
-    getClassOrder: Function;
-    getVariants: Function;
-    markInvalidUtilityCandidate: Function;
-    markInvalidUtilityNode: Function;
+    getClassList: (...args: any[]) => any;
+    getClassOrder: (...args: any[]) => any;
+    getVariants: (...args: any[]) => any;
+    markInvalidUtilityCandidate: (...args: any[]) => any;
+    markInvalidUtilityNode: (...args: any[]) => any;
     notClassCache: Set<string>;
     offsets: {
         layerPositions: object;
@@ -75,12 +158,19 @@ interface TailwindcssRuntimeContext {
     stylesheetCache: Record<string, Set<any>>;
     tailwindConfig: Config;
     userConfigPath: string | null;
-    variantMap: Map<string, [[object, Function]]>;
+    variantMap: Map<string, [[object, (...args: any[]) => unknown]]>;
     variantOptions: Map<string, object>;
 }
-type DeepRequired<T> = {
-    [K in keyof T]: Required<DeepRequired<T[K]>>;
-};
+interface ExtractResult {
+    classList: string[];
+    classSet: Set<string>;
+    filename?: string;
+}
+interface TailwindPatchRuntime {
+    options: NormalizedTailwindcssPatchOptions;
+    majorVersion: 2 | 3 | 4;
+}
+
 interface ILengthUnitsPatchOptions {
     units: string[];
     lengthUnitsFilePath?: string;
@@ -89,17 +179,79 @@ interface ILengthUnitsPatchOptions {
     destPath?: string;
 }
 
-declare function getCacheOptions(options?: CacheOptions | boolean): InternalCacheOptions;
-declare class CacheManager {
-    options: Required<CacheOptions> & {
-        filename: string;
-    };
-    constructor(options?: CacheOptions);
-    getOptions(options?: CacheOptions): Required<CacheOptions> & {
-        filename: string;
+interface ExposeContextPatchParams {
+    rootDir: string;
+    refProperty: string;
+    overwrite: boolean;
+    majorVersion: 2 | 3;
+}
+interface ExposeContextPatchResult {
+    applied: boolean;
+    files: Record<string, string>;
+}
+declare function applyExposeContextPatch(params: ExposeContextPatchParams): ExposeContextPatchResult;
+
+declare function applyExtendLengthUnitsPatchV3(rootDir: string, options: NormalizedExtendLengthUnitsOptions): {
+    changed: boolean;
+    code: undefined;
+} | {
+    changed: boolean;
+    code: string;
+};
+interface V4FilePatch {
+    file: string;
+    code: string;
+    hasPatched: boolean;
+}
+interface V4Candidate extends V4FilePatch {
+    match: RegExpExecArray;
+}
+declare function applyExtendLengthUnitsPatchV4(rootDir: string, options: NormalizedExtendLengthUnitsOptions): {
+    changed: boolean;
+    files: V4Candidate[];
+};
+
+interface PatchRunnerResult {
+    exposeContext?: ReturnType<typeof applyExposeContextPatch>;
+    extendLengthUnits?: ReturnType<typeof applyExtendLengthUnitsPatchV3> | ReturnType<typeof applyExtendLengthUnitsPatchV4>;
+}
+
+interface LegacyCacheOptions {
+    dir?: string;
+    cwd?: string;
+    file?: string;
+    strategy?: 'merge' | 'overwrite';
+    enabled?: boolean;
+}
+interface LegacyOutputOptions {
+    filename?: string;
+    loose?: boolean;
+    removeUniversalSelector?: boolean;
+}
+interface LegacyTailwindcssOptions {
+    version?: 2 | 3 | 4;
+    v2?: TailwindLocatorOptions;
+    v3?: TailwindLocatorOptions;
+    v4?: TailwindNextOptions;
+    config?: string;
+    cwd?: string;
+}
+interface LegacyPatchOptions {
+    packageName?: string;
+    output?: LegacyOutputOptions;
+    tailwindcss?: LegacyTailwindcssOptions;
+    overwrite?: boolean;
+    applyPatches?: {
+        exportContext?: boolean;
+        extendLengthUnits?: boolean | ILengthUnitsPatchOptions;
     };
-    write(data: Set<string>): string | undefined;
-    read(): Set<string>;
+    filter?: (className: string) => boolean;
+    cwd?: string;
+    resolve?: PackageResolvingOptions;
+}
+interface LegacyTailwindcssPatcherOptions {
+    cache?: LegacyCacheOptions | boolean;
+    patch?: LegacyPatchOptions;
 }
 
 interface ExtractValidCandidatesOption {
@@ -108,59 +260,57 @@ interface ExtractValidCandidatesOption {
     css?: string;
     cwd?: string;
 }
+declare function extractRawCandidatesWithPositions(content: string, extension?: string): Promise<{
+    rawCandidate: string;
+    start: number;
+    end: number;
+}[]>;
+declare function extractRawCandidates(sources?: SourceEntry[]): Promise<string[]>;
 declare function extractValidCandidates(options?: ExtractValidCandidatesOption): Promise<string[]>;
 
-interface PatchExtractOptions {
-    write?: boolean;
-}
+type TailwindMajorVersion = 2 | 3 | 4;
+type TailwindcssPatcherInitOptions = TailwindcssPatchOptions | LegacyTailwindcssPatcherOptions;
 declare class TailwindcssPatcher {
-    rawOptions: TailwindcssPatcherOptions;
-    cacheOptions: InternalCacheOptions;
-    patchOptions: InternalPatchOptions;
-    patch: () => void;
-    cacheManager: CacheManager;
-    packageInfo: PackageInfo;
-    majorVersion?: number;
-    filter?: (className: string) => boolean;
-    constructor(options?: TailwindcssPatcherOptions);
-    setCache(set: Set<string>): string | undefined;
-    getCache(): Set<string>;
+    readonly options: NormalizedTailwindcssPatchOptions;
+    readonly packageInfo: PackageInfo;
+    readonly majorVersion: TailwindMajorVersion;
+    private readonly cacheStore;
+    constructor(options?: TailwindcssPatcherInitOptions);
+    patch(): Promise<PatchRunnerResult>;
     getContexts(): TailwindcssRuntimeContext[];
-    getClassCaches(): TailwindcssClassCache[];
-    getClassCacheSet(): Promise<Set<string>>;
-    getClassCacheSetV3(): Set<string>;
-    /**
-     * @description 在多个 tailwindcss 上下文时，这个方法将被执行多次，所以策略上应该使用 append
-     */
+    private runTailwindBuildIfNeeded;
+    private collectClassSet;
+    private mergeWithCache;
     getClassSet(): Promise<Set<string>>;
-    getClassSetV3(): Set<string>;
-    extract(options?: PatchExtractOptions): Promise<{
-        classList: string[];
-        classSet: Set<string>;
-        filename?: string;
-    } | undefined>;
+    extract(options?: {
+        write?: boolean;
+    }): Promise<ExtractResult>;
     extractValidCandidates: typeof extractValidCandidates;
 }
 
-declare function monkeyPatchForExposingContextV3(twDir: string, opt: InternalPatchOptions): Record<string, any> | undefined;
-declare function monkeyPatchForExposingContextV2(twDir: string, opt: InternalPatchOptions): Record<string, any>;
-
-declare function monkeyPatchForSupportingCustomUnitV3(rootDir: string, options?: Partial<ILengthUnitsPatchOptions>): {
-    [x: string]: string;
-} | undefined;
-interface V4GuessFile {
-    code: string;
-    hasPatched: boolean;
-    file: string;
-    matches: RegExpMatchArray;
+declare class CacheStore {
+    private readonly options;
+    constructor(options: NormalizedCacheOptions);
+    private ensureDir;
+    write(data: Set<string>): Promise<string | undefined>;
+    read(): Promise<Set<string>>;
 }
-declare function monkeyPatchForSupportingCustomUnitV4(rootDir: string, options?: Partial<ILengthUnitsPatchOptions>): {
-    files: V4GuessFile[];
-};
-
-declare function internalPatch(pkgJsonPath: PackageInfo, options: InternalPatchOptions): any;
-declare function internalPatch(pkgJsonPath: string, options: InternalPatchOptions): any;
 
 declare const logger: consola.ConsolaInstance;
 
-export { CacheManager, type CacheOptions, type CacheStrategy, type DeepRequired, type ILengthUnitsPatchOptions, type InternalCacheOptions, type InternalPatchOptions, type PatchExtractOptions, type PatchOptions, type TailwindcssClassCache, TailwindcssPatcher, type TailwindcssPatcherOptions, type TailwindcssRuntimeContext, getCacheOptions, internalPatch, logger, monkeyPatchForExposingContextV2, monkeyPatchForExposingContextV3, monkeyPatchForSupportingCustomUnitV3, monkeyPatchForSupportingCustomUnitV4 };
+declare function normalizeOptions(options?: TailwindcssPatchOptions): NormalizedTailwindcssPatchOptions;
+
+declare function collectClassesFromContexts(contexts: TailwindcssRuntimeContext[], filter: (className: string) => boolean): Set<string>;
+declare function collectClassesFromTailwindV4(options: NormalizedTailwindcssPatchOptions): Promise<Set<string>>;
+
+declare function loadRuntimeContexts(packageInfo: PackageInfo, majorVersion: 2 | 3 | 4, refProperty: string): TailwindcssRuntimeContext[];
+
+interface TailwindBuildOptions {
+    cwd: string;
+    config?: string;
+    majorVersion: 2 | 3 | 4;
+    postcssPlugin?: string;
+}
+declare function runTailwindBuild(options: TailwindBuildOptions): Promise<postcss.Result<postcss.Root>>;
+
+export { CacheStore, type CacheStrategy, type ExtractResult, type ILengthUnitsPatchOptions, type NormalizedTailwindcssPatchOptions, type TailwindPatchRuntime, type TailwindcssClassCache, type TailwindcssPatchOptions, TailwindcssPatcher, type TailwindcssRuntimeContext, collectClassesFromContexts, collectClassesFromTailwindV4, extractRawCandidates, extractRawCandidatesWithPositions, extractValidCandidates, loadRuntimeContexts, logger, normalizeOptions, runTailwindBuild };