@pandacss/types 1.11.3 → 2.0.0-beta.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Segun Adebayo
+Copyright (c) 2023 Chakra Systems Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,18 @@
+# @pandacss/types
+
+The public TypeScript types for [Panda CSS](https://panda-css.com) — `Config`, `Preset`, `UserConfig`, and the
+supporting type surface used across the Panda packages.
+
+## Installation
+
+```bash
+npm install -D @pandacss/types
+```
+
+## Documentation
+
+Visit the [Panda CSS documentation](https://panda-css.com) to learn more.
+
+## License
+
+MIT © [Chakra Systems Inc.](https://github.com/chakra-ui)

package/dist/conditions.d.ts

@@ -1,14 +1,8 @@
 import type { AnySelector, Selectors } from './selectors'
 
-export type ConditionType =
-  | 'at-rule'
-  | 'parent-nesting'
-  | 'self-nesting'
-  | 'combinator-nesting'
-  | 'mixed'
-  | 'multi-block'
+export type ConditionType = 'at-rule' | 'parent-nesting' | 'self-nesting' | 'combinator-nesting' | 'mixed'
 
-export type ConditionDetails = AtRuleCondition | SelectorCondition | MixedCondition | MultiBlockCondition
+export type ConditionDetails = AtRuleCondition | SelectorCondition | MixedCondition
 
 export interface AtRuleCondition {
   type: 'at-rule'
@@ -30,21 +24,15 @@ export interface MixedCondition {
   raw: string[]
 }
 
-export interface MultiBlockCondition {
-  type: 'multi-block'
-  value: MixedCondition[]
-  raw: Record<string, any>
-}
-
 /* -----------------------------------------------------------------------------
  * Shadowed export (in CLI): DO NOT REMOVE
  * -----------------------------------------------------------------------------*/
 
-export type ConditionObjectQuery = {
-  [key: string]: ConditionObjectQuery | '@slot'
+export type ConditionSlot = '@slot'
+export interface ConditionBlock {
+  [selector: string]: ConditionSlot | ConditionBlock
 }
-
-export type ConditionQuery = string | string[] | ConditionObjectQuery
+export type ConditionQuery = string | ConditionBlock
 
 export interface Conditions {
   [condition: string]: ConditionQuery

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import type { TSConfig } from 'pkg-types'
 import type { Conditions, ExtendableConditions } from './conditions'
-import type { PandaHooks } from './hooks'
+import type { HookRegistry } from './hooks'
 import type { PatternConfig } from './pattern'
 import type { Keys, LiteralUnion, PathIn, RequiredBy } from './shared'
 import type { StaticCssOptions } from './static-css'
@@ -20,30 +20,6 @@ export type CascadeLayer = 'reset' | 'base' | 'tokens' | 'recipes' | 'utilities'
 
 export type CascadeLayers = Record<CascadeLayer, string>
 
-export interface StudioOptions {
-  /**
-   * Used to customize the design system studio
-   * @default { title: 'Panda', logo: '🐼' }
-   */
-  studio?: {
-    /**
-     * The output directory for the design system studio when the build command is run.
-     */
-    outdir?: string
-    /**
-     * The logo url for the design system studio.
-     */
-    logo?: string
-    /**
-     * Used to inject custom html into the head or body of the studio
-     */
-    inject?: {
-      head?: string
-      body?: string
-    }
-  }
-}
-
 export interface Patterns {
   [pattern: string]: PatternConfig
 }
@@ -206,7 +182,9 @@ export interface ExtendableOptions {
 
 export interface ImportMapInput {
   css?: string | string[]
+  recipe?: string | string[]
   recipes?: string | string[]
+  pattern?: string | string[]
   patterns?: string | string[]
   jsx?: string | string[]
   tokens?: string | string[]
@@ -223,11 +201,6 @@ export interface ImportMapOutput<T = string> {
 type ImportMapOption = string | ImportMapInput
 
 interface FileSystemOptions {
-  /**
-   * Whether to clean the output directory before generating the css.
-   * @default false
-   */
-  clean?: boolean
   /**
    * The output directory.
    * @default 'styled-system'
@@ -263,16 +236,6 @@ interface FileSystemOptions {
    * Use this option as a workaround.
    */
   dependencies?: string[]
-  /**
-   * Whether to watch for changes and regenerate the css.
-   * @default false
-   */
-  watch?: boolean
-  /**
-   * Whether to use polling instead of filesystem events when watching.
-   * @default false
-   */
-  poll?: boolean
   /**
    * The current working directory.
    * @default 'process.cwd()'
@@ -344,11 +307,6 @@ interface CssgenOptions {
    * @default '_'
    */
   separator?: '_' | '=' | '-'
-  /**
-   * Whether to minify the generated css.
-   * @default false
-   */
-  minify?: boolean
   /**
    * The root selector for the css variables.
    * @default ':where(:host, :root)'
@@ -360,69 +318,63 @@ interface CssgenOptions {
    */
   syntax?: 'template-literal' | 'object-literal'
   /**
-   * Whether to use `lightningcss` instead of `postcss` for css optimization.
-   * @default false
+   * Layer mappings used in the generated css.
+   * @default 'true'
    */
-  lightningcss?: boolean
+  layers?: Partial<CascadeLayers>
+}
+
+export interface OptimizeOptions {
   /**
-   * Browserslist query to target specific browsers.
-   * @see https://www.npmjs.com/package/browserslist
+   * Remove unused token declarations based on extracted project usage.
    */
-  browserslist?: string[]
+  removeUnusedTokens?: boolean
   /**
-   * Layer mappings used in the generated css.
-   * @default 'true'
+   * Remove unused keyframes based on extracted project usage.
    */
-  layers?: Partial<CascadeLayers>
+  removeUnusedKeyframes?: boolean
   /**
-   * Polyfill CSS @layers at-rules for older browsers.
-   * @default 'false'
-   * @see https://www.npmjs.com/package/@csstools/postcss-cascade-layers
+   * Narrow compound variant CSS to statically selected variant combinations.
    */
-  polyfill?: boolean
+  smartCompoundVariants?: boolean
 }
 
 interface CodegenOptions {
-  /**
-   * Whether to only emit the `tokens` directory
-   * @default false
-   */
-  emitTokensOnly?: boolean
   /**
    * Whether to hash the generated class names / css variables.
-   * This is useful if want to shorten the class names or css variables.
+   * This is useful if you want to shorten the class names or css variables.
    * @default false
    */
   hash?: boolean | { cssVar: boolean; className: boolean }
   /**
-   * Change generated typescript definitions to be more strict for property having a token or utility.
+   * Whether to resolve configured utility shorthands like `p` -> `padding`.
+   * @default true
    */
-  strictTokens?: boolean
+  shorthands?: boolean
   /**
-   * Change generated typescript definitions to be more strict for built-in CSS properties to only allow valid CSS values.
+   * Change generated TypeScript definitions to be more strict for properties
+   * having a token or utility.
    */
-  strictPropertyValues?: boolean
+  strictTokens?: boolean
   /**
-   * Whether to update the .gitignore file.
-   * @default 'true'
+   * Change generated TypeScript definitions to be more strict for built-in CSS
+   * properties to only allow valid CSS values.
    */
-  gitignore?: boolean
+  strictPropertyValues?: boolean
   /**
-   * Whether to allow shorthand properties
-   * @default 'true'
+   * Generated runtime file extension.
+   * @default 'js'
    */
-  shorthands?: boolean
+  outExtension?: 'ts' | 'js' | 'mjs'
   /**
-   * File extension for generated javascript files.
-   * @default 'mjs'
+   * Whether generated import specifiers include runtime file extensions.
+   * @default false
    */
-  outExtension?: 'mjs' | 'js'
+  forceImportExtension?: boolean
   /**
-   * Whether to force consistent type extensions for generated typescript .d.ts files.
-   * If set to `true` and `outExtension` is set to `mjs`, the generated typescript .d.ts files will have the extension `.d.mts`.
-   * @default false
+   * CSS emission optimizations. All optimizations are opt-in.
    */
-  forceConsistentTypeExtension?: boolean
+  optimize?: OptimizeOptions
 }
 
 interface PresetOptions {
@@ -432,12 +384,9 @@ interface PresetOptions {
   presets?: (string | Preset | Promise<Preset>)[]
 }
 
-export interface HooksOptions {
-  hooks?: Partial<PandaHooks>
-}
-
-export interface PandaPlugin extends HooksOptions {
+export interface PandaPlugin {
   name: string
+  hooks?: Partial<HookRegistry>
 }
 
 export interface PluginsOptions {
@@ -445,20 +394,13 @@ export interface PluginsOptions {
 }
 
 export interface Config
-  extends StudioOptions,
-    ExtendableOptions,
+  extends ExtendableOptions,
     CssgenOptions,
     CodegenOptions,
     FileSystemOptions,
     JsxOptions,
     PresetOptions,
-    HooksOptions,
     PluginsOptions {
-  /**
-   * Whether to opt-out of the defaults config presets: [`@pandacss/preset-base`, `@pandacss/preset-panda`]
-   * @default 'false'
-   */
-  eject?: boolean
   /**
    * The validation strictness to use when validating the config.
    * - When set to 'none', no validation will be performed.
@@ -470,7 +412,7 @@ export interface Config
   validation?: 'none' | 'warn' | 'error'
 }
 
-export interface Preset extends ExtendableOptions, PresetOptions {
+export interface Preset extends ExtendableOptions, PresetOptions, PluginsOptions {
   name: string
 }
 
@@ -501,7 +443,7 @@ export interface LoadConfigResult extends LoadTsConfigResult {
   serialized: string
   deserialize: () => Config
   dependencies: string[]
-  hooks: Partial<PandaHooks>
+  hooks: Partial<HookRegistry>
 }
 
 export interface HashOptions {

package/dist/hooks.d.ts

@@ -1,237 +1,113 @@
-import type { Artifact, ArtifactId, DiffConfigResult } from './artifact'
-import type { LoadConfigResult, UserConfig } from './config'
-import type { HooksApiInterface } from './hooks-api'
-import type { LoggerInterface } from './logger'
-import type { ParserResultInterface, ResultItem } from './parser'
-
-export interface PandaHooks {
-  /**
-   * Called when the config is resolved, after all the presets are loaded and merged.
-   * This is the first hook called, you can use it to tweak the config before the context is created.
-   */
-  'config:resolved': (args: ConfigResolvedHookArgs) => MaybeAsyncReturn<void | ConfigResolvedHookArgs['config']>
-  /**
-   * Called when each preset is resolved, allowing modification of individual presets.
-   * This hook is called for each preset during the resolution process, before they are merged together.
-   */
-  'preset:resolved': (args: PresetResolvedHookArgs) => MaybeAsyncReturn<void | PresetResolvedHookArgs['preset']>
-  /**
-   * Called when the token engine has been created
-   */
-  'tokens:created': (args: TokenCreatedHookArgs) => MaybeAsyncReturn
-  /**
-   * Called when the classname engine has been created
-   */
-  'utility:created': (args: UtilityCreatedHookArgs) => MaybeAsyncReturn
-  /**
-   * Called when the Panda context has been created and the API is ready to be used.
-   */
-  'context:created': (args: ContextCreatedHookArgs) => void
-  /**
-   * Called when the config file or one of its dependencies (imports) has changed.
-   */
-  'config:change': (args: ConfigChangeHookArgs) => MaybeAsyncReturn
-  /**
-   * Called after reading the file content but before parsing it.
-   * You can use this hook to transform the file content to a tsx-friendly syntax so that Panda's parser can parse it.
-   * You can also use this hook to parse the file's content on your side using a custom parser, in this case you don't have to return anything.
-   */
-  'parser:before': (args: ParserResultBeforeHookArgs) => string | void
-  /**
-   * @private USE IT ONLY IF YOU KNOW WHAT YOU ARE DOING
-   */
-  'parser:preprocess': JsxFactoryResultTransform['transform']
-  /**
-   * Called after the file styles are extracted and processed into the resulting ParserResult object.
-   * You can also use this hook to add your own extraction results from your custom parser to the ParserResult object.
-   */
-  'parser:after': (args: ParserResultAfterHookArgs) => void
-  /**
-   * Called right before writing the codegen files to disk.
-   * You can use this hook to tweak the codegen files before they are written to disk.
-   */
-  'codegen:prepare': (args: CodegenPrepareHookArgs) => MaybeAsyncReturn<void | Artifact[]>
-  /**
-   * Called after the codegen is completed
-   */
-  'codegen:done': (args: CodegenDoneHookArgs) => MaybeAsyncReturn
-  /**
-   * Called right before adding the design-system CSS (global, static, preflight, tokens, keyframes) to the final CSS
-   * Called right before writing/injecting the final CSS (styles.css) that contains the design-system CSS and the parser CSS
-   * You can use it to tweak the CSS content before it's written to disk or injected through the postcss plugin.
-   */
-  'cssgen:done': (args: CssgenDoneHookArgs) => string | void
-  /**
-   * Called when CSS needs to be optimized. Use this hook to replace the default PostCSS-based optimizer
-   * with a custom one (e.g. LightningCSS).
-   * Return the optimized CSS string, or void to fall through to the default PostCSS optimizer.
-   */
-  'css:optimize': (args: CssOptimizeHookArgs) => string | void
-}
+import type { Config } from './config'
 
 type MaybeAsyncReturn<T = void> = Promise<T> | T
 
-/* -----------------------------------------------------------------------------
- * Token hooks
- * -----------------------------------------------------------------------------*/
-
-interface TokenCssVarOptions {
-  fallback?: string
-  prefix?: string
-  hash?: boolean
-}
-
-interface TokenCssVar {
-  var: `--${string}`
-  ref: string
-}
+export type HookFilterPattern =
+  | string
+  | RegExp
+  | {
+      include?: Array<string | RegExp> | undefined
+      exclude?: Array<string | RegExp> | undefined
+    }
 
-export interface TokenConfigureOptions {
-  formatTokenName?: (path: string[]) => string
-  formatCssVar?: (path: string[], options: TokenCssVarOptions) => TokenCssVar
+export interface HookFilter {
+  id?: HookFilterPattern | undefined
+  code?:
+    | {
+        include?: string | RegExp | undefined
+        exclude?: string | RegExp | undefined
+      }
+    | undefined
 }
 
-export interface TokenCreatedHookArgs {
-  configure(opts: TokenConfigureOptions): void
-}
+type HookHandler = (...args: never[]) => unknown
 
-/* -----------------------------------------------------------------------------
- * Utility hooks
- * -----------------------------------------------------------------------------*/
+export type PandaHook<Handler extends HookHandler> = Handler | { filter?: HookFilter; handler: Handler }
 
-export interface UtilityConfigureOptions {
-  toHash?(path: string[], toHash: (str: string) => string): string
+export interface ParserResultBeforeHookArgs {
+  filePath: string
+  content: string
+  original?: string
 }
 
-export interface UtilityCreatedHookArgs {
-  configure(opts: UtilityConfigureOptions): void
+export interface PresetResolvedHookArgs {
+  preset: Config
+  name: string
 }
 
-/* -----------------------------------------------------------------------------
- * Config hooks
- * -----------------------------------------------------------------------------*/
-
-interface CallbackItem {
-  value: any
+interface TraverseItem {
+  value: unknown
   path: string
   depth: number
-  parent: any[] | Record<string, unknown>
+  parent: unknown[] | Record<string, unknown>
   key: string
 }
 
-type CallbackFn = (args: CallbackItem) => void
-
 interface TraverseOptions {
-  separator: string
+  separator?: string | undefined
   maxDepth?: number | undefined
 }
 
-interface TraverseFn {
-  (obj: any, callback: CallbackFn, options?: TraverseOptions): void
-}
-
-interface ConfigResolvedHookUtils {
-  omit: <T, K extends keyof T | (string & {})>(obj: T, paths: K[]) => Omit<T, K>
-  pick: <T, K extends keyof T | (string & {})>(obj: T, paths: K[]) => Partial<T>
-  traverse: TraverseFn
+export interface ConfigResolvedHookUtils {
+  omit<T extends object>(obj: T, paths: string[]): T
+  pick<T extends object>(obj: T, paths: string[]): Partial<T>
+  traverse(obj: unknown, callback: (item: TraverseItem) => void, options?: TraverseOptions): void
 }
 
 export interface ConfigResolvedHookArgs {
-  config: LoadConfigResult['config']
+  config: Config
   path: string
   dependencies: string[]
   utils: ConfigResolvedHookUtils
-  original?: LoadConfigResult['config']
-}
-
-export interface ConfigChangeHookArgs {
-  config: UserConfig
-  changes: DiffConfigResult
-}
-
-export interface PresetResolvedHookArgs {
-  preset: LoadConfigResult['config']
-  name: string
-  utils: ConfigResolvedHookUtils
-  original?: LoadConfigResult['config']
 }
 
-/* -----------------------------------------------------------------------------
- * Parser hooks
- * -----------------------------------------------------------------------------*/
-
-export interface ParserResultConfigureOptions {
-  matchTag?: (tag: string, isPandaComponent: boolean) => boolean
-  matchTagMode?: 'extend' | 'override'
-  matchTagProp?: (tag: string, prop: string) => boolean
+export interface CodegenFile {
+  path: string
+  code: string
+  dependencies: string[]
 }
 
-export interface ParserResultBeforeHookArgs {
-  filePath: string
-  content: string
-  configure: (opts: ParserResultConfigureOptions) => void
-  original?: string
+export interface CodegenArtifact {
+  id: string
+  files: CodegenFile[]
 }
 
-export interface JsxFactoryResultTransform {
-  transform: (result: { type: 'jsx-factory'; data: ResultItem['data'] }) => ResultItem['data']
+export interface CodegenPrepareHookArgs {
+  artifacts: CodegenArtifact[]
+  outdir: string
+  cwd?: string | undefined
 }
 
-export interface ParserResultAfterHookArgs {
-  filePath: string
-  result: ParserResultInterface | undefined
+export interface CodegenDoneHookArgs {
+  files: string[]
+  outdir: string
+  cwd?: string | undefined
 }
 
-/* -----------------------------------------------------------------------------
- * Codegen hooks
- * -----------------------------------------------------------------------------*/
-
-export interface CodegenPrepareHookArgs {
-  artifacts: Artifact[]
+export interface PandaHooks {
   /**
-   * The original state of the artifacts, as it was generated by Panda, without any modification from other preset hooks
+   * Called after authored presets are merged, before defaults and serialization.
    */
-  original?: Artifact[]
-  changed: ArtifactId[] | undefined
-}
-export interface CodegenDoneHookArgs {
-  changed: ArtifactId[] | undefined
-}
-
-/* -----------------------------------------------------------------------------
- * Cssgen hooks
- * -----------------------------------------------------------------------------*/
-
-type CssgenArtifact = 'global' | 'static' | 'reset' | 'tokens' | 'keyframes' | 'styles.css'
-
-export interface CssgenDoneHookArgs {
-  artifact: CssgenArtifact
+  'config:resolved': (args: ConfigResolvedHookArgs) => MaybeAsyncReturn<void | Config>
   /**
-   * The current state of the CSS, if any other preset hook has modified the CSS, this will be the modified state
+   * Called when an authored preset is resolved, before all configs are merged.
    */
-  content: string
+  'preset:resolved': (args: PresetResolvedHookArgs) => MaybeAsyncReturn<void | Config>
   /**
-   * The original state of the CSS, as it was generated by Panda, without any modification from other preset hooks
+   * Called after reading file content but before parsing it.
+   * Use this to transform non-standard source into TSX-friendly syntax.
    */
-  original?: string
-}
-
-/* -----------------------------------------------------------------------------
- * CSS optimize hooks
- * -----------------------------------------------------------------------------*/
-
-export interface CssOptimizeHookArgs {
-  css: string
-  minify?: boolean
-  browserslist?: string[]
-  original?: string
+  'parser:before': (args: ParserResultBeforeHookArgs) => MaybeAsyncReturn<string | void>
+  /**
+   * Called before generated files are written by a JS host.
+   */
+  'codegen:prepare': (args: CodegenPrepareHookArgs) => void | CodegenArtifact[]
+  /**
+   * Called after generated files are written by a JS host.
+   */
+  'codegen:done': (args: CodegenDoneHookArgs) => void
 }
 
-/* -----------------------------------------------------------------------------
- * Context hooks
- * -----------------------------------------------------------------------------*/
-
-export interface ContextCreatedHookArgs {
-  ctx: HooksApiInterface
-  logger: LoggerInterface
+export type HookRegistry = {
+  [Name in keyof PandaHooks]: PandaHook<PandaHooks[Name]>
 }

package/dist/index.d.ts

@@ -5,11 +5,9 @@ export type * from './config'
 export type * from './hooks'
 export type * from './hooks-api'
 export type * from './logger'
-export type * from './parser'
 export type * from './parts'
 export type * from './pattern'
 export type * from './recipe'
-export type * from './reporter'
 export type * from './runtime'
 export type * from './shared'
 export type * from './spec'

package/dist/theme.d.ts

@@ -64,9 +64,9 @@ export interface Theme {
    */
   containerNames?: string[]
   /**
-   * The predefined container sizes for your project.
+   * Container query sizes for your project.
    */
-  containerSizes?: Record<string, string>
+  containers?: Record<string, string>
   /**
    * The color palette configuration for your project.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/types",
-  "version": "1.11.3",
+  "version": "2.0.0-beta.0",
   "description": "The types for css panda",
   "main": "dist/index.d.ts",
   "author": "Segun Adebayo <joseshegs@gmail.com>",
@@ -31,14 +31,10 @@
     "microdiff": "1.5.0",
     "ncp": "2.0.0",
     "pkg-types": "2.3.0",
-    "ts-morph": "28.0.0",
-    "@pandacss/extractor": "1.11.3"
-  },
-  "engines": {
-    "node": ">=20"
+    "ts-morph": "28.0.0"
   },
   "scripts": {
     "dev": "tsx scripts/watch.ts",
-    "build": "cross-env PANDA_BUILD=1 tsx scripts/postbuild.ts && tsx scripts/build.ts"
+    "build": "tsx scripts/build.ts"
   }
 }

package/dist/parser.d.ts

@@ -1,40 +0,0 @@
-import type { BoxNodeArray, BoxNodeLiteral, BoxNodeMap, Unboxed } from '@pandacss/extractor'
-
-export interface ResultItem {
-  name?: string
-  data: Array<Unboxed['raw']>
-  type?: 'css' | 'cva' | 'sva' | 'token' | 'pattern' | 'recipe' | 'jsx-factory' | 'jsx-pattern' | 'jsx-recipe' | 'jsx'
-  box?: BoxNodeMap | BoxNodeLiteral | BoxNodeArray
-}
-
-export interface ParserResultInterface {
-  all: Array<ResultItem>
-  jsx: Set<ResultItem>
-  css: Set<ResultItem>
-  cva: Set<ResultItem>
-  sva: Set<ResultItem>
-  token: Set<ResultItem>
-  recipe: Map<string, Set<ResultItem>>
-  pattern: Map<string, Set<ResultItem>>
-  filePath: string | undefined
-  isEmpty: () => boolean
-  toArray: () => Array<ResultItem>
-  set: (name: 'cva' | 'css' | 'sva' | 'token', result: ResultItem) => void
-  setCss: (result: ResultItem) => void
-  setCva: (result: ResultItem) => void
-  setSva: (result: ResultItem) => void
-  setToken: (result: ResultItem) => void
-  setJsx: (result: ResultItem) => void
-  setPattern: (name: string, result: ResultItem) => void
-  setRecipe: (name: string, result: ResultItem) => void
-}
-
-export interface EncoderJson {
-  schemaVersion: string
-  styles: {
-    atomic?: string[]
-    recipes?: {
-      [name: string]: string[]
-    }
-  }
-}

package/dist/reporter.d.ts

@@ -1,167 +0,0 @@
-import type { ParserResultInterface } from './parser'
-
-export type ReportItemType =
-  | 'css'
-  | 'cva'
-  | 'sva'
-  | 'token'
-  | 'pattern'
-  | 'recipe'
-  | 'jsx-factory'
-  | 'jsx-pattern'
-  | 'jsx-recipe'
-  | 'jsx'
-
-type ComponentKind = 'component' | 'function'
-
-interface PropertyLocationRange {
-  startPosition: number
-  startLineNumber: number
-  startColumn: number
-  endPosition: number
-  endLineNumber: number
-  endColumn: number
-}
-
-export interface PropertyReportItem {
-  index: string
-  componentIndex: ComponentReportItem['componentIndex']
-  componentName: ComponentReportItem['componentName']
-  reportItemKind: 'token' | 'utility'
-  reportItemType: ReportItemType
-
-  path: string[]
-  conditionName?: string | undefined
-  propName: string
-  value: string | number | boolean
-
-  tokenType?: string
-  isKnownValue: boolean
-
-  range: PropertyLocationRange | null
-  filepath: string
-}
-
-/**
- * An component is either a component usage or a function usage
- * @example an component name could be 'Button', 'css', 'panda.div', 'vstack', ...
- */
-export interface ComponentReportItem extends Pick<PropertyReportItem, 'filepath'> {
-  componentIndex: string
-  componentName: string
-  reportItemType: ReportItemType
-  kind: ComponentKind
-  contains: Array<PropertyReportItem['index']>
-  value: Record<string, any>
-  range: PropertyLocationRange | null
-  debug?: boolean
-}
-
-export interface ReportDerivedMaps {
-  byComponentOfKind: Map<ComponentKind, Set<ComponentReportItem['componentIndex']>>
-  byPropertyName: Map<string, Set<PropertyReportItem['index']>>
-  byTokenType: Map<string, Set<PropertyReportItem['index']>>
-  byConditionName: Map<string, Set<PropertyReportItem['index']>>
-  byShorthand: Map<string, Set<PropertyReportItem['index']>>
-  byTokenName: Map<string, Set<PropertyReportItem['index']>>
-  byPropertyPath: Map<string, Set<PropertyReportItem['index']>>
-  fromKind: Map<ComponentKind, Set<PropertyReportItem['index']>>
-  byType: Map<string, Set<PropertyReportItem['index']>>
-  byComponentName: Map<string, Set<PropertyReportItem['index']>>
-  colorsUsed: Map<string, Set<PropertyReportItem['index']>>
-}
-
-interface ReportDerivedMapsJSON {
-  byComponentOfKind: Record<ComponentKind, Array<ComponentReportItem['componentIndex']>>
-  byPropertyName: Record<string, Array<PropertyReportItem['index']>>
-  byTokenType: Record<string, Array<PropertyReportItem['index']>>
-  byConditionName: Record<string, Array<PropertyReportItem['index']>>
-  byShorthand: Record<string, Array<PropertyReportItem['index']>>
-  byTokenName: Record<string, Array<PropertyReportItem['index']>>
-  byPropertyPath: Record<string, Array<PropertyReportItem['index']>>
-  fromKind: Record<ComponentKind, Array<PropertyReportItem['index']>>
-  byType: Record<string, Array<PropertyReportItem['index']>>
-  byComponentName: Record<string, Array<PropertyReportItem['index']>>
-  colorsUsed: Record<string, Array<PropertyReportItem['index']>>
-}
-
-export interface ReportCounts {
-  filesWithTokens: number
-  propNameUsed: number
-  tokenUsed: number
-  shorthandUsed: number
-  propertyPathUsed: number
-  typeUsed: number
-  componentNameUsed: number
-  kindUsed: number
-  componentOfKindUsed: number
-  colorsUsed: number
-}
-
-export interface MostUsedItem {
-  key: string
-  count: number
-}
-
-export interface ReportStats {
-  filesWithMostComponent: Record<string, number>
-  mostUseds: {
-    propNames: Array<MostUsedItem>
-    tokens: Array<MostUsedItem>
-    shorthands: Array<MostUsedItem>
-    categories: Array<MostUsedItem>
-    conditions: Array<MostUsedItem>
-    propertyPaths: Array<MostUsedItem>
-    types: Array<MostUsedItem>
-    componentNames: Array<MostUsedItem>
-    fromKinds: Array<MostUsedItem>
-    componentOfKinds: Array<MostUsedItem>
-    colors: Array<MostUsedItem>
-  }
-}
-
-export interface ReportDetails {
-  counts: ReportCounts
-  stats: ReportStats
-}
-
-export interface AnalysisOptions {
-  onResult?: (file: string, result: ParserResultInterface) => void
-}
-
-interface ReportDerivedMap {
-  byFilepath: Map<string, Set<PropertyReportItem['index']>>
-  byComponentInFilepath: Map<string, Set<ComponentReportItem['componentIndex']>>
-  globalMaps: ReportDerivedMaps
-  byFilePathMaps: Map<string, ReportDerivedMaps>
-}
-
-interface ReportDerivedMapJSON {
-  byFilepath: Record<string, Array<PropertyReportItem['index']>>
-  byComponentInFilepath: Record<string, Array<ComponentReportItem['componentIndex']>>
-  globalMaps: ReportDerivedMapsJSON
-  byFilePathMaps: Record<string, ReportDerivedMapsJSON>
-}
-
-export interface AnalysisReport {
-  schemaVersion: string
-  details: ReportDetails
-
-  propByIndex: Map<PropertyReportItem['index'], PropertyReportItem>
-  componentByIndex: Map<ComponentReportItem['componentIndex'], ComponentReportItem>
-
-  derived: ReportDerivedMap
-}
-
-export interface ReportSnapshotJSON extends Omit<AnalysisReport, 'propByIndex' | 'componentByIndex' | 'derived'> {
-  propByIndex: Record<PropertyReportItem['index'], PropertyReportItem>
-  componentByIndex: Record<ComponentReportItem['componentIndex'], ComponentReportItem>
-  derived: ReportDerivedMapJSON
-}
-
-export interface ClassifyReport {
-  propById: Map<string, PropertyReportItem>
-  componentById: Map<ComponentReportItem['componentIndex'], ComponentReportItem>
-  details: Pick<ReportDetails, 'counts' | 'stats'>
-  derived: ReportDerivedMap
-}