weapp-tailwindcss 5.0.0-next.9 → 5.0.1

package/dist/bundlers/vite/css-finalizer.d.ts

@@ -1,5 +1,6 @@
 import type { OutputAsset } from 'rollup';
 import type { Plugin, ResolvedConfig } from 'vite';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface CssFinalizerContext {
     opts: InternalUserDefinedOptions;
@@ -13,10 +14,15 @@ interface CssFinalizerContext {
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     recordCssAssetResult?: (file: string, css: string) => void;
+    recordViteProcessedCssAssetResult?: (file: string, css: string) => void;
+    getViteProcessedCssAssetResults?: () => Iterable<[string, string]>;
     getRecordedGeneratorCandidates?: () => Set<string> | undefined;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string) => void;
+    getRememberedMainCssSource?: (file: string) => string | undefined;
+    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
 }
 export declare function createViteCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;
 export {};

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

@@ -1,2 +1,2 @@
-export declare function collectUnescapedDynamicCandidates(source: string): string[];
+export declare function collectUnescapedDynamicCandidates(source: string, allowedCandidates?: Set<string>): string[];
 export declare function collectLegacyContainerCompatCandidates(sourceCandidates: Set<string>, candidates: Set<string>): Set<string>;

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

@@ -6,11 +6,15 @@ type CssHandlerOptions = IStyleHandlerOptions & {
         };
     };
     majorVersion: number | undefined;
+    sourceOptions?: {
+        outputRoot?: string | undefined;
+    } | undefined;
 };
 interface CssHandlerOptionsCacheOptions {
-    appType: InternalUserDefinedOptions['appType'];
+    getAppType: () => InternalUserDefinedOptions['appType'];
     mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
     getMajorVersion: () => number | undefined;
+    getOutputRoot?: (() => string | undefined) | undefined;
 }
 export interface CssHandlerOptionsCache {
     getCssHandlerOptions: (file: string) => CssHandlerOptions;

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

@@ -1,3 +1,4 @@
 import type { InternalUserDefinedOptions } from '../../../types';
+export declare function createCssTransformShareScope(file: string, rawSource: string): string;
 export declare function createCssTransformShareScopeKey(opts: InternalUserDefinedOptions, file: string, rawSource: string): string;
 export declare function createCssRuntimeSignature(runtimeSignature: string, generatorCandidateSignature: string): string;

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

@@ -1,6 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { ResolvedConfig } from 'vite';
+import type { HmrTimingRecorder } from '../shared/hmr-timing';
 import type { BundleSnapshot } from './bundle-state';
+import type { TailwindSourceEntry } from '../../tailwindcss/source-scan';
 import type { InternalUserDefinedOptions } from '../../types';
 interface GenerateBundleContext {
     opts: InternalUserDefinedOptions;
@@ -9,18 +11,27 @@ interface GenerateBundleContext {
         readyPromise: Promise<void>;
     };
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+        transformOnly?: boolean | undefined;
+    }) => Promise<Set<string>>;
     debug: (format: string, ...args: unknown[]) => void;
     getResolvedConfig: () => ResolvedConfig | undefined;
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
+    isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
     recordCssAssetResult?: (file: string, css: string) => void;
+    recordViteProcessedCssAssetResult?: (file: string, css: string) => void;
+    getViteProcessedCssAssetResults?: () => Iterable<[string, string]>;
     getSourceCandidates?: () => Set<string>;
+    getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined) => Set<string>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberMainCssSource?: (file: string, rawSource: string, cssRuntimeSignature: string) => void;
     getRememberedMainCssSources?: () => Map<string, string>;
     getRememberedMainCssSignature?: (file: string) => string | undefined;
     setRememberedMainCssSignature?: (file: string, cssRuntimeSignature: string) => void;
     recordGeneratorCandidates?: (candidates: Set<string>) => void;
+    hmrTimingRecorder?: HmrTimingRecorder;
 }
 interface GenerateBundleThis {
     addWatchFile?: (id: string) => void;
@@ -30,5 +41,6 @@ interface GenerateBundleThis {
         source: string;
     }) => string;
 }
+export declare function resolveReplayCssOutputFile(rootDir: string, file: string): string;
 export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;
 export {};

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

@@ -1,5 +1,6 @@
 import type { BundleSnapshot } from './bundle-state';
 import type { TailwindcssPatcherLike } from '../../types';
+import type { IArbitraryValues } from '../../types/shared';
 import { extractRawCandidatesWithPositions, extractValidCandidates } from 'tailwindcss-patch';
 type ExtractValidCandidatesOptions = Parameters<typeof extractValidCandidates>[0];
 type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
@@ -8,12 +9,19 @@ type MemoryExtractValidCandidatesOptions = ExtractValidCandidatesOptions & {
 };
 type ExtractValidCandidatesFn = (options?: MemoryExtractValidCandidatesOptions) => Promise<string[]>;
 type ExtractRawCandidateResult = Awaited<ReturnType<typeof extractRawCandidatesWithPositions>>;
-type ExtractRawCandidatesFn = (content: string, extension?: string) => Promise<ExtractRawCandidateResult>;
+type ExtractRawCandidatesFn = (content: string, extension?: string, options?: {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
+}) => Promise<ExtractRawCandidateResult>;
 export interface BundleRuntimeClassSetManager {
-    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot) => Promise<Set<string>>;
+    sync: (patcher: TailwindcssPatcherLike, snapshot: BundleSnapshot, options?: BundleRuntimeClassSetSyncOptions) => Promise<Set<string>>;
     reset: () => Promise<void>;
 }
+export interface BundleRuntimeClassSetSyncOptions {
+    baseClassSet?: Set<string> | undefined;
+    skipInitialFullScanWithBase?: boolean | undefined;
+}
 interface CreateBundleRuntimeClassSetManagerOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
     extractCandidates?: ExtractValidCandidatesFn;
     extractRawCandidates?: ExtractRawCandidatesFn;
 }

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

@@ -1,3 +1,6 @@
-import type { Plugin } from 'vite';
 import type { UserDefinedOptions } from '../../types';
-export declare function WeappTailwindcss(options?: UserDefinedOptions): Plugin[] | undefined;
+export interface WeappTailwindcssVitePlugin {
+    name: string;
+    [hook: string]: any;
+}
+export declare function WeappTailwindcss(options?: UserDefinedOptions): WeappTailwindcssVitePlugin[] | undefined;

package/dist/bundlers/vite/processed-css-assets.d.ts

@@ -0,0 +1,32 @@
+import type { OutputAsset, OutputBundle } from 'rollup';
+import type { InternalUserDefinedOptions } from '../../types';
+interface CssAssetMarkerMatcher {
+    (asset: OutputAsset, file?: string): boolean;
+}
+interface CssAssetProcessedMarker {
+    (asset: OutputAsset, file?: string): void;
+}
+interface CssAssetResultRecorder {
+    (file: string, css: string): void;
+}
+interface CssAssetResultsGetter {
+    (): Iterable<[string, string]>;
+}
+interface CollectViteProcessedCssAssetOptions {
+    isViteProcessedCssAsset?: CssAssetMarkerMatcher | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    recordViteProcessedCssAssetResult?: CssAssetResultRecorder | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+}
+interface InjectViteProcessedCssAssetOptions {
+    opts: InternalUserDefinedOptions;
+    getViteProcessedCssAssetResults?: CssAssetResultsGetter | undefined;
+    markCssAssetProcessed?: CssAssetProcessedMarker | undefined;
+    recordCssAssetResult?: CssAssetResultRecorder | undefined;
+    debug?: ((format: string, ...args: unknown[]) => void) | undefined;
+    onUpdate?: ((file: string, original: string, generated: string) => void) | undefined;
+}
+export declare function collectViteProcessedCssAssetResults(bundle: OutputBundle, options: CollectViteProcessedCssAssetOptions): number;
+export declare function injectViteProcessedCssIntoMainCssAssets(bundle: OutputBundle, options: InjectViteProcessedCssAssetOptions): number;
+export {};

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

@@ -1,13 +1,16 @@
 import type { Plugin } from 'vite';
 import type { AppType } from '../../types';
 interface RewriteCssImportsOptions {
-    appType?: AppType;
-    getAppType?: () => AppType | undefined;
-    shouldOwnTailwindGeneration?: boolean;
+    appType?: AppType | undefined;
+    getAppType?: (() => AppType | undefined) | undefined;
+    generateTailwindCss?: ((id: string, code: string, hookContext?: {
+        addWatchFile?: (id: string) => void;
+    }) => Promise<string | undefined> | string | undefined) | undefined;
+    shouldOwnTailwindGeneration?: boolean | undefined;
     shouldRewrite: boolean;
-    rootImport?: string;
+    rootImport?: string | undefined;
     weappTailwindcssDirPosix: string;
-    onTailwindRootCss?: (id: string, code: string) => Promise<void> | void;
+    onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
 }
 export declare function createRewriteCssImportsPlugins(options: RewriteCssImportsOptions): Plugin[];
 export {};

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

@@ -17,6 +17,10 @@ export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClas
     };
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
-    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean) => Promise<Set<string>>;
+    ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {
+        allowBaselineOnlyInitialSync?: boolean | undefined;
+        baseClassSet?: Set<string> | undefined;
+        transformOnly?: boolean | undefined;
+    }) => Promise<Set<string>>;
 };
 export {};

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

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+interface ViteServeCssGenerationOptions {
+    generateCss: (id: string, code: string, hookContext?: {
+        addWatchFile?: (id: string) => void;
+    }) => Promise<string | undefined> | string | undefined;
+    getCommand: () => string | undefined;
+    onTailwindRootCss?: ((id: string, code: string) => Promise<void> | void) | undefined;
+    shouldGenerate: () => boolean;
+}
+export declare function createViteServeCssGenerationPlugins(options: ViteServeCssGenerationOptions): Plugin[];
+export {};

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

@@ -1,15 +1,37 @@
+import type { TailwindInlineSourceCandidates, TailwindSourceEntry } from '../../tailwindcss/source-scan';
+import type { IArbitraryValues } from '../../types/shared';
 export interface SourceCandidateCollector {
     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>;
+    syncCurrentFile: (id: string) => Promise<void>;
     scanRoot: (options: ScanSourceCandidateRootOptions) => Promise<void>;
+    syncInline: (inlineCandidates: TailwindInlineSourceCandidates | undefined) => void;
     remove: (id: string) => void;
     values: () => Set<string>;
+    valuesForEntries: (entries: TailwindSourceEntry[] | undefined) => Set<string>;
+    snapshot: () => SourceCandidateCollectorSnapshot;
+    restore: (snapshot: SourceCandidateCollectorSnapshot) => void;
     clear: () => void;
 }
+export interface SourceCandidateCollectorSnapshot {
+    candidatesById: Array<[string, string[]]>;
+    cssCandidatesById?: Array<[string, string[]]> | undefined;
+    scanCandidatesById?: Array<[string, string[]]> | undefined;
+    transformCandidatesById?: Array<[string, string[]]> | undefined;
+    inlineExcludedCandidates: string[];
+    inlineIncludedCandidates: string[];
+}
 interface ScanSourceCandidateRootOptions {
     root: string;
-    outDir?: string;
+    outDir?: string | undefined;
+    entries?: TailwindSourceEntry[] | undefined;
+    explicit?: boolean | undefined;
+}
+export interface SourceCandidateCollectorOptions {
+    bareArbitraryValues?: IArbitraryValues['bareArbitraryValues'] | undefined;
 }
 export declare function isSourceCandidateRequest(id: string): boolean;
-export declare function createSourceCandidateCollector(): SourceCandidateCollector;
+export declare function createSourceCandidateCollector(options?: SourceCandidateCollectorOptions): SourceCandidateCollector;
 export {};

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

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

package/dist/bundlers/vite/static-config-content.d.ts

@@ -0,0 +1,5 @@
+type StaticContentValue = string | StaticContentValue[] | {
+    files: StaticContentValue;
+};
+export declare function readStaticConfigContent(configPath: string): StaticContentValue | undefined;
+export {};

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

@@ -15,7 +15,12 @@ interface WebpackWatchChangeLike {
     modifiedFiles?: Set<string>;
     removedFiles?: Set<string>;
 }
+interface RuntimeWatchDependenciesLike {
+    files?: Iterable<string>;
+    contexts?: Iterable<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;
+export declare function isWatchFileInRuntimeDependencies(file: string, dependencies: RuntimeWatchDependenciesLike): boolean;
 export {};

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

@@ -1,16 +1,20 @@
 import type { Compiler } from 'webpack';
+import type { BundleRuntimeClassSetManager } from '../../vite/incremental-runtime-class-set';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5ProcessAssetsHookOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     runtimeState: {
         twPatcher: InternalUserDefinedOptions['twPatcher'];
         readyPromise: Promise<void>;
     };
     getRuntimeRefreshRequirement: () => boolean;
     refreshRuntimeMetadata: (force: boolean) => Promise<void>;
+    isWebpackProcessedCssAsset?: ((file: string, rawSource: string) => boolean) | undefined;
     consumeRuntimeRefreshRequirement: () => void;
+    isWatchMode?: (() => boolean) | undefined;
+    runtimeClassSetManager?: BundleRuntimeClassSetManager | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function setupWebpackV5ProcessAssetsHook(options: SetupWebpackV5ProcessAssetsHookOptions): void;

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

@@ -1,19 +1,24 @@
 import type { TailwindV4CssSource } from 'tailwindcss-patch';
 import type { Compiler } from 'webpack';
+import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
 import type { AppType, InternalUserDefinedOptions } from '../../../types';
 interface SetupWebpackV5LoadersOptions {
     compiler: Compiler;
     options: InternalUserDefinedOptions;
-    appType?: AppType;
+    appType?: AppType | undefined;
     weappTailwindcssPackageDir: string;
     shouldRewriteCssImports: boolean;
-    runtimeLoaderPath?: string;
-    registerAutoCssSource?: (source: TailwindV4CssSource) => Promise<void> | void;
+    runtimeLoaderPath?: string | undefined;
+    registerAutoCssSource?: ((source: TailwindV4CssSource) => Promise<void> | void) | undefined;
+    runtimeState: TailwindRuntimeState;
     getClassSetInLoader: () => Promise<void>;
+    getRuntimeSetInLoader: () => Promise<Set<string>>;
+    markWebpackProcessedCssSource?: ((file: string) => void) | undefined;
     getRuntimeWatchDependencies: () => {
         files: ReadonlySet<string>;
         contexts: ReadonlySet<string>;
     };
+    runtimeRegistryKey?: string | undefined;
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function setupWebpackV5Loaders(options: SetupWebpackV5LoadersOptions): void;

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

@@ -1,7 +1,7 @@
 import type { Compiler } from 'webpack';
 import type { AppType, IBaseWebpackPlugin, InternalUserDefinedOptions, UserDefinedOptions } from '../../../types';
 export declare const weappTailwindcssPackageDir: string;
-export declare class UnifiedWebpackPluginV5 implements IBaseWebpackPlugin {
+export declare class WeappTailwindcss implements IBaseWebpackPlugin {
     options: InternalUserDefinedOptions;
     appType?: AppType;
     private hasInitialTailwindCssRoots;

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

@@ -0,0 +1,31 @@
+import type { TailwindV4CssSource } from 'tailwindcss-patch';
+import type { TailwindRuntimeState } from '../../../tailwindcss/runtime';
+import type { AppType, InternalUserDefinedOptions } from '../../../types';
+export interface WebpackRuntimeClassSetLoaderOptions {
+    getClassSet?: () => void | Promise<void>;
+    getWatchDependencies?: () => RuntimeLoaderWatchDependencies | Promise<RuntimeLoaderWatchDependencies | void> | void;
+}
+export interface RuntimeLoaderWatchDependencies {
+    files?: Iterable<string>;
+    contexts?: Iterable<string>;
+}
+export interface WebpackCssImportRewriteRuntimeOptions {
+    pkgDir: string;
+    appType?: AppType;
+    compilerOptions?: InternalUserDefinedOptions;
+    runtimeState?: TailwindRuntimeState;
+    registerCssSource?: (source: TailwindV4CssSource) => Promise<void> | void;
+    getRuntimeSet?: () => Promise<Set<string>> | Set<string>;
+    markGeneratedCssSource?: (file: string) => void;
+}
+export interface WebpackCssImportRewriteLoaderOptions {
+    tailwindcssImportRewrite?: WebpackCssImportRewriteRuntimeOptions;
+    tailwindcssImportRewriteRuntimeKey?: string;
+}
+export interface WebpackLoaderRuntimeEntry {
+    classSet?: WebpackRuntimeClassSetLoaderOptions;
+    cssImportRewrite?: WebpackCssImportRewriteRuntimeOptions;
+}
+export declare function setWebpackLoaderRuntime(key: string, entry: WebpackLoaderRuntimeEntry): void;
+export declare function deleteWebpackLoaderRuntime(key: string): void;
+export declare function getWebpackLoaderRuntime(key?: string): any;

package/dist/bundlers/webpack/loaders/weapp-tw-css-import-rewrite-loader.d.ts

@@ -1,13 +1,7 @@
-import type { TailwindV4CssSource } from 'tailwindcss-patch';
 import type webpack from 'webpack';
-import type { AppType } from '../../../types';
+import type { WebpackCssImportRewriteLoaderOptions } from './runtime-registry';
 import { Buffer } from 'node:buffer';
-interface CssImportRewriteLoaderOptions {
-    tailwindcssImportRewrite?: {
-        pkgDir: string;
-        appType?: AppType;
-        registerCssSource?: (source: TailwindV4CssSource) => Promise<void> | void;
-    };
+interface CssImportRewriteLoaderOptions extends WebpackCssImportRewriteLoaderOptions {
 }
 export declare function transformCssImportRewriteSource(source: string | Buffer, options: CssImportRewriteLoaderOptions | undefined): string | Buffer<ArrayBufferLike>;
 declare const WeappTwCssImportRewriteLoader: webpack.LoaderDefinitionFunction<CssImportRewriteLoaderOptions>;

package/dist/bundlers/webpack/loaders/weapp-tw-runtime-classset-loader.d.ts

@@ -1,11 +1,7 @@
 import type webpack from 'webpack';
-interface RuntimeClassSetLoaderOptions {
-    getClassSet?: () => void | Promise<void>;
-    getWatchDependencies?: () => RuntimeLoaderWatchDependencies | Promise<RuntimeLoaderWatchDependencies | void> | void;
-}
-interface RuntimeLoaderWatchDependencies {
-    files?: Iterable<string>;
-    contexts?: Iterable<string>;
+import type { WebpackRuntimeClassSetLoaderOptions } from './runtime-registry';
+interface RuntimeClassSetLoaderOptions extends WebpackRuntimeClassSetLoaderOptions {
+    weappTailwindcssRuntimeKey?: string;
 }
 declare const WeappTwRuntimeClassSetLoader: webpack.LoaderDefinitionFunction<RuntimeClassSetLoaderOptions>;
 export default WeappTwRuntimeClassSetLoader;

package/dist/cache/index.d.ts

@@ -9,16 +9,16 @@ export type HashMapKey = string | number;
 export type CacheValue = sources.Source | string;
 export interface CacheProcessResult<T extends CacheValue> {
     result: T;
-    cacheValue?: CacheValue;
+    cacheValue?: CacheValue | undefined;
 }
 export interface CacheProcessOptions<T extends CacheValue> {
     key: string;
-    hashKey?: HashMapKey;
-    rawSource?: string | Buffer;
-    hash?: string;
-    resolveCache?: () => T | undefined;
+    hashKey?: HashMapKey | undefined;
+    rawSource?: string | Buffer | undefined;
+    hash?: string | undefined;
+    resolveCache?: (() => T | undefined) | undefined;
     transform: () => Promise<CacheProcessResult<T> | T>;
-    onCacheHit?: (value: T) => void | Promise<void>;
+    onCacheHit?: ((value: T) => void | Promise<void>) | undefined;
 }
 export interface ICreateCacheReturnType {
     readonly hashMap: Map<HashMapKey, HashMapValue>;

package/dist/{chunk-8l464Juk.js → chunk-C5U5_Hdc.js}

@@ -5,6 +5,8 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -20,6 +22,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__esmMin", {
+	enumerable: true,
+	get: function() {
+		return __esmMin;
+	}
+});
 Object.defineProperty(exports, "__toESM", {
 	enumerable: true,
 	get: function() {

package/dist/cli/context.d.ts

@@ -1,13 +1,3 @@
 import type { UserDefinedOptions } from '../types';
-export declare function createCliContext(overrides: Partial<UserDefinedOptions> | undefined, resolvedCwd: string | undefined): Required<Omit<UserDefinedOptions, "supportCustomLengthUnitsPatch" | "customReplaceDictionary" | "cache"> & {
-    supportCustomLengthUnitsPatch: import("tailwindcss-patch").ILengthUnitsPatchOptions | boolean;
-    templateHandler: (rawSource: string, options?: import("@/types").ITemplateHandlerOptions) => Promise<string>;
-    styleHandler: (rawSource: string, options?: import("@weapp-tailwindcss/postcss").IStyleHandlerOptions) => Promise<import("postcss").Result<import("postcss").Root | import("postcss").Document>>;
-    jsHandler: import("@/types").JsHandler;
-    escapeMap: Record<string, string>;
-    customReplaceDictionary: Record<string, string>;
-    cache: import("../cache").ICreateCacheReturnType;
-    twPatcher: import("@/types").TailwindcssPatcherLike;
-    refreshTailwindcssPatcher: (options?: import("@/types").RefreshTailwindcssPatcherOptions) => Promise<import("@/types").TailwindcssPatcherLike>;
-}>;
+export declare function createCliContext(overrides: Partial<UserDefinedOptions> | undefined, resolvedCwd: string | undefined): import("@/types").InternalUserDefinedOptions;
 export declare function formatOutputPath(target: string, baseDir?: string): string;

package/dist/cli/doctor/types.d.ts

@@ -4,28 +4,28 @@ export interface DoctorCheck {
     title: string;
     status: DoctorCheckStatus;
     message: string;
-    suggestion?: string;
+    suggestion?: string | undefined;
 }
 export interface DoctorReport {
     cwd: string;
     nodeVersion: string;
     detected: {
-        packageManager?: string;
+        packageManager?: string | undefined;
         frameworks: string[];
-        tailwindcssVersion?: string;
-        weappTailwindcssVersion?: string;
+        tailwindcssVersion?: string | undefined;
+        weappTailwindcssVersion?: string | undefined;
     };
     summary: Record<DoctorCheckStatus, number>;
     checks: DoctorCheck[];
 }
 export interface DoctorOptions {
-    cwd?: string;
-    nodeVersion?: string;
+    cwd?: string | undefined;
+    nodeVersion?: string | undefined;
 }
 export interface PackageJson {
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    optionalDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
-    packageManager?: string;
+    dependencies?: Record<string, string> | undefined;
+    devDependencies?: Record<string, string> | undefined;
+    optionalDependencies?: Record<string, string> | undefined;
+    peerDependencies?: Record<string, string> | undefined;
+    packageManager?: string | undefined;
 }

package/dist/cli/vscode-entry.d.ts

@@ -3,9 +3,9 @@ export declare const DEFAULT_VSCODE_SOURCES: string[];
 export interface GenerateVscodeEntryOptions {
     baseDir: string;
     cssEntry: string;
-    output?: string;
-    sources?: string[];
-    force?: boolean;
+    output?: string | undefined;
+    sources?: string[] | undefined;
+    force?: boolean | undefined;
 }
 export interface GenerateVscodeEntryResult {
     outputPath: string;