aeon-ui-engine 1.5.1 → 1.9.0

package/packages/panda/styled-system/patterns/grid.js

@@ -0,0 +1,30 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const gridConfig = {
+  transform(props, { map, isCssUnit }) {
+    const { columnGap, rowGap, gap, columns, minChildWidth, ...rest } = props;
+    const getValue = (v) => isCssUnit(v) ? v : `token(sizes.${v}, ${v})`;
+    return {
+      display: "grid",
+      gridTemplateColumns: columns != null ? map(columns, (v) => `repeat(${v}, minmax(0, 1fr))`) : minChildWidth != null ? map(minChildWidth, (v) => `repeat(auto-fit, minmax(${getValue(v)}, 1fr))`) : void 0,
+      gap,
+      columnGap,
+      rowGap,
+      ...rest
+    };
+  },
+  defaultValues(props) {
+    return { gap: props.columnGap || props.rowGap ? void 0 : "8px" };
+  }
+}
+
+export function gridRaw(styles) {
+  const s = getPatternStyles(gridConfig, styles || {})
+  return gridConfig.transform(s, patternFns)
+}
+
+export const grid = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function grid(styles = {}) {
+  return css(gridRaw(styles))
+}), { raw: gridRaw, propKeys: ["columnGap","columns","gap","minChildWidth","rowGap"] })

package/packages/panda/styled-system/patterns/hstack.d.ts

@@ -1,21 +1,20 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemProperties, SystemStyleObject } from '../types/system';
 
 export interface HstackProperties {
-   justify?: SystemProperties["justifyContent"]
-	gap?: SystemProperties["gap"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
 }
 
-interface HstackStyles extends HstackProperties, DistributiveOmit<SystemStyleObject, keyof HstackProperties > {}
+type HstackRestStyles = Omit<SystemStyleObject, keyof HstackProperties>
+
+interface HstackStyles extends HstackProperties, HstackRestStyles {}
 
 interface HstackPatternFn {
   (styles?: HstackStyles): string
   raw: (styles?: HstackStyles) => SystemStyleObject
+  propKeys: Array<keyof HstackProperties>
 }
 
+export declare function hstackRaw(styles?: HstackStyles): SystemStyleObject;
 
-export declare const hstack: HstackPatternFn;
+export declare const hstack: HstackPatternFn;

package/packages/panda/styled-system/patterns/hstack.js

@@ -0,0 +1,27 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const hstackConfig = {
+  transform(props) {
+    const { justify, gap, ...rest } = props;
+    return {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: justify,
+      gap,
+      flexDirection: "row",
+      ...rest
+    };
+  },
+  defaultValues: { gap: "8px" }
+}
+
+export function hstackRaw(styles) {
+  const s = getPatternStyles(hstackConfig, styles || {})
+  return hstackConfig.transform(s, patternFns)
+}
+
+export const hstack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function hstack(styles = {}) {
+  return css(hstackRaw(styles))
+}), { raw: hstackRaw, propKeys: ["gap","justify"] })

package/packages/panda/styled-system/patterns/index.d.ts

@@ -1,21 +1,20 @@
-/* eslint-disable */
+export * from './aspect-ratio';
+export * from './bleed';
 export * from './box';
-export * from './flex';
-export * from './stack';
-export * from './vstack';
-export * from './hstack';
-export * from './spacer';
-export * from './square';
-export * from './circle';
 export * from './center';
-export * from './link-overlay';
-export * from './aspect-ratio';
-export * from './grid';
-export * from './grid-item';
-export * from './wrap';
+export * from './circle';
 export * from './container';
+export * from './cq';
 export * from './divider';
+export * from './flex';
 export * from './float';
-export * from './bleed';
+export * from './grid';
+export * from './grid-item';
+export * from './hstack';
+export * from './link-overlay';
+export * from './spacer';
+export * from './square';
+export * from './stack';
 export * from './visually-hidden';
-export * from './cq';
+export * from './vstack';
+export * from './wrap';

package/packages/panda/styled-system/patterns/index.js

@@ -0,0 +1,20 @@
+export * from './aspect-ratio';
+export * from './bleed';
+export * from './box';
+export * from './center';
+export * from './circle';
+export * from './container';
+export * from './cq';
+export * from './divider';
+export * from './flex';
+export * from './float';
+export * from './grid';
+export * from './grid-item';
+export * from './hstack';
+export * from './link-overlay';
+export * from './spacer';
+export * from './square';
+export * from './stack';
+export * from './visually-hidden';
+export * from './vstack';
+export * from './wrap';

package/packages/panda/styled-system/patterns/link-overlay.d.ts

@@ -1,20 +1,17 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemStyleObject } from '../types/system';
 
-export interface LinkOverlayProperties {
-   
-}
+export interface LinkOverlayProperties {}
+
+type LinkOverlayRestStyles = Omit<SystemStyleObject, keyof LinkOverlayProperties>
 
-interface LinkOverlayStyles extends LinkOverlayProperties, DistributiveOmit<SystemStyleObject, keyof LinkOverlayProperties > {}
+interface LinkOverlayStyles extends LinkOverlayProperties, LinkOverlayRestStyles {}
 
 interface LinkOverlayPatternFn {
   (styles?: LinkOverlayStyles): string
   raw: (styles?: LinkOverlayStyles) => SystemStyleObject
+  propKeys: Array<keyof LinkOverlayProperties>
 }
 
+export declare function linkOverlayRaw(styles?: LinkOverlayStyles): SystemStyleObject;
 
-export declare const linkOverlay: LinkOverlayPatternFn;
+export declare const linkOverlay: LinkOverlayPatternFn;

package/packages/panda/styled-system/patterns/link-overlay.js

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const linkOverlayConfig = { transform(props) {
+  return {
+    _before: {
+      content: "\"\"",
+      position: "absolute",
+      inset: "0",
+      zIndex: "0",
+      ...props["_before"]
+    },
+    ...props
+  };
+} }
+
+export function linkOverlayRaw(styles) {
+  const s = getPatternStyles(linkOverlayConfig, styles || {})
+  return linkOverlayConfig.transform(s, patternFns)
+}
+
+export const linkOverlay = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function linkOverlay(styles = {}) {
+  return css(linkOverlayRaw(styles))
+}), { raw: linkOverlayRaw, propKeys: [] })

package/packages/panda/styled-system/patterns/runtime.js

@@ -0,0 +1,25 @@
+import { mapObject, withDefaults } from '../helpers';
+
+const CSS_FUNCTION_REGEX = /^(min|max|clamp|calc)\(.*\)/
+const CSS_VAR_REGEX = /^var\(--.+\)$/
+const CSS_UNIT_REGEX = /^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?(?:cm|mm|Q|in|pc|pt|px|em|ex|ch|rem|lh|rlh|vw|vh|vmin|vmax|vb|vi|svw|svh|lvw|lvh|dvw|dvh|cqw|cqh|cqi|cqb|cqmin|cqmax|%)$/
+
+export function isCssFunction(v) {
+  return typeof v === "string" && CSS_FUNCTION_REGEX.test(v)
+}
+
+export function isCssVar(v) {
+  return typeof v === "string" && CSS_VAR_REGEX.test(v)
+}
+
+export function isCssUnit(v) {
+  return typeof v === "string" && CSS_UNIT_REGEX.test(v)
+}
+
+export const patternFns = { map: mapObject, isCssFunction, isCssVar, isCssUnit }
+
+export function getPatternStyles(pattern, styles) {
+  if (!pattern?.defaultValues) return styles
+  const defaults = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues
+  return withDefaults(defaults, styles)
+}

package/packages/panda/styled-system/patterns/spacer.d.ts

@@ -1,20 +1,20 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { TokenValue } from '../types/tokens';
+import type { ConditionalValue, SystemStyleObject } from '../types/system';
 
 export interface SpacerProperties {
-   size?: ConditionalValue<Tokens["spacing"]>
+  size?: ConditionalValue<TokenValue<"spacing">>
 }
 
-interface SpacerStyles extends SpacerProperties, DistributiveOmit<SystemStyleObject, keyof SpacerProperties > {}
+type SpacerRestStyles = Omit<SystemStyleObject, keyof SpacerProperties>
+
+interface SpacerStyles extends SpacerProperties, SpacerRestStyles {}
 
 interface SpacerPatternFn {
   (styles?: SpacerStyles): string
   raw: (styles?: SpacerStyles) => SystemStyleObject
+  propKeys: Array<keyof SpacerProperties>
 }
 
+export declare function spacerRaw(styles?: SpacerStyles): SystemStyleObject;
 
-export declare const spacer: SpacerPatternFn;
+export declare const spacer: SpacerPatternFn;

package/packages/panda/styled-system/patterns/spacer.js

@@ -0,0 +1,26 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const spacerConfig = { transform(props, { map, isCssUnit, isCssVar }) {
+  const { size, ...rest } = props;
+  return {
+    alignSelf: "stretch",
+    justifySelf: "stretch",
+    flex: map(size, (v) => {
+      if (v == null) return "1";
+      const val = isCssUnit(v) || isCssVar(v) ? v : `token(spacing.${v}, ${v})`;
+      return `0 0 ${val}`;
+    }),
+    ...rest
+  };
+} }
+
+export function spacerRaw(styles) {
+  const s = getPatternStyles(spacerConfig, styles || {})
+  return spacerConfig.transform(s, patternFns)
+}
+
+export const spacer = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function spacer(styles = {}) {
+  return css(spacerRaw(styles))
+}), { raw: spacerRaw, propKeys: ["size"] })

package/packages/panda/styled-system/patterns/square.d.ts

@@ -1,20 +1,19 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemProperties, SystemStyleObject } from '../types/system';
 
 export interface SquareProperties {
-   size?: SystemProperties["width"]
+  size?: SystemProperties["width"]
 }
 
-interface SquareStyles extends SquareProperties, DistributiveOmit<SystemStyleObject, keyof SquareProperties > {}
+type SquareRestStyles = Omit<SystemStyleObject, keyof SquareProperties>
+
+interface SquareStyles extends SquareProperties, SquareRestStyles {}
 
 interface SquarePatternFn {
   (styles?: SquareStyles): string
   raw: (styles?: SquareStyles) => SystemStyleObject
+  propKeys: Array<keyof SquareProperties>
 }
 
+export declare function squareRaw(styles?: SquareStyles): SystemStyleObject;
 
-export declare const square: SquarePatternFn;
+export declare const square: SquarePatternFn;

package/packages/panda/styled-system/patterns/square.js

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const squareConfig = { transform(props) {
+  const { size, ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    flex: "0 0 auto",
+    width: size,
+    height: size,
+    ...rest
+  };
+} }
+
+export function squareRaw(styles) {
+  const s = getPatternStyles(squareConfig, styles || {})
+  return squareConfig.transform(s, patternFns)
+}
+
+export const square = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function square(styles = {}) {
+  return css(squareRaw(styles))
+}), { raw: squareRaw, propKeys: ["size"] })

package/packages/panda/styled-system/patterns/stack.d.ts

@@ -1,23 +1,22 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemProperties, SystemStyleObject } from '../types/system';
 
 export interface StackProperties {
-   align?: SystemProperties["alignItems"]
-	justify?: SystemProperties["justifyContent"]
-	direction?: SystemProperties["flexDirection"]
-	gap?: SystemProperties["gap"]
+  align?: SystemProperties["alignItems"]
+  direction?: SystemProperties["flexDirection"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
 }
 
-interface StackStyles extends StackProperties, DistributiveOmit<SystemStyleObject, keyof StackProperties > {}
+type StackRestStyles = Omit<SystemStyleObject, keyof StackProperties>
+
+interface StackStyles extends StackProperties, StackRestStyles {}
 
 interface StackPatternFn {
   (styles?: StackStyles): string
   raw: (styles?: StackStyles) => SystemStyleObject
+  propKeys: Array<keyof StackProperties>
 }
 
+export declare function stackRaw(styles?: StackStyles): SystemStyleObject;
 
-export declare const stack: StackPatternFn;
+export declare const stack: StackPatternFn;

package/packages/panda/styled-system/patterns/stack.js

@@ -0,0 +1,30 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const stackConfig = {
+  transform(props) {
+    const { align, justify, direction, gap, ...rest } = props;
+    return {
+      display: "flex",
+      flexDirection: direction,
+      alignItems: align,
+      justifyContent: justify,
+      gap,
+      ...rest
+    };
+  },
+  defaultValues: {
+    direction: "column",
+    gap: "8px"
+  }
+}
+
+export function stackRaw(styles) {
+  const s = getPatternStyles(stackConfig, styles || {})
+  return stackConfig.transform(s, patternFns)
+}
+
+export const stack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function stack(styles = {}) {
+  return css(stackRaw(styles))
+}), { raw: stackRaw, propKeys: ["align","direction","gap","justify"] })

package/packages/panda/styled-system/patterns/visually-hidden.d.ts

@@ -1,20 +1,17 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemStyleObject } from '../types/system';
 
-export interface VisuallyHiddenProperties {
-   
-}
+export interface VisuallyHiddenProperties {}
+
+type VisuallyHiddenRestStyles = Omit<SystemStyleObject, keyof VisuallyHiddenProperties>
 
-interface VisuallyHiddenStyles extends VisuallyHiddenProperties, DistributiveOmit<SystemStyleObject, keyof VisuallyHiddenProperties > {}
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, VisuallyHiddenRestStyles {}
 
 interface VisuallyHiddenPatternFn {
   (styles?: VisuallyHiddenStyles): string
   raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+  propKeys: Array<keyof VisuallyHiddenProperties>
 }
 
+export declare function visuallyHiddenRaw(styles?: VisuallyHiddenStyles): SystemStyleObject;
 
-export declare const visuallyHidden: VisuallyHiddenPatternFn;
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

package/packages/panda/styled-system/patterns/visually-hidden.js

@@ -0,0 +1,19 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const visuallyHiddenConfig = { transform(props) {
+  return {
+    srOnly: true,
+    ...props
+  };
+} }
+
+export function visuallyHiddenRaw(styles) {
+  const s = getPatternStyles(visuallyHiddenConfig, styles || {})
+  return visuallyHiddenConfig.transform(s, patternFns)
+}
+
+export const visuallyHidden = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function visuallyHidden(styles = {}) {
+  return css(visuallyHiddenRaw(styles))
+}), { raw: visuallyHiddenRaw, propKeys: [] })

package/packages/panda/styled-system/patterns/vstack.d.ts

@@ -1,21 +1,20 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemProperties, SystemStyleObject } from '../types/system';
 
 export interface VstackProperties {
-   justify?: SystemProperties["justifyContent"]
-	gap?: SystemProperties["gap"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
 }
 
-interface VstackStyles extends VstackProperties, DistributiveOmit<SystemStyleObject, keyof VstackProperties > {}
+type VstackRestStyles = Omit<SystemStyleObject, keyof VstackProperties>
+
+interface VstackStyles extends VstackProperties, VstackRestStyles {}
 
 interface VstackPatternFn {
   (styles?: VstackStyles): string
   raw: (styles?: VstackStyles) => SystemStyleObject
+  propKeys: Array<keyof VstackProperties>
 }
 
+export declare function vstackRaw(styles?: VstackStyles): SystemStyleObject;
 
-export declare const vstack: VstackPatternFn;
+export declare const vstack: VstackPatternFn;

package/packages/panda/styled-system/patterns/vstack.js

@@ -0,0 +1,27 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const vstackConfig = {
+  transform(props) {
+    const { justify, gap, ...rest } = props;
+    return {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: justify,
+      gap,
+      flexDirection: "column",
+      ...rest
+    };
+  },
+  defaultValues: { gap: "8px" }
+}
+
+export function vstackRaw(styles) {
+  const s = getPatternStyles(vstackConfig, styles || {})
+  return vstackConfig.transform(s, patternFns)
+}
+
+export const vstack = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function vstack(styles = {}) {
+  return css(vstackRaw(styles))
+}), { raw: vstackRaw, propKeys: ["gap","justify"] })

package/packages/panda/styled-system/patterns/wrap.d.ts

@@ -1,24 +1,23 @@
-/* eslint-disable */
-import type { SystemStyleObject, ConditionalValue } from '../types/index';
-import type { Properties } from '../types/csstype';
-import type { SystemProperties } from '../types/style-props';
-import type { DistributiveOmit } from '../types/system-types';
-import type { Tokens } from '../tokens/index';
+import type { SystemProperties, SystemStyleObject } from '../types/system';
 
 export interface WrapProperties {
-   gap?: SystemProperties["gap"]
-	rowGap?: SystemProperties["gap"]
-	columnGap?: SystemProperties["gap"]
-	align?: SystemProperties["alignItems"]
-	justify?: SystemProperties["justifyContent"]
+  align?: SystemProperties["alignItems"]
+  columnGap?: SystemProperties["gap"]
+  gap?: SystemProperties["gap"]
+  justify?: SystemProperties["justifyContent"]
+  rowGap?: SystemProperties["gap"]
 }
 
-interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+type WrapRestStyles = Omit<SystemStyleObject, keyof WrapProperties>
+
+interface WrapStyles extends WrapProperties, WrapRestStyles {}
 
 interface WrapPatternFn {
   (styles?: WrapStyles): string
   raw: (styles?: WrapStyles) => SystemStyleObject
+  propKeys: Array<keyof WrapProperties>
 }
 
+export declare function wrapRaw(styles?: WrapStyles): SystemStyleObject;
 
-export declare const wrap: WrapPatternFn;
+export declare const wrap: WrapPatternFn;

package/packages/panda/styled-system/patterns/wrap.js

@@ -0,0 +1,26 @@
+import { getPatternStyles, patternFns } from './runtime';
+import { memo } from '../helpers';
+import { css } from '../css/index';
+
+const wrapConfig = { transform(props) {
+  const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "8px", align, justify, ...rest } = props;
+  return {
+    display: "flex",
+    flexWrap: "wrap",
+    alignItems: align,
+    justifyContent: justify,
+    gap,
+    columnGap,
+    rowGap,
+    ...rest
+  };
+} }
+
+export function wrapRaw(styles) {
+  const s = getPatternStyles(wrapConfig, styles || {})
+  return wrapConfig.transform(s, patternFns)
+}
+
+export const wrap = /* @__PURE__ */ Object.assign(/* @__PURE__ */ memo(function wrap(styles = {}) {
+  return css(wrapRaw(styles))
+}), { raw: wrapRaw, propKeys: ["align","columnGap","gap","justify","rowGap"] })

package/packages/panda/styled-system/recipes/aeon-accordion.d.ts

@@ -1,33 +1,16 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
+import type { ConditionalValue } from '../types/system';
+import type { SlotRecipeRuntimeFn, RecipeVariantMap } from '../types/recipe';
 
-interface AeonAccordionVariant {
-  
-}
+export type AeonAccordionVariant = {}
 
-type AeonAccordionVariantMap = {
-  [key in keyof AeonAccordionVariant]: Array<AeonAccordionVariant[key]>
+export type AeonAccordionVariantProps = {
+  [K in keyof AeonAccordionVariant]?: ConditionalValue<AeonAccordionVariant[K]>
 }
 
-type AeonAccordionSlot = "root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator"
+export type AeonAccordionVariantMap = RecipeVariantMap<AeonAccordionVariant>
 
-export type AeonAccordionVariantProps = {
-  [key in keyof AeonAccordionVariant]?: ConditionalValue<AeonAccordionVariant[key]> | undefined
-}
+export type AeonAccordionSlot = "root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator"
 
-export interface AeonAccordionRecipe {
-  __slot: AeonAccordionSlot
-  __type: AeonAccordionVariantProps
-  (props?: AeonAccordionVariantProps): Pretty<Record<AeonAccordionSlot, string>>
-  raw: (props?: AeonAccordionVariantProps) => AeonAccordionVariantProps
-  variantMap: AeonAccordionVariantMap
-  variantKeys: Array<keyof AeonAccordionVariant>
-  splitVariantProps<Props extends AeonAccordionVariantProps>(props: Props): [AeonAccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AeonAccordionVariantProps>>]
-  getVariantProps: (props?: AeonAccordionVariantProps) => AeonAccordionVariantProps
-}
+export type AeonAccordionRecipe = SlotRecipeRuntimeFn<AeonAccordionSlot, AeonAccordionVariantProps, AeonAccordionVariantMap>
 
-/**
- * Aeon accordion — content stacks with gap (no stacked padding + margins)
- */
-export declare const aeonAccordion: AeonAccordionRecipe
+export declare const aeonAccordion: AeonAccordionRecipe;

package/packages/panda/styled-system/recipes/aeon-accordion.js

@@ -0,0 +1,5 @@
+import { createSlotRecipe } from './runtime';
+
+const aeonAccordionConfig = {"name":"aeonAccordion","slots":["root","item","itemTrigger","itemContent","itemIndicator"]}
+
+export const aeonAccordion = /* @__PURE__ */ createSlotRecipe(aeonAccordionConfig)