@pandacss/compiler 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/index.d.ts

@@ -1,162 +1,92 @@
-import { SerializedConfig, Span, Diagnostic, MatchCategory, ExtractedCall, ExtractedJsx, ExtractResult, Compiler, SerializedHookFilter, CompileOutput, Driver, CompilerOptions, ConfigSnapshot } from '@pandacss/compiler-shared';
+import * as _pandacss_compiler_shared from '@pandacss/compiler-shared';
+import { BaseDriver, Diagnostic, CodegenOverlay, DesignSystemWatchTarget, DesignSystemWatchFileKind, SourceChange, DiffConfigResult, CodegenOptions, CompileOptions, CompileOutput, WriteCssOptions, WriteCssResult, WriteLayerCssOptions, WriteSplitCssOptions, WriteSplitCssResult, SerializedConfig, CompilerOptions, ConfigSnapshot } from '@pandacss/compiler-shared';
 export * from '@pandacss/compiler-shared';
-
-interface CompileInput {
-    files?: Array<{
-        path: string;
-        content: string;
-    }>;
-    config?: SerializedConfig;
-    cwd?: string;
-    cacheDir?: string;
-    emitLayerDeclaration?: boolean;
-}
-type ImportSpecifierKind = 'named' | 'default' | 'namespace';
-interface ImportSpecifier {
-    kind: ImportSpecifierKind;
-    imported: string;
-    local: string;
-    typeOnly: boolean;
-    span: Span;
-}
-type ImportKind = 'sideEffect' | 'value';
-interface ImportRecord {
-    module: string;
-    kind: ImportKind;
-    typeOnly: boolean;
-    specifiers: ImportSpecifier[];
-    span: Span;
-}
-interface ImportScanResult {
-    imports: ImportRecord[];
-    diagnostics: Diagnostic[];
-}
-interface Matcher {
-    modules: string[];
-    /** Omit to match any imported name (used for recipes/patterns). */
-    names?: string[];
-}
-type JsxFramework = 'react' | 'solid' | 'preact' | 'vue' | 'qwik' | (string & {});
-type CssSyntax = 'template-literal' | 'object-literal';
-interface Matchers {
-    css: Matcher;
-    recipe: Matcher;
-    pattern: Matcher;
-    jsx?: Matcher;
-    tokens: Matcher;
-    /** Configured JSX framework. Enables JSX-aware extraction diagnostics. */
-    jsxFramework?: JsxFramework;
-    /** Resolved Panda token dictionary. When present, `token('path')` and
-     *  `token.var('path')` calls fold to their dictionary value during
-     *  extraction. */
-    tokenDictionary?: TokenDictionary;
-    /** Resolved JSX factory names that accept member-chain tags (`<styled.div>`). */
-    jsxFactories?: string[];
-    /** CSS authoring syntax preference. Omit for object-literal mode. */
-    syntax?: CssSyntax;
-}
-/** Two parallel `path → string` maps backing `token()` resolution.
- *  - `values['colors.red.500']` → raw value, e.g. `'#ef4444'`
- *  - `vars['colors.red.500']` → CSS-var form, e.g. `'var(--colors-red-500)'` */
-interface TokenDictionary {
-    values: Record<string, string>;
-    vars: Record<string, string>;
-}
-interface MatchedImport {
-    category: MatchCategory;
-    module: string;
-    name: string;
-    alias: string;
-    kind: ImportSpecifierKind;
-}
-interface ExtractedCallsResult {
-    calls: ExtractedCall[];
-    diagnostics: Diagnostic[];
-}
-interface ExtractedJsxResult {
-    jsx: ExtractedJsx[];
-    diagnostics: Diagnostic[];
-}
-/** Full result including raw + matched imports, for tooling / parity flows. */
-interface ExtractDebugResult {
-    imports: ImportRecord[];
-    matched: MatchedImport[];
-    calls: ExtractedCall[];
-    jsx: ExtractedJsx[];
-    diagnostics: Diagnostic[];
-}
-/** Reusable extractor session — built once from a `Matchers` config, then
- *  called per file. For one-off use, prefer a `Compiler` + `extractFileSource`. */
-interface ExtractorSession {
-    extract(path: string, source: string): ExtractResult;
-    extractDebug(path: string, source: string): ExtractDebugResult;
-    matchImports(scan: ImportScanResult): MatchedImport[];
-}
-interface ExtractorSessionConstructor {
-    new (matchers: Matchers): ExtractorSession;
-}
-interface TraceOptions {
-    /** Tracing filter, e.g. "trace", "debug", or "pandacss_project=trace". */
-    filter?: string;
-    /** `fmt` writes to stderr; `chrome-json` writes a Chrome trace file. */
-    output?: 'fmt' | 'chrome-json';
-    /** Required for useful `chrome-json` output. Defaults to `.panda/trace.json`. */
-    file?: string;
-}
-interface NativeCompilerOptions {
-    crossFile?: boolean;
-}
-/** The raw native instance — superset of {@link Compiler} carrying the internal
- *  methods the facade hides. */
-interface RawCompiler extends Compiler {
-    token_dictionary?(): TokenDictionary | undefined;
-    registerUtilityTransform?(id: string, callback: (resolved: unknown, original: unknown) => unknown): void;
-    registerPatternTransform?(id: string, callback: (props: unknown, helpers: Record<string, unknown>) => unknown): void;
-    registerSourceTransform?(id: string, filter: SerializedHookFilter | undefined, callback: (filePath: string, content: string) => string | undefined): void;
-}
-interface CompilerConstructor {
-    fromConfig(config: SerializedConfig, options?: NativeCompilerOptions, utilityValuesCallbacks?: Record<string, (tokenDictionary: TokenDictionary | undefined) => unknown>): RawCompiler;
-}
-interface NativeBinding {
-    startTracing?(options?: TraceOptions): boolean;
-    flushTracing?(): void;
-    shutdownTracing?(): boolean;
-    compile(input?: CompileInput): CompileOutput;
-    scanImports(path: string, source: string): ImportScanResult;
-    matchImports(scan: ImportScanResult, matchers: Matchers): MatchedImport[];
-    extractCalls(path: string, source: string, matched: MatchedImport[], matchers: Matchers): ExtractedCallsResult;
-    extractJsx(path: string, source: string, matched: MatchedImport[], matchers: Matchers): ExtractedJsxResult;
-    extract(path: string, source: string, matchers: Matchers): ExtractResult;
-    extractDebug(path: string, source: string, matchers: Matchers): ExtractDebugResult;
-    Extractor: ExtractorSessionConstructor;
-    Compiler: CompilerConstructor;
-}
+export { NativeSourceTransformer, NativeTransformSourceInput, TransformSourceOptions, TransformSourceResult, createUsageReport } from '@pandacss/compiler-shared';
+import { C as CompileInput, T as TraceOptions, N as NativeCompiler } from './types-DR9fSNfa.js';
+export { o as CompilerConstructor, e as CssSyntax, j as ExtractDebugResult, E as ExtractedCallsResult, i as ExtractedJsxResult, k as ExtractorSession, l as ExtractorSessionConstructor, b as ImportKind, c as ImportRecord, d as ImportScanResult, a as ImportSpecifier, I as ImportSpecifierKind, J as JsxFramework, h as MatchedImport, M as Matcher, f as Matchers, p as NativeBinding, m as NativeCompilerOptions, n as RawCompiler, R as RawSourceTransformBinding, g as TokenDictionary } from './types-DR9fSNfa.js';
+import { LoadConfigResult } from '@pandacss/config';
 
 interface NodeDriverOptions {
     cwd: string;
     /** Explicit config file (relative to `cwd`); otherwise discovered upward. */
     configPath?: string;
+    /** Override the config's `include` globs (e.g. CLI `--include`). Empty/omitted keeps the config value. */
+    include?: string[];
+}
+interface WriteDesignSystemLibOptions {
+    outdir?: string;
+    files?: string[];
+    panda?: string;
+    minify?: boolean;
+    maxWarnings?: number | string;
+}
+interface WriteDesignSystemLibResult {
+    manifestPath: string;
+    buildInfoPath: string;
+    presetPath: string;
+    exportsChanged: boolean;
+    parsedFileCount: number;
+    diagnostics: Diagnostic[];
 }
 /**
  * {@link Driver} backed by the native compiler (`OsFileSystem`). Loads the
  * config from disk; `scan` / `codegen` run through the Rust fs engine.
  */
-declare function createNodeDriver(options: NodeDriverOptions): Promise<Driver>;
+declare function createNodeDriver(options: NodeDriverOptions): Promise<NodeDriver>;
+declare class NodeDriver extends BaseDriver {
+    #private;
+    constructor(options: NodeDriverOptions, loaded: LoadConfigResult);
+    get designSystemDiagnostics(): Diagnostic[];
+    protected codegenOverlay(): CodegenOverlay | undefined;
+    get config(): _pandacss_compiler_shared.SerializedConfig;
+    get configPath(): string;
+    get configDependencies(): string[];
+    designSystemWatchTargets(): DesignSystemWatchTarget[];
+    isDesignSystemFile(file: string): DesignSystemWatchFileKind | false;
+    private buildDesignSystemFileKinds;
+    syncDesignSystemFileChange(change: SourceChange): Promise<boolean>;
+    syncDesignSystemSources(): boolean[];
+    reload(): Promise<DiffConfigResult>;
+    /** Re-hydrate when treeshake import set changes. */
+    syncDesignSystemTreeShake(): boolean;
+    protected prepareCssOutput(): void;
+    applyChange(change: SourceChange): boolean;
+    getOutdir(outdir?: string): string;
+    writeDesignSystemLib(options?: WriteDesignSystemLibOptions): Promise<WriteDesignSystemLibResult>;
+    codegen(options?: CodegenOptions): string[];
+    cssgen(options?: CompileOptions): CompileOutput;
+    writeCss(options: WriteCssOptions): WriteCssResult;
+    writeLayerCss(options: WriteLayerCssOptions): WriteCssResult;
+    writeSplitCss(options?: WriteSplitCssOptions): WriteSplitCssResult;
+    private runCssgenDone;
+    private codegenWithPrepareHooks;
+    isConfigFile(file: string): boolean;
+    private buildConfigFilePaths;
+    private parseDesignSystemLib;
+    private compileDesignSystemPreset;
+    private writeDesignSystemLibArtifacts;
+}
 
-/** One-shot stateless compile: build a compiler from `config`, parse every
- *  input file, and emit the stylesheet. Callback-bearing configs
- *  (`utilities.*.transform`, `patterns.*.transform`) are *not* supported here —
- *  use [`createCompiler`] + `options.callbacks` for those. */
+/**
+ * One-shot stateless compile: build a compiler from `config`, parse every
+ * input file, and emit the stylesheet. Callback-bearing configs
+ * (`utilities.*.transform`, `patterns.*.transform`) are *not* supported here -
+ * use [`createCompiler`] + `options.callbacks` for those.
+ */
 declare function compile(input?: CompileInput): CompileOutput;
 declare function startTracing(options?: TraceOptions): boolean;
 declare function flushTracing(): void;
+/** Renders `timings.json` from spans collected so far. Call before `shutdownTracing`. */
+declare function takeTimingsJson(): string | undefined;
 declare function shutdownTracing(): boolean;
-declare function createCompiler(config: SerializedConfig, options?: CompilerOptions): Compiler;
-/** Like {@link createCompiler}, but takes a snapshot; its callbacks merge under
- *  any in `options.callbacks`. */
-declare function createCompilerFromSnapshot(snapshot: ConfigSnapshot, options?: CompilerOptions): Compiler;
+declare function createCompiler(config: SerializedConfig, options?: CompilerOptions): NativeCompiler;
+/**
+ * Like {@link createCompiler}, but takes a snapshot; its callbacks merge under
+ * any in `options.callbacks`.
+ */
+declare function createCompilerFromSnapshot(snapshot: ConfigSnapshot, options?: CompilerOptions): NativeCompiler;
 declare function getBindingInfo(): {
     native: boolean;
 };
 
-export { type CompileInput, type CompilerConstructor, type CssSyntax, type ExtractDebugResult, type ExtractedCallsResult, type ExtractedJsxResult, type ExtractorSession, type ExtractorSessionConstructor, type ImportKind, type ImportRecord, type ImportScanResult, type ImportSpecifier, type ImportSpecifierKind, type JsxFramework, type MatchedImport, type Matcher, type Matchers, type NativeBinding, type NativeCompilerOptions, type NodeDriverOptions, type RawCompiler, type TokenDictionary, type TraceOptions, compile, createCompiler, createCompilerFromSnapshot, createNodeDriver, flushTracing, getBindingInfo, shutdownTracing, startTracing };
+export { CompileInput, NativeCompiler, NodeDriver, type NodeDriverOptions, TraceOptions, type WriteDesignSystemLibOptions, type WriteDesignSystemLibResult, compile, createCompiler, createCompilerFromSnapshot, createNodeDriver, flushTracing, getBindingInfo, shutdownTracing, startTracing, takeTimingsJson };

package/dist/index.js

@@ -1,20 +1,26 @@
 import {
+  NodeDriver,
   compile,
   createCompiler,
   createCompilerFromSnapshot,
   createNodeDriver,
+  createUsageReport,
   flushTracing,
   getBindingInfo,
   shutdownTracing,
-  startTracing
-} from "./chunk-7OM4CBA4.js";
+  startTracing,
+  takeTimingsJson
+} from "./chunk-73WPZHEX.js";
 export {
+  NodeDriver,
   compile,
   createCompiler,
   createCompilerFromSnapshot,
   createNodeDriver,
+  createUsageReport,
   flushTracing,
   getBindingInfo,
   shutdownTracing,
-  startTracing
+  startTracing,
+  takeTimingsJson
 };

package/dist/loader.d.ts

@@ -1,10 +1,11 @@
-import { Compiler, CompilerOptions } from '@pandacss/compiler-shared';
+import { CompilerOptions } from '@pandacss/compiler-shared';
 import { LoadConfigOptions } from '@pandacss/config';
 export { LoadConfigOptions, LoadConfigResult } from '@pandacss/config';
+import { N as NativeCompiler } from './types-DR9fSNfa.js';
 
 interface LoadCompilerResult {
     /** The compiler built from the loaded config snapshot. */
-    compiler: Compiler;
+    compiler: NativeCompiler;
     /** Resolved config path. */
     path: string;
     /** Module ids to watch for invalidation. */

package/dist/loader.js

@@ -1,6 +1,6 @@
 import {
   createCompilerFromSnapshot
-} from "./chunk-7OM4CBA4.js";
+} from "./chunk-73WPZHEX.js";
 
 // src/loader.ts
 import { loadConfig } from "@pandacss/config";

package/dist/tooling/index.d.ts

@@ -0,0 +1,108 @@
+import { Compiler, Diagnostic, FileInspectionResult, Spec, Deprecation } from '@pandacss/compiler-shared';
+import { LoadConfigResult } from '@pandacss/config';
+import { ImportMapOutput } from '@pandacss/types';
+
+interface NativeCompiler extends Compiler {
+}
+
+interface ProjectKey {
+    cwd: string;
+    /** Explicit config file (relative to `cwd`); otherwise discovered upward. */
+    configPath?: string;
+}
+interface Project {
+    compiler: NativeCompiler;
+    configPath: string;
+    dependencies: string[];
+    outdir: string;
+    /** Non-fatal issues surfaced while hydrating a consumed design-system package. */
+    designSystemDiagnostics: Diagnostic[];
+    /** Treeshake import fingerprint (watch sync). */
+    designSystemTreeshakeKey?: string;
+}
+declare function createProjectFromLoadedConfig(loaded: LoadConfigResult): Project;
+declare function createProjectFromConfig(key: ProjectKey): Promise<Project>;
+
+interface FileInspectionCacheEntry {
+    sourceKey: string;
+    result: FileInspectionResult;
+}
+/** Caches `compiler.inspectFile()` results per `(compiler, path)`, invalidated by source content. */
+declare class FileInspector {
+    #private;
+    inspect(compiler: Compiler, path: string, source: string): FileInspectionResult;
+    clear(compiler?: Compiler): void;
+}
+declare function sourceCacheKey(source: string): string;
+
+interface ProjectRegistryOptions {
+    createProject?: (key: ProjectKey) => Promise<Project>;
+}
+declare class ProjectRegistry {
+    #private;
+    constructor(options?: ProjectRegistryOptions);
+    getProject(key: ProjectKey): Promise<Project>;
+    invalidate(_changedPaths?: string[]): void;
+}
+
+declare class SpecIndex {
+    #private;
+    readonly spec: Spec;
+    constructor(spec: Spec);
+    resolveTokenValue(path: string): string | undefined;
+    resolveTokenPaths(prefix?: string): string[];
+    resolveTokenDeprecation(path: string): Deprecation | undefined;
+    hasCondition(name: string): boolean;
+    /** Bare style-object keys: named/custom conditions plus breakpoints (`sm`, `md`, ...). */
+    resolveStyleObjectKeys(): string[];
+    resolveTokenCategoryForProperty(property: string): string | undefined;
+    resolveLiteralsForProperty(property: string): string[] | undefined;
+    resolveKeyframeNames(prefix?: string): string[];
+    /** Token category names actually present in this config (`colors`, `spacing`, ...). */
+    resolveTokenCategories(prefix?: string): string[];
+}
+
+interface ConfigTokenRefSpan {
+    start: number;
+    end: number;
+    pathStart: number;
+    pathEnd: number;
+    path: string;
+}
+declare function findConfigTokenRefs(text: string): ConfigTokenRefSpan[];
+declare function findConfigTokenRefAt(text: string, position: number): ConfigTokenRefSpan | undefined;
+declare function completeConfigTokenPath(prefix: string, index: SpecIndex): string[];
+
+type StyleObjectCursorKind = 'key' | 'value';
+interface StyleObjectContext {
+    existingKeys: string[];
+    cursorKind: StyleObjectCursorKind;
+    /**
+     * Style-object-relative key chain leading to the cursor (see typescript-plugin's
+     * `getStyleObjectCursorInfo`) — e.g. `['color']`, or `['backgroundColor', 'sm']` for a
+     * utility's own inline conditional value (`backgroundColor: { sm: 're' }`).
+     */
+    propertyPath: string[];
+    prefix: string;
+}
+type CompletionEntryKind = 'utility' | 'condition' | 'token' | 'keyframe' | 'literal' | 'keyword' | 'category';
+interface CompletionEntry {
+    name: string;
+    kind: CompletionEntryKind;
+}
+declare function completeConfigStyleObject(context: StyleObjectContext, index: SpecIndex): CompletionEntry[];
+
+type SemanticTokenCursorKind = 'category' | 'condition';
+interface SemanticTokenContext {
+    cursorKind: SemanticTokenCursorKind;
+    existingKeys: string[];
+    prefix: string;
+}
+declare function completeSemanticTokenObject(context: SemanticTokenContext, index: SpecIndex): CompletionEntry[];
+
+interface ResolveModuleTargetOptions {
+    outdir: string;
+}
+declare function resolveModuleTarget(specifier: string, importMap: ImportMapOutput, options: ResolveModuleTargetOptions): string | undefined;
+
+export { type CompletionEntry, type CompletionEntryKind, type ConfigTokenRefSpan, type FileInspectionCacheEntry, FileInspector, type Project, type ProjectKey, ProjectRegistry, type ProjectRegistryOptions, type ResolveModuleTargetOptions, type SemanticTokenContext, type SemanticTokenCursorKind, SpecIndex, type StyleObjectContext, type StyleObjectCursorKind, completeConfigStyleObject, completeConfigTokenPath, completeSemanticTokenObject, createProjectFromConfig, createProjectFromLoadedConfig, findConfigTokenRefAt, findConfigTokenRefs, resolveModuleTarget, sourceCacheKey };