weapp-tailwindcss 5.1.16 → 5.2.1

package/dist/compiler/compilation-dependency-state.d.ts

@@ -0,0 +1,16 @@
+import type { CompilationDependencyChange } from './compilation-scope-graph.js';
+import type { CompilationResult, SourceScope } from './types.js';
+export interface CompilationDependencyScopeEntry {
+    latest?: Pick<CompilationResult, 'graphNodes'> | undefined;
+    scope: SourceScope;
+}
+export declare class CompilationDependencyState {
+    private readonly revisions;
+    getAffectedScopes(entries: Iterable<CompilationDependencyScopeEntry>, changes: Iterable<CompilationDependencyChange>): Set<string>;
+    getAffectedScopeChanges(entries: Iterable<CompilationDependencyScopeEntry>, changes: Iterable<CompilationDependencyChange>): Map<string, CompilationDependencyChange[]>;
+    record(entries: Iterable<CompilationDependencyScopeEntry>, changes: Iterable<CompilationDependencyChange>): Set<string>;
+    recordScopes(scopeIds: Iterable<string>): void;
+    getRevision(scopeId: string): number;
+    delete(scopeId: string): void;
+    clear(): void;
+}

package/dist/compiler/compilation-scope-graph.d.ts

@@ -0,0 +1,31 @@
+import type { CompilationChange, CompilationGraphSnapshot, CompilationSnapshot, SourceKind, SourceScope } from './types.js';
+export interface CompilationScopeDependency {
+    id: string;
+    kind: SourceKind;
+}
+export interface CompilationDependencyChange {
+    id: string;
+    type: 'dependency-changed' | 'config-changed';
+}
+export interface CompilationScopeGraphSource {
+    id: string;
+    kind: SourceKind;
+    content?: string | undefined;
+    dependencies?: CompilationScopeDependency[] | undefined;
+}
+export interface CompilationScopeSnapshotSource extends CompilationScopeGraphSource {
+    candidates: Iterable<string>;
+}
+export interface CreateCompilationScopeSnapshotOptions {
+    changes?: CompilationChange[] | undefined;
+    preserveDeletedCss?: boolean | undefined;
+    validatedClassSet?: Iterable<string> | undefined;
+}
+export declare function sourceNodeId(sourceId: string): string;
+export declare function dependencyNodeId(dependencyId: string): string;
+export declare function createCompilationDependencyChanges(dependencyIds: Iterable<string>, type?: CompilationDependencyChange['type']): CompilationDependencyChange[];
+export declare function mergeCompilationDependencyChanges(...groups: Array<Iterable<CompilationDependencyChange> | undefined>): CompilationDependencyChange[];
+export declare function mergeCompilationScopeDependencies(...groups: Array<Iterable<CompilationScopeDependency> | undefined>): CompilationScopeDependency[];
+export declare function dependencySignature(source: CompilationScopeGraphSource): string;
+export declare function createCompilationScopeGraph(scope: SourceScope, outputId: string, sources: Iterable<CompilationScopeGraphSource>): CompilationGraphSnapshot;
+export declare function createCompilationScopeSnapshot(scope: SourceScope, outputId: string, sources: Iterable<CompilationScopeSnapshotSource>, options?: CreateCompilationScopeSnapshotOptions): CompilationSnapshot;

package/dist/compiler/compilation-session-pool.d.ts

@@ -0,0 +1,54 @@
+import type { CompilationDependencyChange, CompilationScopeDependency, CompilationScopeGraphSource } from './compilation-scope-graph.js';
+import type { CompilationResult, SourceKind, SourceScope } from './types.js';
+export interface CompilationScopeSource extends CompilationScopeGraphSource {
+    id: string;
+    kind: SourceKind;
+    candidates: Iterable<string>;
+}
+export interface CompilationScopeGenerationResult {
+    classSet: Iterable<string>;
+    dependenciesBySource?: Iterable<readonly [string, Iterable<CompilationScopeDependency>]> | undefined;
+}
+export interface CompilationScopeRequest {
+    scope: SourceScope;
+    outputId: string;
+    sources: CompilationScopeSource[];
+    changes?: CompilationDependencyChange[] | undefined;
+    preserveDeletedCss?: boolean | undefined;
+}
+export interface CompilationScopeState extends Omit<CompilationResult, 'candidatesBySource'> {
+    candidatesBySource: Map<string, Set<string>>;
+}
+export type CompilationScopeExecution<T> = {
+    committed: true;
+    compilation: CompilationScopeState;
+    value: T;
+} | {
+    committed: false;
+    compilation: CompilationScopeState;
+    value?: never;
+};
+export declare class CompilationSessionPool {
+    private readonly dependencyState;
+    private readonly entries;
+    private disposed;
+    run<T extends CompilationScopeGenerationResult | undefined>(request: CompilationScopeRequest, compile: (compilation: CompilationScopeState) => Promise<T>): Promise<CompilationScopeExecution<T>>;
+    invalidateScope(scopeId: string): void;
+    dispose(): Promise<void>;
+    get size(): number;
+    getAffectedScopes(changes: Iterable<CompilationDependencyChange>): Set<string>;
+    getAffectedScopeChanges(changes: Iterable<CompilationDependencyChange>): Map<string, CompilationDependencyChange[]>;
+    recordDependencyChanges(changes: Iterable<CompilationDependencyChange>): Set<string>;
+    recordAffectedScopes(scopeIds: Iterable<string>): void;
+    getScopeDependencyRevision(scopeId: string): number;
+    private getEntry;
+    private disposeEntry;
+    private runEntry;
+    private prepareEntry;
+    private createGraphSources;
+    private normalizeGeneratedDependencies;
+    private enqueue;
+    private toScopeState;
+}
+export declare function getCompilationSessionPool(owner: object): CompilationSessionPool;
+export declare function disposeCompilationSessionPool(owner: object): Promise<void>;

package/dist/compiler/compiler-owner-state.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureCompilerOwnerActive(owner: object): void;
+export declare function runCompilerOwnerActivity<T>(owner: object, activity: () => T | Promise<T>): Promise<Awaited<T>>;
+export declare function runCompilerOwnerDisposal(owner: object, dispose: () => Promise<void>): Promise<void>;

package/dist/compiler/composition.d.ts

@@ -0,0 +1,8 @@
+import type { CssFragment, GenerationArtifact } from './types.js';
+import { postcss } from '@weapp-tailwindcss/postcss';
+export declare function orderCssFragments(fragments: Iterable<CssFragment>): CssFragment[];
+export declare function composeGenerationArtifact(artifact: GenerationArtifact): {
+    artifact: GenerationArtifact;
+    root: postcss.Root;
+    css: string;
+};

package/dist/compiler/emission-plan.d.ts

@@ -0,0 +1,26 @@
+import type { GenerationArtifact } from './types.js';
+export interface AssetEmission {
+    assetId: string;
+    artifact: GenerationArtifact;
+}
+export interface AssetWriteOperation<Source = string> {
+    assetId: string;
+    kind: 'write';
+    source: Source;
+}
+export interface AssetDeleteOperation {
+    assetId: string;
+    kind: 'delete';
+}
+export type AssetEmissionOperation<Source = string> = AssetWriteOperation<Source> | AssetDeleteOperation;
+export declare class AssetEmissionPlan<Source = string> {
+    private readonly emissions;
+    private readonly assetOperations;
+    upsert(assetId: string, artifact: GenerationArtifact): void;
+    get(assetId: string): GenerationArtifact | undefined;
+    entries(): AssetEmission[];
+    write(assetId: string, source: Source): void;
+    remove(assetId: string): void;
+    operations(): AssetEmissionOperation<Source>[];
+    clear(): void;
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,23 @@
+export * from './artifact.js';
+export * from './candidate-index.js';
+export * from './compilation-change-coordinator.js';
+export * from './compilation-scope-graph.js';
+export * from './compilation-session-pool.js';
+export * from './composition.js';
+export * from './emission-plan.js';
+export * from './invalidation.js';
+export * from './mode.js';
+export * from './owner-lifecycle.js';
+export * from './platform-adapter.js';
+export * from './runtime-affecting-signature.js';
+export * from './runtime-build-state.js';
+export * from './runtime-snapshot.js';
+export * from './scope-planner.js';
+export * from './semantic-css.js';
+export * from './session.js';
+export * from './shadow-gate.js';
+export * from './shadow-report.js';
+export * from './shadow-report-session.js';
+export * from './source-graph.js';
+export * from './tailwind-generation-session-pool.js';
+export type * from './types.js';

package/dist/compiler/invalidation.d.ts

@@ -0,0 +1,3 @@
+import type { SourceGraph } from './source-graph.js';
+import type { CompilationChange } from './types.js';
+export declare function resolveInvalidatedScopes(graph: SourceGraph, changes: Iterable<CompilationChange>): Set<string>;

package/dist/compiler/mode.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerMode } from './types.js';
+export declare const COMPILER_MODE_ENV = "WEAPP_TAILWINDCSS_COMPILER";
+export declare function resolveCompilerMode(env?: NodeJS.ProcessEnv): CompilerMode;

package/dist/compiler/owner-lifecycle.d.ts

@@ -0,0 +1 @@
+export declare function disposeCompilerOwner(owner: object): Promise<void>;

package/dist/compiler/platform-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { IStyleHandlerOptions, StyleHandler } from '@weapp-tailwindcss/postcss/types';
+import type { PlatformAdapter } from './types.js';
+export interface CreateStylePlatformAdapterOptions {
+    id: PlatformAdapter['id'];
+    styleHandler: StyleHandler;
+    styleOptions?: Partial<IStyleHandlerOptions> | undefined;
+}
+export declare function createPassthroughPlatformAdapter(id: PlatformAdapter['id']): PlatformAdapter;
+export declare function createStylePlatformAdapter(options: CreateStylePlatformAdapterOptions): PlatformAdapter;

package/dist/compiler/runtime-affecting-signature.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeEntryType } from './runtime-snapshot.js';
+export declare function createRuntimeAffectingSourceSignature(source: string, type: RuntimeEntryType): string;

package/dist/compiler/runtime-build-state.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeCompilationBuildState, RuntimeCompilationSnapshot, UpdateRuntimeCompilationBuildStateOptions } from './runtime-snapshot.js';
+export declare function createRuntimeCompilationBuildState(): RuntimeCompilationBuildState;
+export declare function updateRuntimeCompilationBuildState(state: RuntimeCompilationBuildState, snapshot: RuntimeCompilationSnapshot, linkedByEntry: Map<string, Set<string>>, options?: UpdateRuntimeCompilationBuildStateOptions): void;
+export declare function removeRuntimeCompilationBuildStateFiles(state: RuntimeCompilationBuildState, files: Iterable<string>): void;
+export declare function resetRuntimeCompilationBuildState(state: RuntimeCompilationBuildState): void;
+export declare function createRuntimeCompilationAffectingSignature(snapshot: RuntimeCompilationSnapshot, computeHash: (source: string) => string): string;

package/dist/compiler/runtime-snapshot.d.ts

@@ -0,0 +1,53 @@
+export type RuntimeEntryType = 'html' | 'js' | 'css' | 'other';
+export interface RuntimeSnapshotEntry {
+    file: string;
+    source: string;
+    type: RuntimeEntryType;
+    runtimeCandidate?: boolean | undefined;
+}
+export interface RuntimeProcessFileSets {
+    html: Set<string>;
+    js: Set<string>;
+    css: Set<string>;
+}
+export interface RuntimeCompilationSnapshot<Entry extends RuntimeSnapshotEntry = RuntimeSnapshotEntry> {
+    entries: Entry[];
+    sourceHashByFile: Map<string, string>;
+    runtimeAffectingSignatureByFile: Map<string, string>;
+    runtimeAffectingHashByFile: Map<string, string>;
+    hasOmittedKnownFiles: boolean;
+    removedFiles: Set<string>;
+    changedByType: Record<RuntimeEntryType, Set<string>>;
+    runtimeAffectingChangedByType: Record<RuntimeEntryType, Set<string>>;
+    processFiles: RuntimeProcessFileSets;
+    linkedImpactsByEntry: Map<string, Set<string>>;
+}
+export interface RuntimeCompilationBuildState {
+    iteration: number;
+    sourceHashByFile: Map<string, string>;
+    runtimeAffectingSignatureByFile: Map<string, string>;
+    runtimeAffectingHashByFile: Map<string, string>;
+    linkedByEntry: Map<string, Set<string>>;
+    dependentsByLinkedFile: Map<string, Set<string>>;
+    bundleMarkupCandidatesByFile: Map<string, Set<string>>;
+    generatorCandidateSignature?: string | undefined;
+}
+export interface CreateRuntimeCompilationSnapshotOptions {
+    changedFiles?: Iterable<string> | undefined;
+    runtimeAffectingChangedFiles?: Iterable<string> | undefined;
+    processFiles?: Iterable<string> | undefined;
+    hasOmittedKnownFiles?: boolean | undefined;
+    removedFiles?: Iterable<string> | undefined;
+}
+export interface BuildRuntimeCompilationSnapshotOptions {
+    computeHash: (source: string) => string;
+    createRuntimeAffectingSignature: (source: string, type: RuntimeEntryType) => string;
+    forceAll?: boolean | undefined;
+    hasOmittedKnownFiles?: boolean | undefined;
+    removedFiles?: Iterable<string> | undefined;
+}
+export interface UpdateRuntimeCompilationBuildStateOptions {
+    incremental?: boolean | undefined;
+}
+export declare function createRuntimeCompilationSnapshot<Entry extends RuntimeSnapshotEntry>(entries: Entry[], options?: CreateRuntimeCompilationSnapshotOptions): RuntimeCompilationSnapshot<Entry>;
+export declare function buildRuntimeCompilationSnapshot<Entry extends RuntimeSnapshotEntry>(entries: Entry[], state: RuntimeCompilationBuildState, options: BuildRuntimeCompilationSnapshotOptions): RuntimeCompilationSnapshot<Entry>;

package/dist/compiler/scope-planner.d.ts

@@ -0,0 +1,6 @@
+import type { SourceGraphNode, SourceScope } from './types.js';
+export interface SourceScopePlan {
+    scope: SourceScope;
+    nodes: SourceGraphNode[];
+}
+export declare function planSourceScopes(nodes: Iterable<SourceGraphNode>): SourceScopePlan[];

package/dist/compiler/semantic-css.d.ts

@@ -0,0 +1,66 @@
+import type { Root } from 'postcss';
+import type { GenerationArtifact } from './types.js';
+export interface SemanticCssDeclaration {
+    type: 'declaration';
+    property: string;
+    value: string;
+    important: boolean;
+}
+export interface SemanticCssRule {
+    type: 'rule';
+    selector: string;
+    nodes: SemanticCssNode[];
+}
+export interface SemanticCssAtRule {
+    type: 'at-rule';
+    name: string;
+    params: string;
+    nodes: SemanticCssNode[];
+}
+export type SemanticCssNode = SemanticCssDeclaration | SemanticCssRule | SemanticCssAtRule;
+export interface ArtifactSemanticFragment {
+    id: string;
+    kind: GenerationArtifact['fragments'][number]['kind'];
+    order: number;
+    scope: GenerationArtifact['fragments'][number]['scope'];
+    sourceId: string;
+    stage: GenerationArtifact['fragments'][number]['stage'];
+    root: SemanticCssNode[];
+}
+export interface ArtifactSemanticSnapshot {
+    present: boolean;
+    fragments: ArtifactSemanticFragment[];
+    classSet: string[];
+    rawCandidates: string[];
+    dependencies: string[];
+    sourceEntries: string[];
+}
+export interface ArtifactSemanticDifference {
+    kind: 'added' | 'removed' | 'changed';
+    path: string;
+    left?: unknown;
+    right?: unknown;
+}
+export interface ArtifactSemanticSummary {
+    present: boolean;
+    fragments: number;
+    classes: number;
+    rawCandidates: number;
+    dependencies: number;
+    sourceEntries: number;
+}
+export interface ArtifactSemanticComparison {
+    equal: boolean;
+    differences: ArtifactSemanticDifference[];
+    truncated: boolean;
+    left: ArtifactSemanticSummary;
+    right: ArtifactSemanticSummary;
+}
+export interface CompareArtifactSemanticsOptions {
+    maxDifferences?: number | undefined;
+}
+export declare function normalizeCssRoot(root: Root): SemanticCssNode[];
+export declare function createArtifactSemanticSnapshot(artifact: GenerationArtifact | undefined): ArtifactSemanticSnapshot;
+export declare function createArtifactSemanticSignature(artifact: GenerationArtifact): string;
+export declare function compareArtifactSemantics(left: GenerationArtifact | undefined, right: GenerationArtifact | undefined, options?: CompareArtifactSemanticsOptions): ArtifactSemanticComparison;
+export declare function areArtifactsSemanticallyEqual(left: GenerationArtifact, right: GenerationArtifact): boolean;

package/dist/compiler/session.d.ts

@@ -0,0 +1,13 @@
+import type { CompilationGraphSnapshot, CompilationResult, CompilationSession, CompilationSnapshot } from './types.js';
+export declare class DefaultCompilationSession implements CompilationSession {
+    private readonly candidateIndex;
+    private readonly graph;
+    private readonly retainedCandidates;
+    private validatedClassSet;
+    private invalidatedScopes;
+    private revision;
+    update(snapshot: CompilationSnapshot): CompilationResult;
+    commitValidation(revision: number, validatedClassSet: Iterable<string>, graph?: CompilationGraphSnapshot): CompilationResult;
+    private createResult;
+    dispose(): void;
+}

package/dist/compiler/shadow-gate.d.ts

@@ -0,0 +1,26 @@
+import type { CompilerShadowRunSnapshot } from './shadow-report-session.js';
+export declare const COMPILER_SHADOW_GATE_ENV = "WEAPP_TAILWINDCSS_COMPILER_SHADOW_GATE";
+export type CompilerShadowGateMode = 'off' | 'report' | 'error';
+export type CompilerShadowGateIssue = 'semantic-mismatch' | 'truncated-report' | 'dropped-report';
+export interface CompilerShadowGateResult {
+    mode: CompilerShadowGateMode;
+    passed: boolean;
+    issues: CompilerShadowGateIssue[];
+    snapshot: CompilerShadowRunSnapshot;
+}
+export interface CompilerShadowGatePayload {
+    mode: CompilerShadowGateMode;
+    passed: boolean;
+    issues: CompilerShadowGateIssue[];
+    revision: number;
+    summary: CompilerShadowRunSnapshot['summary'];
+}
+export interface FinalizeCompilerShadowRunOptions {
+    emit?: ((payload: CompilerShadowGatePayload) => void) | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    revision?: number | undefined;
+}
+export declare function resolveCompilerShadowGateMode(env?: NodeJS.ProcessEnv): CompilerShadowGateMode;
+export declare function evaluateCompilerShadowGate(snapshot: CompilerShadowRunSnapshot, mode?: CompilerShadowGateMode): CompilerShadowGateResult;
+export declare function emitCompilerShadowGateResult(payload: CompilerShadowGatePayload): void;
+export declare function finalizeCompilerShadowRun(owner: object, options?: FinalizeCompilerShadowRunOptions): CompilerShadowGateResult | undefined;

package/dist/compiler/shadow-report-session.d.ts

@@ -0,0 +1,37 @@
+import type { CompilerShadowReport } from './shadow-report.js';
+export interface CompilerShadowRunSummary {
+    total: number;
+    matched: number;
+    mismatched: number;
+    truncated: number;
+    dropped: number;
+}
+export interface CompilerShadowRunSnapshot {
+    revision: number;
+    completed: boolean;
+    reports: CompilerShadowReport[];
+    summary: CompilerShadowRunSummary;
+}
+export declare class CompilerShadowReportSession {
+    private readonly maxReports;
+    private readonly reportsByScope;
+    private revision;
+    private dropped;
+    private completed;
+    private disposed;
+    constructor(maxReports?: number);
+    beginRun(): number;
+    record(report: CompilerShadowReport, revision?: number): boolean;
+    getRevision(): number;
+    completeRun(revision?: number): CompilerShadowRunSnapshot | undefined;
+    snapshot(): CompilerShadowRunSnapshot;
+    dispose(): void;
+    private ensureActive;
+}
+export declare function getCompilerShadowReportSession(owner: object): CompilerShadowReportSession;
+export declare function beginCompilerShadowRun(owner: object): number;
+export declare function getCompilerShadowRunRevision(owner: object): number;
+export declare function recordCompilerShadowReport(owner: object, report: CompilerShadowReport, revision?: number | undefined): boolean;
+export declare function getCompilerShadowRunSnapshot(owner: object): CompilerShadowRunSnapshot;
+export declare function completeCompilerShadowReportRun(owner: object, revision?: number | undefined): CompilerShadowRunSnapshot | undefined;
+export declare function disposeCompilerShadowReportSession(owner: object): void;

package/dist/compiler/shadow-report.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactSemanticDifference, ArtifactSemanticSummary, CompareArtifactSemanticsOptions } from './semantic-css.js';
+import type { GenerationArtifact } from './types.js';
+export interface CompilerShadowReport {
+    file: string;
+    scopeId: string;
+    equal: boolean;
+    differences: ArtifactSemanticDifference[];
+    truncated: boolean;
+    legacy: ArtifactSemanticSummary;
+    graph: ArtifactSemanticSummary;
+}
+export interface CreateCompilerShadowReportOptions extends CompareArtifactSemanticsOptions {
+    scopeId?: string | undefined;
+}
+export declare function createCompilerShadowReport(file: string, legacy: GenerationArtifact | undefined, graph: GenerationArtifact | undefined, options?: CreateCompilerShadowReportOptions): CompilerShadowReport;

package/dist/compiler/source-graph.d.ts

@@ -0,0 +1,32 @@
+import type { SourceGraphEdge, SourceGraphNode } from './types.js';
+export declare class SourceGraph {
+    private readonly edges;
+    private readonly nodes;
+    replace(nodes: Iterable<SourceGraphNode>, edges: Iterable<SourceGraphEdge>): void;
+    getNode(id: string): {
+        scope: {
+            id: string;
+            kind: import("./types.js").SourceScopeKind;
+        };
+        id: string;
+        kind: import("./types.js").SourceKind;
+        content?: string | undefined;
+    } | undefined;
+    getNodes(): {
+        scope: {
+            id: string;
+            kind: import("./types.js").SourceScopeKind;
+        };
+        id: string;
+        kind: import("./types.js").SourceKind;
+        content?: string | undefined;
+    }[];
+    getEdges(): {
+        from: string;
+        to: string;
+        kind: import("./types.js").SourceEdgeKind;
+    }[];
+    getDependents(id: string): string[];
+    clear(): void;
+    private edgeKey;
+}

package/dist/compiler/tailwind-generation-session-pool.d.ts

@@ -0,0 +1,22 @@
+import type { TailwindResolvedSource, WeappTailwindcssGenerateOptions, WeappTailwindcssGenerateResult } from '../generator/index.js';
+export type TailwindGenerationPoolChange = {
+    type: 'all';
+} | {
+    type: 'dependencies';
+    paths?: Iterable<string> | undefined;
+} | {
+    type: 'source';
+    source: TailwindResolvedSource;
+};
+export declare class TailwindGenerationSessionPool {
+    private readonly generators;
+    private disposed;
+    generate(source: TailwindResolvedSource, options?: WeappTailwindcssGenerateOptions): Promise<WeappTailwindcssGenerateResult>;
+    validateCandidates(source: TailwindResolvedSource, candidates: Iterable<string>): Promise<Set<string>>;
+    invalidate(change: TailwindGenerationPoolChange): void;
+    dispose(): void;
+    get size(): number;
+    private getGenerator;
+}
+export declare function getTailwindGenerationSessionPool(owner: object): TailwindGenerationSessionPool;
+export declare function disposeTailwindGenerationSessionPool(owner: object): void;

package/dist/compiler/types.d.ts

@@ -0,0 +1,95 @@
+import type { Root } from 'postcss';
+export type CompilerMode = 'legacy' | 'shadow' | 'graph';
+export type CssFragmentKind = 'tailwind' | 'theme' | 'preflight' | 'user' | 'import';
+export type CssStage = 'raw' | 'framework-processed' | 'adapted';
+export type SourceKind = 'css' | 'template' | 'script' | 'config' | 'asset';
+export type SourceScopeKind = 'global' | 'subpackage' | 'component';
+export type SourceEdgeKind = 'imports' | 'candidate-source' | 'depends-on' | 'emits-to';
+export interface SourceScope {
+    id: string;
+    kind: SourceScopeKind;
+}
+export interface SourceGraphNode {
+    id: string;
+    kind: SourceKind;
+    scope: SourceScope;
+    content?: string | undefined;
+}
+export interface SourceGraphEdge {
+    from: string;
+    to: string;
+    kind: SourceEdgeKind;
+}
+export interface CssFragment {
+    id: string;
+    kind: CssFragmentKind;
+    root: Root;
+    sourceId: string;
+    scope: SourceScope;
+    order: number;
+    stage: CssStage;
+}
+export interface GenerationArtifact {
+    fragments: CssFragment[];
+    classSet: Set<string>;
+    rawCandidates: Set<string>;
+    dependencies: string[];
+    sourceEntries: string[];
+    revision?: number | undefined;
+}
+export interface CandidateChange {
+    sourceId: string;
+    addedCandidates: Set<string>;
+    removedCandidates: Set<string>;
+}
+export type CompilationChange = CandidateChange | {
+    sourceId: string;
+    type: 'source-removed';
+} | {
+    sourceId: string;
+    type: 'dependency-changed';
+} | {
+    sourceId: string;
+    type: 'config-changed';
+};
+export interface CompilationGraphSnapshot {
+    nodes: SourceGraphNode[];
+    edges: SourceGraphEdge[];
+}
+export interface CompilationSnapshot extends CompilationGraphSnapshot {
+    candidatesBySource?: Iterable<readonly [string, Iterable<string>]> | undefined;
+    changes?: CompilationChange[] | undefined;
+    preserveDeletedCss?: boolean | undefined;
+    validatedClassSet?: Iterable<string> | undefined;
+}
+export interface CompilationResult {
+    revision: number;
+    candidates: Set<string>;
+    candidatesBySource: Map<string, Set<string>>;
+    validatedClassSet: Set<string>;
+    invalidatedScopes: Set<string>;
+    graphEdges: SourceGraphEdge[];
+    graphNodes: SourceGraphNode[];
+}
+export interface CompilationSession {
+    update: (snapshot: CompilationSnapshot) => CompilationResult | Promise<CompilationResult>;
+    commitValidation: (revision: number, validatedClassSet: Iterable<string>, graph?: CompilationGraphSnapshot | undefined) => CompilationResult | Promise<CompilationResult>;
+    dispose: () => void;
+}
+export interface PlatformGenerationRequest {
+    sourceId: string;
+    scope: SourceScope;
+    css: string;
+    candidates: Set<string>;
+}
+export interface PreparedPlatformGenerationRequest extends PlatformGenerationRequest {
+    restoreCandidates?: ReadonlyMap<string, string> | undefined;
+}
+export interface PlatformAdapterContext {
+    stage: CssStage;
+}
+export interface PlatformAdapter {
+    id: 'web' | 'mini-program' | 'native-app';
+    prepare: (request: PlatformGenerationRequest) => PreparedPlatformGenerationRequest;
+    transform: (artifact: GenerationArtifact, context: PlatformAdapterContext) => Promise<GenerationArtifact>;
+}

package/dist/constants.d.ts

@@ -2,8 +2,8 @@ export declare const runtimeAopLoader = "weapp-tw-runtime-aop-loader";
 export declare const WeappTailwindcssWebpackPluginOptimizeChunkAssetsHooks = "WeappTailwindcssWebpackPluginOptimizeChunkAssetsHooks";
 export declare const pluginName = "weapp-tailwindcss";
 export declare const vitePluginName = "weapp-tailwindcss:adaptor";
-export declare const WEAPP_TW_REQUIRED_NODE_VERSION = "20.19.0";
-export declare const WEAPP_TW_REQUIRED_NODE_VERSION_RANGE = "^20.19.0 || >=22.12.0";
+export declare const WEAPP_TW_REQUIRED_NODE_VERSION = "22.18.0";
+export declare const WEAPP_TW_REQUIRED_NODE_VERSION_RANGE = "^22.18.0 || >=24.11.0";
 export declare const WEAPP_TW_VERSION: string;
 export declare const DEFAULT_RUNTIME_PACKAGE_REPLACEMENTS: {
     readonly 'tailwind-merge': "@weapp-tailwindcss/merge";

package/dist/context/compiler-context-cache.d.ts

@@ -1,3 +1,3 @@
-import type { InternalUserDefinedOptions, UserDefinedOptions } from '../types';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../types/index.js';
 export declare function createCompilerContextCacheKey(opts?: UserDefinedOptions): string | undefined;
 export declare function withCompilerContextCache(opts: UserDefinedOptions | undefined, factory: () => InternalUserDefinedOptions): InternalUserDefinedOptions;

package/dist/context/custom-attributes.d.ts

@@ -1,2 +1,2 @@
-import type { ICustomAttributes, ICustomAttributesEntities } from '../types';
+import type { ICustomAttributes, ICustomAttributesEntities } from '../types/index.js';
 export declare function toCustomAttributesEntities(customAttributes?: ICustomAttributes): ICustomAttributesEntities;

package/dist/context/handlers.d.ts

@@ -1,6 +1,6 @@
-import type { ICustomAttributesEntities, InternalUserDefinedOptions } from '../types';
+import type { ICustomAttributesEntities, InternalUserDefinedOptions } from '../types/index.js';
 export declare function createHandlersFromContext(ctx: InternalUserDefinedOptions, customAttributesEntities: ICustomAttributesEntities, cssCalcOptions: InternalUserDefinedOptions['cssCalc'], tailwindcssMajorVersion?: number): {
     styleHandler: import("@weapp-tailwindcss/postcss").StyleHandler;
-    jsHandler: import("@/types").JsHandler;
-    templateHandler: (rawSource: string, opt?: Pick<import("@/types").ITemplateHandlerOptions, "runtimeSet">) => Promise<string>;
+    jsHandler: import("../types/index.js").JsHandler;
+    templateHandler: (rawSource: string, opt?: Pick<import("../types/index.js").ITemplateHandlerOptions, "runtimeSet">) => Promise<string>;
 };

package/dist/context/index.d.ts

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions, TailwindcssRuntimeLike, UserDefinedOptions } from '../types';
+import type { InternalUserDefinedOptions, TailwindcssRuntimeLike, UserDefinedOptions } from '../types/index.js';
 interface ClearTailwindcssRuntimeCacheOptions {
     removeDirectory?: boolean;
 }

package/dist/context/runtime-package-replacements.d.ts

@@ -1,2 +1,2 @@
-import type { InternalUserDefinedOptions } from '../types';
+import type { InternalUserDefinedOptions } from '../types/index.js';
 export declare function resolveRuntimePackageReplacements(option: InternalUserDefinedOptions['replaceRuntimePackages']): Record<string, string> | undefined;

package/dist/context/style-options.d.ts

@@ -1,5 +1,5 @@
 import type { IStyleHandlerOptions } from '@weapp-tailwindcss/postcss/types';
-import type { InternalUserDefinedOptions } from '../types';
+import type { InternalUserDefinedOptions } from '../types/index.js';
 export type ResolvedStyleOptions = Partial<IStyleHandlerOptions> & {
     appType?: InternalUserDefinedOptions['appType'] | undefined;
 };