aeon-ui-engine 1.0.0

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

@@ -0,0 +1,21 @@
+/* eslint-disable */
+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 './container';
+export * from './divider';
+export * from './float';
+export * from './bleed';
+export * from './visually-hidden';
+export * from './cq';

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

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

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

@@ -0,0 +1,21 @@
+/* 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';
+
+export interface LinkOverlayProperties {
+   
+}
+
+
+interface LinkOverlayStyles extends LinkOverlayProperties, DistributiveOmit<SystemStyleObject, keyof LinkOverlayProperties > {}
+
+interface LinkOverlayPatternFn {
+  (styles?: LinkOverlayStyles): string
+  raw: (styles?: LinkOverlayStyles) => SystemStyleObject
+}
+
+
+export declare const linkOverlay: LinkOverlayPatternFn;

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

@@ -0,0 +1,24 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const linkOverlayConfig = {
+transform(props) {
+  return {
+    _before: {
+      content: '""',
+      position: "absolute",
+      inset: "0",
+      zIndex: "0",
+      ...props["_before"]
+    },
+    ...props
+  };
+}}
+
+export const getLinkOverlayStyle = (styles = {}) => {
+  const _styles = getPatternStyles(linkOverlayConfig, styles)
+  return linkOverlayConfig.transform(_styles, patternFns)
+}
+
+export const linkOverlay = (styles) => css(getLinkOverlayStyle(styles))
+linkOverlay.raw = getLinkOverlayStyle

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

@@ -0,0 +1,21 @@
+/* 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';
+
+export interface SpacerProperties {
+   size?: ConditionalValue<Tokens["spacing"]>
+}
+
+
+interface SpacerStyles extends SpacerProperties, DistributiveOmit<SystemStyleObject, keyof SpacerProperties > {}
+
+interface SpacerPatternFn {
+  (styles?: SpacerStyles): string
+  raw: (styles?: SpacerStyles) => SystemStyleObject
+}
+
+
+export declare const spacer: SpacerPatternFn;

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

@@ -0,0 +1,21 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const spacerConfig = {
+transform(props, { map }) {
+  const { size, ...rest } = props;
+  return {
+    alignSelf: "stretch",
+    justifySelf: "stretch",
+    flex: map(size, (v) => v == null ? "1" : `0 0 ${v}`),
+    ...rest
+  };
+}}
+
+export const getSpacerStyle = (styles = {}) => {
+  const _styles = getPatternStyles(spacerConfig, styles)
+  return spacerConfig.transform(_styles, patternFns)
+}
+
+export const spacer = (styles) => css(getSpacerStyle(styles))
+spacer.raw = getSpacerStyle

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

@@ -0,0 +1,21 @@
+/* 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';
+
+export interface SquareProperties {
+   size?: SystemProperties["width"]
+}
+
+
+interface SquareStyles extends SquareProperties, DistributiveOmit<SystemStyleObject, keyof SquareProperties > {}
+
+interface SquarePatternFn {
+  (styles?: SquareStyles): string
+  raw: (styles?: SquareStyles) => SystemStyleObject
+}
+
+
+export declare const square: SquarePatternFn;

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

@@ -0,0 +1,24 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+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 const getSquareStyle = (styles = {}) => {
+  const _styles = getPatternStyles(squareConfig, styles)
+  return squareConfig.transform(_styles, patternFns)
+}
+
+export const square = (styles) => css(getSquareStyle(styles))
+square.raw = getSquareStyle

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

@@ -0,0 +1,24 @@
+/* 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';
+
+export interface StackProperties {
+   align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+	direction?: SystemProperties["flexDirection"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface StackStyles extends StackProperties, DistributiveOmit<SystemStyleObject, keyof StackProperties > {}
+
+interface StackPatternFn {
+  (styles?: StackStyles): string
+  raw: (styles?: StackStyles) => SystemStyleObject
+}
+
+
+export declare const stack: StackPatternFn;

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

@@ -0,0 +1,24 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+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:'10px'}}
+
+export const getStackStyle = (styles = {}) => {
+  const _styles = getPatternStyles(stackConfig, styles)
+  return stackConfig.transform(_styles, patternFns)
+}
+
+export const stack = (styles) => css(getStackStyle(styles))
+stack.raw = getStackStyle

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

@@ -0,0 +1,21 @@
+/* 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';
+
+export interface VisuallyHiddenProperties {
+   
+}
+
+
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, DistributiveOmit<SystemStyleObject, keyof VisuallyHiddenProperties > {}
+
+interface VisuallyHiddenPatternFn {
+  (styles?: VisuallyHiddenStyles): string
+  raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+}
+
+
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

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

@@ -0,0 +1,18 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const visuallyHiddenConfig = {
+transform(props) {
+  return {
+    srOnly: true,
+    ...props
+  };
+}}
+
+export const getVisuallyHiddenStyle = (styles = {}) => {
+  const _styles = getPatternStyles(visuallyHiddenConfig, styles)
+  return visuallyHiddenConfig.transform(_styles, patternFns)
+}
+
+export const visuallyHidden = (styles) => css(getVisuallyHiddenStyle(styles))
+visuallyHidden.raw = getVisuallyHiddenStyle

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

@@ -0,0 +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';
+
+export interface VstackProperties {
+   justify?: SystemProperties["justifyContent"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface VstackStyles extends VstackProperties, DistributiveOmit<SystemStyleObject, keyof VstackProperties > {}
+
+interface VstackPatternFn {
+  (styles?: VstackStyles): string
+  raw: (styles?: VstackStyles) => SystemStyleObject
+}
+
+
+export declare const vstack: VstackPatternFn;

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

@@ -0,0 +1,24 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const vstackConfig = {
+transform(props) {
+  const { justify, gap, ...rest } = props;
+  return {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: justify,
+    gap,
+    flexDirection: "column",
+    ...rest
+  };
+},
+defaultValues:{gap:'10px'}}
+
+export const getVstackStyle = (styles = {}) => {
+  const _styles = getPatternStyles(vstackConfig, styles)
+  return vstackConfig.transform(_styles, patternFns)
+}
+
+export const vstack = (styles) => css(getVstackStyle(styles))
+vstack.raw = getVstackStyle

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

@@ -0,0 +1,25 @@
+/* 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';
+
+export interface WrapProperties {
+   gap?: SystemProperties["gap"]
+	rowGap?: SystemProperties["gap"]
+	columnGap?: SystemProperties["gap"]
+	align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+}
+
+
+interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+}
+
+
+export declare const wrap: WrapPatternFn;

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

@@ -0,0 +1,25 @@
+import { getPatternStyles, patternFns } from '../helpers.mjs';
+import { css } from '../css/index.mjs';
+
+const wrapConfig = {
+transform(props) {
+  const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "10px", align, justify, ...rest } = props;
+  return {
+    display: "flex",
+    flexWrap: "wrap",
+    alignItems: align,
+    justifyContent: justify,
+    gap,
+    columnGap,
+    rowGap,
+    ...rest
+  };
+}}
+
+export const getWrapStyle = (styles = {}) => {
+  const _styles = getPatternStyles(wrapConfig, styles)
+  return wrapConfig.transform(_styles, patternFns)
+}
+
+export const wrap = (styles) => css(getWrapStyle(styles))
+wrap.raw = getWrapStyle

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

@@ -0,0 +1,32 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonAccordionVariant {
+  
+}
+
+type AeonAccordionVariantMap = {
+  [key in keyof AeonAccordionVariant]: Array<AeonAccordionVariant[key]>
+}
+
+export type AeonAccordionVariantProps = {
+  [key in keyof AeonAccordionVariant]?: ConditionalValue<AeonAccordionVariant[key]> | undefined
+}
+
+export interface AeonAccordionRecipe {
+  __type: AeonAccordionVariantProps
+  (props?: AeonAccordionVariantProps): Pretty<Record<"root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator", 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
+}
+
+/**
+ * Aeon accordion — content stacks with gap (no stacked padding + margins)
+
+
+ */
+export declare const aeonAccordion: AeonAccordionRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonAccordionDefaultVariants = {}
+const aeonAccordionCompoundVariants = []
+
+const aeonAccordionSlotNames = [
+  [
+    "root",
+    "aeonAccordion__root"
+  ],
+  [
+    "item",
+    "aeonAccordion__item"
+  ],
+  [
+    "itemTrigger",
+    "aeonAccordion__itemTrigger"
+  ],
+  [
+    "itemContent",
+    "aeonAccordion__itemContent"
+  ],
+  [
+    "itemIndicator",
+    "aeonAccordion__itemIndicator"
+  ]
+]
+const aeonAccordionSlotFns = /* @__PURE__ */ aeonAccordionSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonAccordionDefaultVariants, getSlotCompoundVariant(aeonAccordionCompoundVariants, slotName))])
+
+const aeonAccordionFn = memo((props = {}) => {
+  return Object.fromEntries(aeonAccordionSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonAccordionVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonAccordionDefaultVariants, ...compact(variants) })
+
+export const aeonAccordion = /* @__PURE__ */ Object.assign(aeonAccordionFn, {
+  __recipe__: false,
+  __name__: 'aeonAccordion',
+  raw: (props) => props,
+  variantKeys: aeonAccordionVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonAccordionVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,32 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonAsyncVariant {
+  
+}
+
+type AeonAsyncVariantMap = {
+  [key in keyof AeonAsyncVariant]: Array<AeonAsyncVariant[key]>
+}
+
+export type AeonAsyncVariantProps = {
+  [key in keyof AeonAsyncVariant]?: ConditionalValue<AeonAsyncVariant[key]> | undefined
+}
+
+export interface AeonAsyncRecipe {
+  __type: AeonAsyncVariantProps
+  (props?: AeonAsyncVariantProps): Pretty<Record<"root" | "track" | "segment" | "readout" | "readoutRail" | "readoutBody" | "actions", string>>
+  raw: (props?: AeonAsyncVariantProps) => AeonAsyncVariantProps
+  variantMap: AeonAsyncVariantMap
+  variantKeys: Array<keyof AeonAsyncVariant>
+  splitVariantProps<Props extends AeonAsyncVariantProps>(props: Props): [AeonAsyncVariantProps, Pretty<DistributiveOmit<Props, keyof AeonAsyncVariantProps>>]
+  getVariantProps: (props?: AeonAsyncVariantProps) => AeonAsyncVariantProps
+}
+
+/**
+ * Async data region — track, readout, and actions
+
+
+ */
+export declare const aeonAsync: AeonAsyncRecipe

package/packages/panda/styled-system/recipes/aeon-async.mjs

@@ -0,0 +1,56 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonAsyncDefaultVariants = {}
+const aeonAsyncCompoundVariants = []
+
+const aeonAsyncSlotNames = [
+  [
+    "root",
+    "aeonAsync__root"
+  ],
+  [
+    "track",
+    "aeonAsync__track"
+  ],
+  [
+    "segment",
+    "aeonAsync__segment"
+  ],
+  [
+    "readout",
+    "aeonAsync__readout"
+  ],
+  [
+    "readoutRail",
+    "aeonAsync__readoutRail"
+  ],
+  [
+    "readoutBody",
+    "aeonAsync__readoutBody"
+  ],
+  [
+    "actions",
+    "aeonAsync__actions"
+  ]
+]
+const aeonAsyncSlotFns = /* @__PURE__ */ aeonAsyncSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonAsyncDefaultVariants, getSlotCompoundVariant(aeonAsyncCompoundVariants, slotName))])
+
+const aeonAsyncFn = memo((props = {}) => {
+  return Object.fromEntries(aeonAsyncSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonAsyncVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonAsyncDefaultVariants, ...compact(variants) })
+
+export const aeonAsync = /* @__PURE__ */ Object.assign(aeonAsyncFn, {
+  __recipe__: false,
+  __name__: 'aeonAsync',
+  raw: (props) => props,
+  variantKeys: aeonAsyncVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonAsyncVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonBadgeVariant {
+  /**
+ * @default "default"
+ */
+variant: "default" | "accent" | "danger"
+}
+
+type AeonBadgeVariantMap = {
+  [key in keyof AeonBadgeVariant]: Array<AeonBadgeVariant[key]>
+}
+
+export type AeonBadgeVariantProps = {
+  [key in keyof AeonBadgeVariant]?: ConditionalValue<AeonBadgeVariant[key]> | undefined
+}
+
+export interface AeonBadgeRecipe {
+  __type: AeonBadgeVariantProps
+  (props?: AeonBadgeVariantProps): string
+  raw: (props?: AeonBadgeVariantProps) => AeonBadgeVariantProps
+  variantMap: AeonBadgeVariantMap
+  variantKeys: Array<keyof AeonBadgeVariant>
+  splitVariantProps<Props extends AeonBadgeVariantProps>(props: Props): [AeonBadgeVariantProps, Pretty<DistributiveOmit<Props, keyof AeonBadgeVariantProps>>]
+  getVariantProps: (props?: AeonBadgeVariantProps) => AeonBadgeVariantProps
+}
+
+
+export declare const aeonBadge: AeonBadgeRecipe

package/packages/panda/styled-system/recipes/aeon-badge.mjs

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const aeonBadgeFn = /* @__PURE__ */ createRecipe('aeonBadge', {
+  "variant": "default"
+}, [])
+
+const aeonBadgeVariantMap = {
+  "variant": [
+    "default",
+    "accent",
+    "danger"
+  ]
+}
+
+const aeonBadgeVariantKeys = Object.keys(aeonBadgeVariantMap)
+
+export const aeonBadge = /* @__PURE__ */ Object.assign(memo(aeonBadgeFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'aeonBadge',
+  __getCompoundVariantCss__: aeonBadgeFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: aeonBadgeVariantKeys,
+  variantMap: aeonBadgeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, aeonBadgeVariantKeys)
+  },
+  getVariantProps: aeonBadgeFn.getVariantProps,
+})

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

@@ -0,0 +1,39 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonButtonGroupVariant {
+  /**
+ * @default "horizontal"
+ */
+orientation: "horizontal" | "vertical"
+/**
+ * @default "sm"
+ */
+gap: "sm" | "md" | "lg"
+}
+
+type AeonButtonGroupVariantMap = {
+  [key in keyof AeonButtonGroupVariant]: Array<AeonButtonGroupVariant[key]>
+}
+
+export type AeonButtonGroupVariantProps = {
+  [key in keyof AeonButtonGroupVariant]?: ConditionalValue<AeonButtonGroupVariant[key]> | undefined
+}
+
+export interface AeonButtonGroupRecipe {
+  __type: AeonButtonGroupVariantProps
+  (props?: AeonButtonGroupVariantProps): string
+  raw: (props?: AeonButtonGroupVariantProps) => AeonButtonGroupVariantProps
+  variantMap: AeonButtonGroupVariantMap
+  variantKeys: Array<keyof AeonButtonGroupVariant>
+  splitVariantProps<Props extends AeonButtonGroupVariantProps>(props: Props): [AeonButtonGroupVariantProps, Pretty<DistributiveOmit<Props, keyof AeonButtonGroupVariantProps>>]
+  getVariantProps: (props?: AeonButtonGroupVariantProps) => AeonButtonGroupVariantProps
+}
+
+/**
+ * Horizontal or vertical stack of buttons with consistent spacing
+
+
+ */
+export declare const aeonButtonGroup: AeonButtonGroupRecipe