weapp-tailwindcss 5.1.15 → 5.2.0

package/dist/bundlers/vite/generate-bundle/finalize/root-import-shell.d.ts

@@ -0,0 +1,69 @@
+import type { OutputAsset, OutputChunk } from 'rollup';
+import type { BundleBuildState, BundleSnapshot } from '../../bundle-state.js';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../../shared/framework-strategy.js';
+import type { BundleMetrics } from '../metrics.js';
+import type { GenerateBundleContext } from '../types.js';
+export interface FinalizeGenerateBundleOptions {
+    activeProcessCacheKeys: Set<string>;
+    activeProcessHashKeys: Set<string | number>;
+    activeViteCssCacheFiles: Set<string>;
+    bundle: Record<string, OutputAsset | OutputChunk>;
+    bundleFiles: string[];
+    cache: GenerateBundleContext['opts']['cache'];
+    cssTaskFactories: Array<() => Promise<void>>;
+    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
+    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
+    debug: GenerateBundleContext['debug'];
+    defaultStyleOutputExtension: string;
+    formatIteration: number;
+    generatorCandidateSignature: string;
+    generatorRuntime: Set<string>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
+    getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
+    getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    hmrTimingRecorder: GenerateBundleContext['hmrTimingRecorder'];
+    hmrTimingStartedAt: number;
+    isHarmonyAppStyleTarget: boolean;
+    isNativeAppStyleTarget: boolean;
+    isViteProcessedCssAsset: GenerateBundleContext['isViteProcessedCssAsset'];
+    isWebGeneratorTarget: boolean;
+    jsAfterCss: boolean;
+    jsTaskFactories: Array<() => Promise<void>>;
+    lastCssResultByFile: Map<string, string>;
+    lastCssSourceHashByFile: Map<string, string>;
+    linkedByEntry: Map<string, Set<string>> | undefined;
+    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
+    metrics: BundleMetrics;
+    onEnd: GenerateBundleContext['opts']['onEnd'];
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    opts: GenerateBundleContext['opts'];
+    outDir: string;
+    pendingLinkedUpdates: Array<() => void>;
+    pruneViteCssCaches: GenerateBundleContext['pruneViteCssCaches'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+    recordTimingDetail: (name: string, startedAt: number) => void;
+    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
+    rootDir: string;
+    runtime: Set<string>;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    shouldPreserveAppCssExtension: boolean;
+    snapshot: BundleSnapshot;
+    sourceCandidates: Set<string>;
+    sourceRoot: string | undefined;
+    state: BundleBuildState;
+    styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    tasks: Promise<void>[];
+    timingDetails: Record<string, number>;
+    transformRuntime: Set<string>;
+    transformWebTargetCss?: ((css: string, file: string) => string) | undefined;
+    useIncrementalMode: boolean;
+}
+export declare function finalizeWebviewCssCompat(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<FinalizeGenerateBundleOptions, 'debug' | 'onUpdate' | 'opts' | 'recordCssAssetResult'>): number;
+export declare function normalizeRootMiniProgramImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'cssMatcher'> & {
+    debug: GenerateBundleContext['debug'];
+    enabled: boolean;
+    onUpdate: GenerateBundleContext['opts']['onUpdate'];
+    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
+}): number;

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

@@ -1,70 +1,2 @@
-import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleBuildState, BundleSnapshot } from '../bundle-state';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { BundleMetrics } from './metrics';
-import type { GenerateBundleContext } from './types';
-interface FinalizeGenerateBundleOptions {
-    activeProcessCacheKeys: Set<string>;
-    activeProcessHashKeys: Set<string | number>;
-    activeViteCssCacheFiles: Set<string>;
-    bundle: Record<string, OutputAsset | OutputChunk>;
-    bundleFiles: string[];
-    cache: GenerateBundleContext['opts']['cache'];
-    cssTaskFactories: Array<() => Promise<void>>;
-    cssPipelineStrategy?: ViteFrameworkCssPipelineStrategy | undefined;
-    createCssPipelineContext?: ((file: string) => ViteFrameworkCssPipelineContext) | undefined;
-    debug: GenerateBundleContext['debug'];
-    defaultStyleOutputExtension: string;
-    formatIteration: number;
-    generatorCandidateSignature: string;
-    generatorRuntime: Set<string>;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
-    getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
-    getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
-    getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];
-    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
-    hmrTimingRecorder: GenerateBundleContext['hmrTimingRecorder'];
-    hmrTimingStartedAt: number;
-    isHarmonyAppStyleTarget: boolean;
-    isNativeAppStyleTarget: boolean;
-    isViteProcessedCssAsset: GenerateBundleContext['isViteProcessedCssAsset'];
-    isWebGeneratorTarget: boolean;
-    jsAfterCss: boolean;
-    jsTaskFactories: Array<() => Promise<void>>;
-    lastCssResultByFile: Map<string, string>;
-    lastCssSourceHashByFile: Map<string, string>;
-    linkedByEntry: Map<string, Set<string>> | undefined;
-    markCssAssetProcessed: GenerateBundleContext['markCssAssetProcessed'];
-    metrics: BundleMetrics;
-    onEnd: GenerateBundleContext['opts']['onEnd'];
-    onUpdate: GenerateBundleContext['opts']['onUpdate'];
-    opts: GenerateBundleContext['opts'];
-    outDir: string;
-    pendingLinkedUpdates: Array<() => void>;
-    pruneViteCssCaches: GenerateBundleContext['pruneViteCssCaches'];
-    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
-    recordTimingDetail: (name: string, startedAt: number) => void;
-    recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
-    rootDir: string;
-    runtime: Set<string>;
-    runtimeState: GenerateBundleContext['runtimeState'];
-    shouldPreserveAppCssExtension: boolean;
-    snapshot: BundleSnapshot;
-    sourceCandidates: Set<string>;
-    sourceRoot: string | undefined;
-    state: BundleBuildState;
-    styleHandler: GenerateBundleContext['opts']['styleHandler'];
-    tasks: Promise<void>[];
-    timingDetails: Record<string, number>;
-    transformRuntime: Set<string>;
-    transformWebTargetCss?: ((css: string, file: string) => string) | undefined;
-    useIncrementalMode: boolean;
-}
-export declare function normalizeRootMiniProgramImportShellAssets(bundle: Record<string, OutputAsset | OutputChunk>, options: Pick<GenerateBundleContext['opts'], 'cssMatcher'> & {
-    debug: GenerateBundleContext['debug'];
-    enabled: boolean;
-    onUpdate: GenerateBundleContext['opts']['onUpdate'];
-    recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
-}): number;
-export declare function finalizeGenerateBundle(options: FinalizeGenerateBundleOptions): Promise<void>;
-export {};
+export { finalizeGenerateBundle } from './finalize/bundle.js';
+export { normalizeRootMiniProgramImportShellAssets } from './finalize/root-import-shell.js';

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

@@ -1,6 +1,6 @@
 import type { OutputAsset } from 'rollup';
-import type { createEmptyMetrics } from './metrics';
-import { processCachedTask } from '../../shared/cache';
+import type { createEmptyMetrics } from './metrics.js';
+import { processCachedTask } from '../../shared/cache.js';
 export interface ProcessHtmlBundleEntryOptions {
     cache: Parameters<typeof processCachedTask<string>>[0]['cache'];
     context: {

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

@@ -1,2 +1,2 @@
-import type { OutputEntry } from '../bundle-entries';
+import type { OutputEntry } from '../bundle-entries.js';
 export declare function createJsEntryResolver(jsEntries: Map<string, OutputEntry>): (id: string) => OutputEntry | undefined;

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

@@ -1,5 +1,6 @@
-import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types';
+import type { CreateJsHandlerOptions, InternalUserDefinedOptions } from '../../../types/index.js';
 interface JsHandlerOptionsFactoryOptions {
+    getExperimentalJsFastPath?: () => CreateJsHandlerOptions['experimentalJsFastPath'];
     getMajorVersion: () => number | undefined;
     moduleGraph: CreateJsHandlerOptions['moduleGraph'];
 }

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

@@ -1,5 +1,5 @@
-import type { OutputEntry } from '../bundle-entries';
-import type { LinkedJsModuleResult } from '../../../types';
+import type { OutputEntry } from '../bundle-entries.js';
+import type { LinkedJsModuleResult } from '../../../types/index.js';
 interface LinkedUpdateHelpersOptions {
     jsEntries: Map<string, OutputEntry>;
     onUpdate: (fileName: string, previous: string, next: string) => void;

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

@@ -1,8 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
-import type { BundleMetrics } from './metrics';
-import type { GenerateBundleContext } from './types';
-import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types';
+import type { BundleSnapshot, BundleStateEntry } from '../bundle-state.js';
+import type { BundleMetrics } from './metrics.js';
+import type { GenerateBundleContext } from './types.js';
+import type { CreateJsHandlerOptions, LinkedJsModuleResult } from '../../../types/index.js';
 interface ProcessJsBundleEntryOptions {
     applyLinkedUpdates: (linked?: Record<string, LinkedJsModuleResult>) => void;
     bundle: Record<string, OutputAsset | OutputChunk>;
@@ -11,7 +11,8 @@ interface ProcessJsBundleEntryOptions {
     debug: GenerateBundleContext['debug'];
     disableJsPrecheck: boolean;
     entry: BundleStateEntry;
-    getJsEntry: ReturnType<typeof import('./js-entries').createJsEntryResolver>;
+    getJsEntry: ReturnType<typeof import('./js-entries.js').createJsEntryResolver>;
+    deferUniAppXStylePlaceholder?: boolean;
     jsHandler: GenerateBundleContext['opts']['jsHandler'];
     jsTaskFactories: Array<() => Promise<void>>;
     linkedByEntry: Map<string, Set<string>> | undefined;

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

@@ -1,4 +1,4 @@
-import type { GenerateBundleContext } from './types';
+import type { GenerateBundleContext } from './types.js';
 export declare function resolveViteMemoryDebugStats(context: {
     activeProcessCacheKeys: Set<string>;
     activeProcessHashKeys: Set<string | number>;

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

@@ -1,4 +1,4 @@
-import type { BundleSnapshot } from '../bundle-state';
+import type { BundleSnapshot } from '../bundle-state.js';
 interface LogBundleProcessPlanOptions {
     debug: (format: string, ...args: unknown[]) => void;
     snapshot: BundleSnapshot;

package/dist/bundlers/vite/generate-bundle/remembered-css-plan.d.ts

@@ -0,0 +1,35 @@
+import type { OutputAsset } from 'rollup';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
+export interface ResolveRememberedCssSourcePlanOptions {
+    configuredSourceFileKeys: ReadonlySet<string>;
+    currentRawSourceHasExplicitScanContext: boolean;
+    debug: (format: string, ...args: unknown[]) => void;
+    explicitConfiguredSourceFileKeys: ReadonlySet<string>;
+    file: string;
+    getRememberedCssSources: (() => Iterable<[string, RememberedCssSource]>) | undefined;
+    getSfcSource: ((file: string) => string | undefined) | undefined;
+    hasExplicitConfiguredRootSource: boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    originalSource: OutputAsset;
+    outputFile: string;
+    outputRoot: string;
+    rawSource: string;
+    resolveConfiguredRootSource: () => RememberedCssSource | undefined;
+    resolveMatchedOutputFile: (sourceFile: string) => string | undefined;
+    resolveTemporarySource: (outputFile: string, rawSource: string) => RememberedCssSource | undefined;
+    shouldKeepCurrentRootOutput: (sourceFile: string, outputFile: string) => boolean;
+    snapshot: BundleSnapshot;
+    sourceRoot: string | undefined;
+    temporaryOutput: boolean;
+    cssMatcher: ((file: string) => boolean) | undefined;
+}
+export interface RememberedCssSourcePlan {
+    forceNonMainChunk: boolean;
+    hasUsableTailwindSource: boolean;
+    outputFile: string;
+    resolvedFromTemporarySource: boolean;
+    sources: RememberedCssSource[];
+    usedConfiguredSourceFiles: string[];
+}
+export declare function resolveRememberedCssSourcePlan(options: ResolveRememberedCssSourcePlanOptions): Promise<RememberedCssSourcePlan>;

package/dist/bundlers/vite/generate-bundle/remembered-css-replay.d.ts

@@ -1,7 +1,7 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { BundleMetrics } from './metrics';
-import type { GenerateBundleContext, RememberedCssSource } from './types';
+import type { ViteFrameworkCssPipelineContext, ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { BundleMetrics } from './metrics.js';
+import type { GenerateBundleContext, RememberedCssSource } from './types.js';
 interface ProcessRememberedCssReplayOptions {
     addWatchFile: (id: string) => void;
     bundle: Record<string, OutputAsset | OutputChunk>;
@@ -25,8 +25,8 @@ interface ProcessRememberedCssReplayOptions {
     emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset | undefined;
     generatorRuntime: Set<string>;
     generatorPlatform?: string | undefined;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
-    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
     getRememberedCssSignature?: ((file: string) => string | undefined) | undefined;
     getRememberedCssSources?: (() => Iterable<[string, RememberedCssSource]>) | undefined;
     isNativeAppStyleTarget: boolean;
@@ -41,7 +41,6 @@ interface ProcessRememberedCssReplayOptions {
     opts: GenerateBundleContext['opts'];
     recordCssAssetResult: GenerateBundleContext['recordCssAssetResult'];
     recordViteProcessedCssAssetResult: GenerateBundleContext['recordViteProcessedCssAssetResult'];
-    refreshRememberedCssSource?: GenerateBundleContext['refreshRememberedCssSource'];
     rootDir: string;
     runtimeState: GenerateBundleContext['runtimeState'];
     setRememberedCssSignature?: ((file: string, cssRuntimeSignature: string) => void) | undefined;

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

@@ -1,6 +1,6 @@
 import type { OutputAsset } from 'rollup';
-import type { RememberedCssSource } from './types';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { RememberedCssSource } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export declare function createRememberedCssRuntimeSignature(cssRuntimeSignature: string, cssRuntimeAffectingHash: string): string;
 export declare function resolveRememberedCssSourceForTest(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource | undefined;
 export declare function findRememberedCssSources(sources: Iterable<[string, RememberedCssSource]> | undefined, outputFile: string, file: string, originalSource: OutputAsset, outputRoot: string, sourceRoot: string | undefined): RememberedCssSource[];

package/dist/bundlers/vite/generate-bundle/root-style-output.d.ts

@@ -12,6 +12,26 @@ export declare function shouldPreserveFrameworkRootMiniProgramImportShell(option
     matchesCss: boolean;
     shouldKeep: () => boolean | undefined;
 }): boolean;
+export interface ResolveFrameworkRootImportShellPlanOptions {
+    assetSourceFile: string;
+    configuredTargetFiles: Iterable<string | undefined>;
+    file: string;
+    isMainChunk: boolean;
+    isWebGeneratorTarget: boolean;
+    matchesCss: boolean;
+    processedTargetFiles: Iterable<string | undefined>;
+    rawSource: string;
+    rememberedTarget: string | undefined;
+    rootImportShellOutputFile: string;
+    shouldKeep: () => boolean | undefined;
+    shouldMoveToOrigin: () => boolean | undefined;
+}
+export interface FrameworkRootImportShellPlan {
+    isCurrentImportShell: boolean;
+    reusableTarget: string | undefined;
+    targetToRemember: string | undefined;
+}
+export declare function resolveFrameworkRootImportShellPlan(options: ResolveFrameworkRootImportShellPlanOptions): FrameworkRootImportShellPlan;
 export declare function restoreFrameworkRootMiniProgramImportShellAssets(bundle: OutputBundle, options: {
     debug?: ((format: string, ...args: unknown[]) => void) | undefined;
     isWebGeneratorTarget: boolean;

package/dist/bundlers/vite/generate-bundle/runtime-configured-css.d.ts

@@ -0,0 +1,54 @@
+import type { OutputBundle } from 'rollup';
+import type { ViteFrameworkCssPipelineContext } from '../shared/framework-strategy.js';
+import type { ConfiguredCssSourceEntry } from './configured-css-sources.js';
+import type { GenerateBundleContext } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export interface CreateConfiguredCssSourceRegistryOptions {
+    bundleFiles: string[];
+    defaultStyleOutputExtension: string;
+    getCssSource: (file: string) => string | undefined;
+    isWebGeneratorTarget: boolean;
+    opts: InternalUserDefinedOptions;
+    outDir: string;
+    rootDir: string;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    sourceRoot?: string | undefined;
+}
+export declare function createConfiguredCssSourceRegistry(options: CreateConfiguredCssSourceRegistryOptions): {
+    explicitCssEntryFiles: string[];
+    getSourceEntries: () => ConfiguredCssSourceEntry[];
+    normalizeGeneratorUserRawSource: (source: string, sourceFile: string, fallbackFile?: string | undefined) => string;
+    resolveMatchedSourceOutputFile: (sourceFile: string) => string | undefined;
+};
+export interface CreateConfiguredCssRootResolversOptions {
+    bundle: OutputBundle;
+    bundleFiles: string[];
+    cssPipelineContext: ViteFrameworkCssPipelineContext;
+    cssPipelineStrategy: GenerateBundleContext['cssPipelineStrategy'];
+    currentSubpackageRoots?: Set<string> | undefined;
+    defaultStyleOutputExtension: string;
+    entries: ConfiguredCssSourceEntry[];
+    explicitCssEntryFiles: string[];
+    isWebGeneratorTarget: boolean;
+    opts: InternalUserDefinedOptions;
+    rootDir: string;
+    shouldPreserveAppCssExtension: boolean;
+    sourceRoot?: string | undefined;
+}
+export declare function createConfiguredCssRootResolvers(options: CreateConfiguredCssRootResolversOptions): {
+    configuredTailwindV4ExplicitCssEntryFileKeysForScope: Set<string>;
+    configuredTailwindV4CssSourceFileKeysForScope: Set<string>;
+    hasExplicitConfiguredRootCssEntryForOutput: (outputFile: string) => boolean;
+    isMiniProgramStyleOutputFile: (file: string) => boolean;
+    normalizeConfiguredTailwindV4CssEntryFileKey: (file: string) => string;
+    resolveConfiguredCssEntryRootInjectionTarget: (sourceFile: string | undefined, outputFile: string) => string | undefined;
+    resolveConfiguredRootCssSourceStyle: (outputFile: string, entries: ConfiguredCssSourceEntry[], originalFileNames?: string[] | undefined) => {
+        outputFile: string;
+        rawSource: string;
+        sourceFile: string;
+    } | undefined;
+    selectConfiguredRootCssSourceEntry: (outputFile: string, entries: ConfiguredCssSourceEntry[], originalFileNames?: string[] | undefined) => ConfiguredCssSourceEntry | undefined;
+    shouldKeepCurrentRootCssOutputForConfiguredSource: (sourceFile: string | undefined, outputFile: string) => boolean;
+    shouldKeepCurrentRootMiniProgramStyleOutputAsImportShell: (outputFile: string, css?: string | undefined) => boolean;
+    shouldSelectConfiguredRootCssOutput: (outputFile: string) => boolean;
+};

package/dist/bundlers/vite/generate-bundle/runtime-linked-css.d.ts

@@ -1,4 +1,4 @@
-import type { BundleSnapshot } from '../bundle-state';
+import type { BundleSnapshot } from '../bundle-state.js';
 export declare function collectCssExtensionByStem(files: string[], cssMatcher: (file: string) => boolean): Map<string, string>;
 export declare function collectRuntimeLinkedCssFiles(snapshot: BundleSnapshot, extensionByStem: Map<string, string>, fallbackExtension: string): Set<string>;
 export declare function collectJsImportedCssFiles(snapshot: BundleSnapshot): Set<string>;

package/dist/bundlers/vite/generate-bundle/runtime-linked-source-memory.d.ts

@@ -1,6 +1,6 @@
-import type { BundleSnapshot } from '../bundle-state';
-import type { RememberedCssSource } from './types';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export interface RememberRuntimeLinkedCssSourcesOptions {
     bundleFiles: string[];
     defaultStyleOutputExtension: string;

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

@@ -0,0 +1,6 @@
+import { normalizeBundleFileNameKeysForTest } from './bundle-file-names.js';
+import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from './css-output.js';
+import { resolveRememberedCssSourceForTest } from './remembered-css.js';
+import { shouldKeepRootMiniProgramStyleAsImportShell as shouldKeepRootMiniProgramStyleAsImportShell2, shouldMoveRootMiniProgramStyleToImportShellOrigin as shouldMoveRootMiniProgramStyleToImportShellOrigin2 } from './root-style-output.js';
+declare function createGenerateBundleHook(context: any): any;
+export { createGenerateBundleHook, normalizeBundleFileNameKeysForTest, resolveMiniProgramStyleOutputExtension2 as resolveMiniProgramStyleOutputExtension, resolveRememberedCssSourceForTest, resolveReplayCssOutputFile2 as resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile2 as resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile, shouldKeepRootMiniProgramStyleAsImportShell2 as shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin2 as shouldMoveRootMiniProgramStyleToImportShellOrigin };

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

@@ -1,5 +1,5 @@
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 export declare function createScopedGeneratorCandidateSignature(rawSource: string, sourceFile: string, fallbackSignature: string, getSourceCandidatesForEntries: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined, options?: {
     includeFallbackSignature?: boolean | undefined;
     majorVersion?: number | undefined;

package/dist/bundlers/vite/generate-bundle/sfc-style-source.d.ts

@@ -1,6 +1,6 @@
 import type { OutputChunk } from 'rollup';
-import type { BundleSnapshot } from '../bundle-state';
-import type { RememberedCssSource } from './types';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { RememberedCssSource } from './types.js';
 export declare function isSfcStyleSourceFile(file: string): boolean;
 export interface SfcStyleBlock {
     attrs: string;

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

@@ -1,8 +1 @@
-import type { EntryType } from '../bundle-state';
-export declare function summarizeStringDiff(previous: string, next: string): string;
-export declare function createLinkedImpactSignature(entry: string, linkedImpactsByEntry: Map<string, Set<string>>, sourceHashByFile: Map<string, string>): string | undefined;
-export declare function createJsHashSalt(runtimeSignature: string, linkedImpactSignature?: string): string;
-export declare function createStableTextSignature(input: string): string;
-export declare function createCandidateSignature(candidates: Set<string>): string;
-export declare function getSnapshotHash(snapshotMap: Map<string, string>, file: string, fallback: string): string;
-export declare function hasRuntimeAffectingSourceChanges(changedByType: Record<EntryType, Set<string>>): boolean;
+export { createCandidateSignature, createJsHashSalt, createLinkedImpactSignature, createStableTextSignature, getSnapshotHash, hasRuntimeAffectingSourceChanges, summarizeStringDiff, } from '../../shared/runtime-signatures.js';

package/dist/bundlers/vite/generate-bundle/source-candidate-scope.d.ts

@@ -1,6 +1,6 @@
-import type { BundleSnapshot } from '../bundle-state';
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 interface CreateSubpackageSourceCandidateScopeOptions {
     cssSourceFiles?: Iterable<string> | undefined;
     getSourceCandidatesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Set<string>) | undefined;

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

@@ -6,5 +6,10 @@ export interface ResolveCurrentSourceCandidateSourceOptions {
     rootDir: string;
     sourceRoot?: string | undefined;
 }
+export interface CurrentSourceCandidateFileMatch {
+    confidence: 'exact' | 'suffix';
+    file: string;
+}
+export declare function resolveCurrentSourceCandidateFileMatch(options: ResolveCurrentSourceCandidateSourceOptions): CurrentSourceCandidateFileMatch | undefined;
 export declare function resolveCurrentSourceCandidateFile(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;
 export declare function resolveCurrentSourceCandidateSource(options: ResolveCurrentSourceCandidateSourceOptions): string | undefined;

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

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { BundleSnapshot } from '../bundle-state';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
 export declare function normalizePackageRoot(root: string): string;
 export declare function collectMiniProgramSubpackageRoots(bundle: Record<string, OutputAsset | OutputChunk>): Set<string> | undefined;
 export declare function isSubpackageOutputFile(file: string, subpackageRoots: Set<string>): boolean;

package/dist/bundlers/vite/generate-bundle/temporary-css-assets.d.ts

@@ -1,9 +1,22 @@
-import type { RememberedCssSource } from './types';
+import type { RememberedCssSource } from './types.js';
 export interface TemporaryCssSourceEntry {
     file: string;
     outputFile: string;
     source: string;
 }
+export interface CollectTemporaryCssSourceEntriesOptions {
+    configuredEntries: TemporaryCssSourceEntry[];
+    configuredScopeEntries: TemporaryCssSourceEntry[];
+    currentSubpackageRoots: string[] | undefined;
+    explicitSourceFileKeys: ReadonlySet<string>;
+    isSubpackageOutputFile: (file: string, roots: string[]) => boolean;
+    normalizeConfiguredSourceFile: (file: string) => string;
+    rememberedEntries: TemporaryCssSourceEntry[];
+    resolveRuntimeLinkedSource: (file: string) => TemporaryCssSourceEntry | undefined;
+    runtimeLinkedCssFiles: Iterable<string>;
+    shouldSelectConfiguredRootOutput: (outputFile: string) => boolean;
+}
+export declare function collectTemporaryCssSourceEntries(options: CollectTemporaryCssSourceEntriesOptions): TemporaryCssSourceEntry[];
 export declare function isTemporaryCssAssetFile(file: string): boolean;
 export declare function createTemporaryCssAssetSourceResolver(entries: TemporaryCssSourceEntry[]): {
     entries: TemporaryCssSourceEntry[];

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

@@ -1,5 +1,5 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 type TransformMatcher = (id: string) => boolean;
 interface TransformFilter {
     include?: TransformMatcher | undefined;

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

@@ -0,0 +1 @@
+export declare function scheduleViteCssTransform(options: any): void;

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

@@ -1,11 +1,12 @@
 import type { OutputAsset } from 'rollup';
 import type { ResolvedConfig } from 'vite';
-import type { HmrTimingRecorder } from '../../shared/hmr-timing';
-import type { BundleSnapshot } from '../bundle-state';
-import type { ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy';
-import type { SourceCandidateFilterOptions } from '../source-candidates';
-import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan';
-import type { InternalUserDefinedOptions } from '../../../types';
+import type { HmrTimingRecorder } from '../../shared/hmr-timing.js';
+import type { BundleSnapshot } from '../bundle-state.js';
+import type { ViteCssAssetIdentity } from '../css-asset-identity.js';
+import type { ViteFrameworkCssPipelineStrategy } from '../shared/framework-strategy.js';
+import type { SourceCandidateFilterOptions } from '../source-candidates.js';
+import type { TailwindSourceEntry } from '../../../tailwindcss/source-scan.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
 export interface GenerateBundleContext {
     processMarkupAndScripts?: boolean | undefined;
     processStyles?: boolean | undefined;
@@ -28,6 +29,7 @@ export interface GenerateBundleContext {
     markCssAssetProcessed?: (asset: OutputAsset, file?: string) => void;
     isCssAssetProcessed?: (asset: OutputAsset, file?: string) => boolean;
     isViteProcessedCssAsset?: (asset: OutputAsset, file?: string) => boolean;
+    resolveCssAssetIdentity?: (asset: OutputAsset, file?: string) => ViteCssAssetIdentity;
     recordCssAssetResult?: (file: string, css: string) => void;
     recordViteProcessedCssAssetResult?: (file: string, css: string, options?: {
         injectIntoMain?: boolean | undefined;
@@ -51,7 +53,6 @@ export interface GenerateBundleContext {
     getSourceCandidateSourcesForEntries?: ((entries: TailwindSourceEntry[] | undefined, options?: SourceCandidateFilterOptions) => Map<string, Set<string>>) | undefined;
     waitForSourceCandidateSyncs?: () => Promise<void>;
     rememberCssSource?: (entry: RememberedCssSource, cssRuntimeSignature?: string) => void;
-    refreshRememberedCssSource?: (entry: RememberedCssSource) => Promise<RememberedCssSource | undefined> | RememberedCssSource | undefined;
     getRememberedCssSources?: () => Iterable<[string, RememberedCssSource]>;
     getRememberedCssSignature?: (file: string) => string | undefined;
     setRememberedCssSignature?: (file: string, cssRuntimeSignature: string) => void;

package/dist/bundlers/vite/generate-bundle/uni-app-x-postprocess.d.ts

@@ -1,6 +1,6 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { CssHandlerOptionsCache } from './css-handler-options';
-import type { GenerateBundleContext } from './types';
+import type { CssHandlerOptionsCache } from './css-handler-options.js';
+import type { GenerateBundleContext } from './types.js';
 interface HandleUniAppXPostCssOptions {
     bundle: Record<string, OutputAsset | OutputChunk>;
     debug: GenerateBundleContext['debug'];
@@ -15,6 +15,7 @@ interface HandleUniAppXPostCssOptions {
     opts: GenerateBundleContext['opts'];
     runtimeState: GenerateBundleContext['runtimeState'];
     styleHandler: GenerateBundleContext['opts']['styleHandler'];
+    deferStylePlaceholderInjection?: boolean;
 }
 export declare function handleUniAppXPostCssTasks(options: HandleUniAppXPostCssOptions): Promise<string[]>;
 export {};

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

@@ -0,0 +1,22 @@
+import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
+import type { OutputAsset } from 'rollup';
+import type { GenerateBundleContext } from './types.js';
+import type { InternalUserDefinedOptions } from '../../../types/index.js';
+export interface ValidateRuntimeCandidatesOptions {
+    cssEntries: Array<{
+        file: string;
+        output: OutputAsset;
+    }>;
+    debug: GenerateBundleContext['debug'];
+    getCssHandlerOptions: (file: string) => IStyleHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => IStyleHandlerOptions;
+    getViteProcessedCssAssetResults: GenerateBundleContext['getViteProcessedCssAssetResults'];
+    hasMultipleConfiguredCssEntries: boolean;
+    normalizeMiniProgramGeneratorRawSource: (source: string, outputFile: string) => string;
+    opts: InternalUserDefinedOptions;
+    runtimeState: GenerateBundleContext['runtimeState'];
+    sourceCandidates: Set<string>;
+    styleHandler: InternalUserDefinedOptions['styleHandler'];
+    transformRuntime: Set<string>;
+}
+export declare function validateRuntimeCandidates(options: ValidateRuntimeCandidatesOptions): Promise<void>;

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

@@ -1,8 +1,8 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types';
-export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names';
-export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output';
-export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css';
-export { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output';
-export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types';
-export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, _opt: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;
+import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types.js';
+export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names.js';
+export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output.js';
+export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css.js';
+export { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output.js';
+export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types.js';
+export declare function createGenerateBundleHook(context: GenerateBundleContext): (this: GenerateBundleThis, options: unknown, bundle: Record<string, OutputAsset | OutputChunk>) => Promise<void>;

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

@@ -1,4 +1 @@
-import type { BundleSnapshot, BundleStateEntry } from '../bundle-state';
-export declare function createRuntimeEntries(snapshot: BundleSnapshot): BundleStateEntry[];
-export declare function collectChangedRuntimeFiles(snapshot: BundleSnapshot): Set<string>;
-export declare function resolveEntryExtension(entry: BundleStateEntry): string;
+export { collectChangedRuntimeFiles, createRuntimeEntries, resolveEntryExtension, } from '../../shared/runtime-class-set/entries.js';

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

@@ -1,3 +1 @@
-export declare function createEscapeFragments(escapeMap: Record<string, string>): string[];
-export declare function collectEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;
-export declare function collectStrictEscapedRuntimeCandidates(source: string, escapeMap: Record<string, string>, escapeFragments: string[]): Set<string>;
+export { collectEscapedRuntimeCandidates, collectStrictEscapedRuntimeCandidates, createEscapeFragments, } from '../../shared/runtime-class-set/escaped-candidates.js';