@pandacss/types 0.17.1 → 0.17.2

package/dist/hooks.d.ts

@@ -1,44 +0,0 @@
-import type { HookKeys, Hookable } from 'hookable'
-import type { LoadConfigResult, UserConfig } from './config'
-import type { ParserResultType } from './parser'
-
-type MaybeAsyncReturn = Promise<void> | void
-
-export interface PandaHooks {
-  /**
-   * Called when the config is resolved, after all the presets are loaded and merged.
-   */
-  'config:resolved': (conf: LoadConfigResult) => MaybeAsyncReturn
-  /**
-   * Called when the config file or one of its dependencies (imports) has changed.
-   */
-  'config:change': (ctx: UserConfig) => MaybeAsyncReturn
-  /**
-   * Called after reading the file content but before parsing it.
-   */
-  'parser:before': (file: string, content: string) => void
-  /**
-   * Called after the file styles are extracted and processed into the resulting ParserResult object.
-   */
-  'parser:after': (file: string, result: ParserResultType | undefined) => void
-  /**
-   * Called after the extracted ParserResult has been transformed to a CSS string
-   */
-  'parser:css': (file: string, css: string | undefined) => void
-  /**
-   * Called before generating the design-system CSS files (global, static, preflight, tokens, keyframes)
-   */
-  'generator:css': (
-    file: 'global.css' | 'static.css' | 'reset.css' | 'tokens.css' | 'keyframes.css' | 'styles.css',
-    css: string,
-  ) => void
-  /**
-   * Called after the codegen is completed
-   */
-  'generator:done': () => void | Promise<void>
-}
-
-export type PandaHookable = Hookable<PandaHooks, HookKeys<PandaHooks>>
-export interface ConfigResultWithHooks extends LoadConfigResult {
-  hooks: PandaHookable
-}

package/dist/index.d.ts

@@ -1,16 +0,0 @@
-export type * from './analyze-report'
-export type * from './composition'
-export type * from './conditions'
-export type * from './config'
-export type * from './hooks'
-export type * from './parser'
-export type * from './parts'
-export type * from './pattern'
-export type * from './recipe'
-export type * from './runtime'
-export type * from './shared'
-export type * from './static-css'
-export type * from './system-types'
-export type * from './theme'
-export type * from './tokens'
-export type * from './utility'

package/dist/parser.d.ts

@@ -1,36 +0,0 @@
-import type { BoxNodeMap, BoxNodeLiteral, Unboxed, BoxNodeArray } from '@pandacss/extractor'
-
-export interface ResultItem {
-  name?: string
-  data: Array<Unboxed['raw']>
-  type?: 'object' | 'cva' | 'sva' | 'pattern' | 'recipe' | 'jsx-factory' | 'jsx-pattern' | 'jsx-recipe' | 'jsx'
-  box: BoxNodeMap | BoxNodeLiteral | BoxNodeArray
-}
-
-export interface ParserResultType {
-  jsx: Set<ResultItem>
-  css: Set<ResultItem>
-  cva: Set<ResultItem>
-  sva: Set<ResultItem>
-  recipe: Map<string, Set<ResultItem>>
-  pattern: Map<string, Set<ResultItem>>
-  filePath: string | undefined
-  set: (name: 'cva' | 'css', result: ResultItem) => void
-  setSva: (result: ResultItem) => void
-  setCva: (result: ResultItem) => void
-  setJsx: (result: ResultItem) => void
-  setRecipe: (name: string, result: ResultItem) => void
-  setPattern: (name: string, result: ResultItem) => void
-  isEmpty: () => boolean
-  setFilePath: (filePath: string) => ParserResultType
-  toArray: () => Array<ResultItem>
-  toJSON: () => {
-    sva: Array<ResultItem>
-    css: Array<ResultItem>
-    cva: Array<ResultItem>
-    recipe: Record<string, ResultItem[]>
-    pattern: Record<string, ResultItem[]>
-    jsx: Array<ResultItem>
-  }
-  merge: (result: ParserResultType) => ParserResultType
-}

package/dist/parts.d.ts

@@ -1,5 +0,0 @@
-export interface Part {
-  selector: string
-}
-
-export type Parts = Record<string, Part>

package/dist/pattern.d.ts

@@ -1,60 +0,0 @@
-import type { CssProperty, SystemStyleObject } from './system-types'
-import type { TokenCategory } from './tokens'
-
-type Primitive = string | number | boolean | null | undefined
-type LiteralUnion<T, K extends Primitive = string> = T | (K & Record<never, never>)
-
-export type PatternProperty =
-  | { type: 'property'; value: CssProperty }
-  | { type: 'enum'; value: string[] }
-  | { type: 'token'; value: TokenCategory; property?: CssProperty }
-  | { type: 'string' | 'boolean' | 'number' }
-
-export interface PatternHelpers {
-  map: (value: any, fn: (value: string) => string | undefined) => any
-}
-
-export type PatternProperties = Record<string, PatternProperty>
-
-type Props<T> = Record<LiteralUnion<keyof T>, any>
-
-export interface PatternConfig<T extends PatternProperties = PatternProperties> {
-  /**
-   * The description of the pattern. This will be used in the JSDoc comment.
-   */
-  description?: string
-  /**
-   * The JSX element rendered by the pattern
-   * @default 'div'
-   */
-  jsxElement?: string
-  /**
-   * The properties of the pattern.
-   */
-  properties?: T
-  /**
-   * The css object this pattern will generate.
-   */
-  transform?: (props: Props<T>, helpers: PatternHelpers) => SystemStyleObject
-  /**
-   * The jsx element name this pattern will generate.
-   */
-  jsxName?: string
-  /**
-   * The jsx elements to track for this pattern. Can be string or Regexp.
-   *
-   * @default capitalize(pattern.name)
-   * @example ['Button', 'Link', /Button$/]
-   */
-  jsx?: Array<string | RegExp>
-  /**
-   * Whether to only generate types for the specified properties.
-   * This will disallow css properties
-   */
-  strict?: boolean
-  /**
-   * @experimental
-   * Disallow certain css properties for this pattern
-   */
-  blocklist?: LiteralUnion<CssProperty>[]
-}

package/dist/prop-type.d.ts

@@ -1,14 +0,0 @@
-import type { ConditionalValue } from './conditions'
-import type { CssProperties } from './system-types'
-
-/* -----------------------------------------------------------------------------
- * Shadowed export (in CLI): DO NOT REMOVE
- * -----------------------------------------------------------------------------*/
-
-export interface PropertyTypes {}
-
-export type PropertyValue<K extends string> = K extends keyof PropertyTypes
-  ? ConditionalValue<PropertyTypes[K]>
-  : K extends keyof CssProperties
-  ? ConditionalValue<CssProperties[K]>
-  : never

package/dist/recipe.d.ts

@@ -1,147 +0,0 @@
-import type { SystemStyleObject, DistributiveOmit } from './system-types'
-
-type Pretty<T> = { [K in keyof T]: T[K] } & {}
-
-type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T
-
-export type RecipeVariantRecord = Record<any, Record<any, SystemStyleObject>>
-
-export type RecipeSelection<T extends RecipeVariantRecord> = keyof any extends keyof T
-  ? {}
-  : {
-      [K in keyof T]?: StringToBoolean<keyof T[K]>
-    }
-
-export type RecipeVariantFn<T extends RecipeVariantRecord> = (props?: RecipeSelection<T>) => string
-
-export type RecipeVariantProps<
-  T extends RecipeVariantFn<RecipeVariantRecord> | SlotRecipeVariantFn<string, SlotRecipeVariantRecord<string>>,
-> = Pretty<Parameters<T>[0]>
-
-type RecipeVariantMap<T extends RecipeVariantRecord> = {
-  [K in keyof T]: Array<keyof T[K]>
-}
-
-/* -----------------------------------------------------------------------------
- * Recipe / Standard
- * -----------------------------------------------------------------------------*/
-
-export interface RecipeRuntimeFn<T extends RecipeVariantRecord> extends RecipeVariantFn<T> {
-  __type: RecipeSelection<T>
-  variantKeys: (keyof T)[]
-  variantMap: RecipeVariantMap<T>
-  raw: (props?: RecipeSelection<T>) => SystemStyleObject
-  config: RecipeConfig<T>
-  splitVariantProps<Props extends RecipeSelection<T>>(
-    props: Props,
-  ): [RecipeSelection<T>, Pretty<DistributiveOmit<Props, keyof T>>]
-}
-
-type OneOrMore<T> = T | Array<T>
-
-export type RecipeCompoundSelection<T> = {
-  [K in keyof T]?: OneOrMore<StringToBoolean<keyof T[K]>>
-}
-
-export type RecipeCompoundVariant<T> = T & {
-  css: SystemStyleObject
-}
-
-export interface RecipeDefinition<T extends RecipeVariantRecord> {
-  /**
-   * The base styles of the recipe.
-   */
-  base?: SystemStyleObject
-  /**
-   * The multi-variant styles of the recipe.
-   */
-  variants?: T
-  /**
-   * The default variants of the recipe.
-   */
-  defaultVariants?: RecipeSelection<T>
-  /**
-   * The styles to apply when a combination of variants is selected.
-   */
-  compoundVariants?: Pretty<RecipeCompoundVariant<RecipeCompoundSelection<T>>>[]
-}
-
-export type RecipeCreatorFn = <T extends RecipeVariantRecord>(config: RecipeDefinition<T>) => RecipeRuntimeFn<T>
-
-interface RecipeConfigMeta {
-  /**
-   * The name of the recipe.
-   */
-  className: string
-  /**
-   * The description of the recipe. This will be used in the JSDoc comment.
-   */
-  description?: string
-  /**
-   * The jsx elements to track for this recipe. Can be string or Regexp.
-   *
-   * @default capitalize(recipe.name)
-   * @example ['Button', 'Link', /Button$/]
-   */
-  jsx?: Array<string | RegExp>
-}
-
-export interface RecipeConfig<T extends RecipeVariantRecord = RecipeVariantRecord>
-  extends RecipeDefinition<T>,
-    RecipeConfigMeta {}
-
-/* -----------------------------------------------------------------------------
- * Recipe / Slot
- * -----------------------------------------------------------------------------*/
-
-type SlotRecord<S extends string, T> = Partial<Record<S, T>>
-
-export type SlotRecipeVariantRecord<S extends string> = Record<any, Record<any, SlotRecord<S, SystemStyleObject>>>
-
-export type SlotRecipeVariantFn<S extends string, T extends RecipeVariantRecord> = (
-  props?: RecipeSelection<T>,
-) => SlotRecord<S, string>
-
-export interface SlotRecipeRuntimeFn<S extends string, T extends SlotRecipeVariantRecord<S>>
-  extends SlotRecipeVariantFn<S, T> {
-  raw: (props?: RecipeSelection<T>) => Record<S, SystemStyleObject>
-  variantKeys: (keyof T)[]
-  variantMap: RecipeVariantMap<T>
-  splitVariantProps<Props extends RecipeSelection<T>>(props: Props): [RecipeSelection<T>, Pretty<Omit<Props, keyof T>>]
-}
-
-export type SlotRecipeCompoundVariant<S extends string, T> = T & {
-  css: SlotRecord<S, SystemStyleObject>
-}
-
-export interface SlotRecipeDefinition<S extends string, T extends SlotRecipeVariantRecord<S>> {
-  /**
-   * The parts/slots of the recipe.
-   */
-  slots: S[] | Readonly<S[]>
-  /**
-   * The base styles of the recipe.
-   */
-  base?: SlotRecord<S, SystemStyleObject>
-  /**
-   * The multi-variant styles of the recipe.
-   */
-  variants?: T
-  /**
-   * The default variants of the recipe.
-   */
-  defaultVariants?: RecipeSelection<T>
-  /**
-   * The styles to apply when a combination of variants is selected.
-   */
-  compoundVariants?: Pretty<SlotRecipeCompoundVariant<S, RecipeCompoundSelection<T>>>[]
-}
-
-export type SlotRecipeCreatorFn = <S extends string, T extends SlotRecipeVariantRecord<S>>(
-  config: SlotRecipeDefinition<S, T>,
-) => SlotRecipeRuntimeFn<S, T>
-
-export type SlotRecipeConfig<
-  S extends string = string,
-  T extends SlotRecipeVariantRecord<S> = SlotRecipeVariantRecord<S>,
-> = SlotRecipeDefinition<S, T> & RecipeConfigMeta

package/dist/runtime.d.ts

@@ -1,41 +0,0 @@
-interface Watcher {
-  on(event: 'add' | 'addDir' | 'change', listener: (path: string) => void): this
-  on(event: 'all', listener: (evt: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', path: string) => void): this
-  close(): Promise<void>
-}
-
-interface InputOptions {
-  include: string[]
-  exclude?: string[]
-  cwd?: string
-}
-
-interface FileSystem {
-  readDirSync(dir: string): string[]
-  existsSync(fileLike: string): boolean
-  glob(opts: InputOptions): string[]
-  readFileSync(filePath: string): string
-  rmDirSync(dirPath: string): void
-  writeFile(file: string, content: string): Promise<void>
-  rmFileSync(file: string): void
-  ensureDirSync(dirPath: string): void
-  writeFileSync(filePath: string, content: string): void
-  watch(options: InputOptions & { poll?: boolean }): Watcher
-}
-
-interface Path {
-  join(...paths: string[]): string
-  dirname(path: string): string
-  extname(path: string): string
-  relative(from: string, to: string): string
-  isAbsolute(path: string): boolean
-  sep: string
-  abs(cwd: string, path: string): string
-}
-
-export interface Runtime {
-  fs: FileSystem
-  path: Path
-  cwd(): string
-  env(name: string): string | undefined
-}

package/dist/selectors.d.ts

@@ -1,58 +0,0 @@
-import type { Pseudos } from './csstype'
-
-type AriaAttributes =
-  | '[aria-disabled]'
-  | '[aria-hidden]'
-  | '[aria-invalid]'
-  | '[aria-readonly]'
-  | '[aria-required]'
-  | '[aria-selected]'
-  | '[aria-checked]'
-  | '[aria-expanded]'
-  | '[aria-pressed]'
-  | `[aria-current=${'page' | 'step' | 'location' | 'date' | 'time'}]`
-  | '[aria-invalid]'
-  | `[aria-sort=${'ascending' | 'descending'}]`
-
-type DataAttributes =
-  | '[data-selected]'
-  | '[data-highlighted]'
-  | '[data-hover]'
-  | '[data-active]'
-  | '[data-checked]'
-  | '[data-disabled]'
-  | '[data-readonly]'
-  | '[data-focus]'
-  | '[data-focus-visible]'
-  | '[data-focus-visible-added]'
-  | '[data-invalid]'
-  | '[data-pressed]'
-  | '[data-expanded]'
-  | '[data-grabbed]'
-  | '[data-dragged]'
-  | '[data-orientation=horizontal]'
-  | '[data-orientation=vertical]'
-  | '[data-in-range]'
-  | '[data-out-of-range]'
-  | '[data-placeholder-shown]'
-  | `[data-part=${string}]`
-  | `[data-attr=${string}]`
-  | `[data-placement=${string}]`
-  | `[data-theme=${string}]`
-  | `[data-size=${string}]`
-  | `[data-state=${string}]`
-  | '[data-empty]'
-  | '[data-loading]'
-  | '[data-loaded]'
-  | '[data-enter]'
-  | '[data-entering]'
-  | '[data-exited]'
-  | '[data-exiting]'
-
-type AttributeSelector = `&${Pseudos | DataAttributes | AriaAttributes}`
-type ParentSelector = `${DataAttributes | AriaAttributes} &`
-
-type AtRuleType = 'media' | 'layer' | 'container' | 'supports' | 'page'
-
-export type AnySelector = `${string}&` | `&${string}` | `@${AtRuleType}${string}`
-export type Selectors = AttributeSelector | ParentSelector

package/dist/shared.d.ts

@@ -1,25 +0,0 @@
-type Primitive = string | number | boolean | null | undefined
-
-export type LiteralUnion<T, K extends Primitive = string> = T | (K & Record<never, never>)
-
-export interface Recursive<T> {
-  [key: string]: T | Recursive<T>
-}
-
-export type Dict<T = any> = Record<string, T>
-
-export type RequiredBy<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>
-
-export type AnyFunction<T = any> = (...args: T[]) => any
-
-type Nullable<T> = T | null | undefined
-
-export interface ArtifactContent {
-  file: string
-  code: string | undefined
-}
-
-export type Artifact = Nullable<{
-  dir?: string[]
-  files: ArtifactContent[]
-}>

package/dist/static-css.d.ts

@@ -1,38 +0,0 @@
-interface CssRule {
-  /**
-   * The css properties to generate utilities for.
-   * @example ['margin', 'padding']
-   */
-  properties: {
-    [property: string]: string[]
-  }
-  /**
-   * The css conditions to generate utilities for.
-   * @example ['hover', 'focus']
-   */
-  conditions?: string[]
-  /**
-   * Whether to generate responsive utilities.
-   */
-  responsive?: boolean
-}
-
-type RecipeRule =
-  | '*'
-  | ({
-      conditions?: string[]
-      responsive?: boolean
-    } & { [variant: string]: boolean | string[] })
-
-export interface StaticCssOptions {
-  /**
-   * The css utility classes to generate.
-   */
-  css?: CssRule[]
-  /**
-   * The css recipes to generate.
-   */
-  recipes?: {
-    [recipe: string]: RecipeRule[]
-  }
-}

package/dist/style-props.d.ts

@@ -1,20 +0,0 @@
-import type { ConditionalValue } from './conditions'
-import type { PropertiesFallback } from './csstype'
-import type { PropertyValue } from './prop-type'
-
-type String = string & {}
-type Number = number & {}
-
-/* -----------------------------------------------------------------------------
- * Shadowed export (in CLI): DO NOT REMOVE
- * -----------------------------------------------------------------------------*/
-
-type CssProperties = PropertiesFallback<String | Number>
-
-export type CssVarProperties = {
-  [key in `--${string}`]?: ConditionalValue<string | number>
-}
-
-export type SystemProperties = {
-  [K in keyof CssProperties]?: PropertyValue<K>
-}

package/dist/system-types.d.ts

@@ -1,90 +0,0 @@
-import type { ConditionalValue, Conditions, Nested } from './conditions'
-import type { PropertiesFallback } from './csstype'
-import type { SystemProperties, CssVarProperties } from './style-props'
-
-type String = string & {}
-type Number = number & {}
-
-export type Pretty<T> = { [K in keyof T]: T[K] } & {}
-
-export type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never
-
-export type DistributiveUnion<T, U> = {
-  [K in keyof T]: K extends keyof U ? U[K] | T[K] : T[K]
-} & DistributiveOmit<U, keyof T>
-
-export type Assign<T, U> = {
-  [K in keyof T]: K extends keyof U ? U[K] : T[K]
-} & U
-
-/* -----------------------------------------------------------------------------
- * Native css properties
- * -----------------------------------------------------------------------------*/
-
-export type CssProperty = keyof PropertiesFallback
-
-export interface CssProperties extends PropertiesFallback<String | Number>, CssVarProperties {}
-
-export interface CssKeyframes {
-  [name: string]: {
-    [time: string]: CssProperties
-  }
-}
-
-/* -----------------------------------------------------------------------------
- * Conditional css properties
- * -----------------------------------------------------------------------------*/
-
-type MinimalNested<P> = {
-  [K in keyof Conditions]?: Nested<P>
-}
-
-interface GenericProperties {
-  [key: string]: ConditionalValue<String | Number | boolean>
-}
-
-/* -----------------------------------------------------------------------------
- * Native css props
- * -----------------------------------------------------------------------------*/
-
-export type NestedCssProperties = Nested<CssProperties>
-
-export type SystemStyleObject = Nested<(SystemProperties | GenericProperties) & CssVarProperties>
-
-export interface GlobalStyleObject {
-  [selector: string]: SystemStyleObject
-}
-export interface ExtendableGlobalStyleObject {
-  [selector: string]: SystemStyleObject | undefined
-  extend?: GlobalStyleObject | undefined
-}
-
-export type CompositionStyleObject<Property extends string> = Nested<{
-  [K in Property]?: K extends keyof SystemStyleObject ? SystemStyleObject[K] : unknown
-}>
-
-/* -----------------------------------------------------------------------------
- * Jsx style props
- * -----------------------------------------------------------------------------*/
-interface WithCss {
-  css?: SystemStyleObject
-}
-type StyleProps = SystemProperties & MinimalNested<SystemStyleObject>
-
-export type JsxStyleProps = StyleProps & WithCss
-
-export interface PatchedHTMLProps {
-  htmlWidth?: string | number
-  htmlHeight?: string | number
-  htmlTranslate?: 'yes' | 'no' | undefined
-  htmlContent?: string
-}
-
-export type OmittedHTMLProps = 'color' | 'translate' | 'transition' | 'width' | 'height' | 'content'
-
-type WithHTMLProps<T> = DistributiveOmit<T, OmittedHTMLProps> & PatchedHTMLProps
-
-export type JsxHTMLProps<T extends Record<string, any>, P extends Record<string, any> = {}> = Assign<
-  WithHTMLProps<T>,
-  P
->

package/dist/theme.d.ts

@@ -1,56 +0,0 @@
-import type { LayerStyles, TextStyles } from './composition'
-import type { RecipeConfig, SlotRecipeConfig } from './recipe'
-import type { CssKeyframes } from './system-types'
-import type { SemanticTokens, Tokens } from './tokens'
-
-export interface Theme {
-  /**
-   * The breakpoints for your project.
-   */
-  breakpoints?: Record<string, string>
-  /**
-   * The css animation keyframes definitions.
-   */
-  keyframes?: CssKeyframes
-  /**
-   * The design tokens for your project.
-   */
-  tokens?: Tokens
-  /**
-   * The semantic design tokens for your project.
-   */
-  semanticTokens?: SemanticTokens
-  /**
-   * The typography styles for your project.
-   */
-  textStyles?: TextStyles
-  /**
-   * The layer styles for your project.
-   */
-  layerStyles?: LayerStyles
-  /**
-   * Multi-variant style definitions for your project.
-   * Useful for defining component styles.
-   */
-  recipes?: Record<string, RecipeConfig>
-  /**
-   * Multi-variant style definitions for component slots.
-   */
-  slotRecipes?: Record<string, SlotRecipeConfig>
-}
-
-interface PartialTheme extends Omit<Theme, 'recipes' | 'slotRecipes'> {
-  /**
-   * Multi-variant style definitions for your project.
-   * Useful for defining component styles.
-   */
-  recipes?: Record<string, Partial<RecipeConfig>>
-  /**
-   * Multi-variant style definitions for component slots.
-   */
-  slotRecipes?: Record<string, Partial<SlotRecipeConfig>>
-}
-
-export interface ExtendableTheme extends Theme {
-  extend?: PartialTheme | undefined
-}