aeon-ui-engine 1.0.0

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

@@ -0,0 +1,63 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonScrollDefaultVariants = {
+  "axis": "both",
+  "maxH": "md",
+  "maxW": "full"
+}
+const aeonScrollCompoundVariants = []
+
+const aeonScrollSlotNames = [
+  [
+    "root",
+    "aeonScroll__root"
+  ],
+  [
+    "viewport",
+    "aeonScroll__viewport"
+  ],
+  [
+    "content",
+    "aeonScroll__content"
+  ]
+]
+const aeonScrollSlotFns = /* @__PURE__ */ aeonScrollSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonScrollDefaultVariants, getSlotCompoundVariant(aeonScrollCompoundVariants, slotName))])
+
+const aeonScrollFn = memo((props = {}) => {
+  return Object.fromEntries(aeonScrollSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonScrollVariantKeys = [
+  "axis",
+  "maxH",
+  "maxW"
+]
+const getVariantProps = (variants) => ({ ...aeonScrollDefaultVariants, ...compact(variants) })
+
+export const aeonScroll = /* @__PURE__ */ Object.assign(aeonScrollFn, {
+  __recipe__: false,
+  __name__: 'aeonScroll',
+  raw: (props) => props,
+  variantKeys: aeonScrollVariantKeys,
+  variantMap: {
+  "axis": [
+    "y",
+    "x",
+    "both"
+  ],
+  "maxH": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "maxW": [
+    "full",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, aeonScrollVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,32 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonSelectVariant {
+  
+}
+
+type AeonSelectVariantMap = {
+  [key in keyof AeonSelectVariant]: Array<AeonSelectVariant[key]>
+}
+
+export type AeonSelectVariantProps = {
+  [key in keyof AeonSelectVariant]?: ConditionalValue<AeonSelectVariant[key]> | undefined
+}
+
+export interface AeonSelectRecipe {
+  __type: AeonSelectVariantProps
+  (props?: AeonSelectVariantProps): Pretty<Record<"root" | "trigger" | "value" | "icon" | "positioner" | "content" | "item", string>>
+  raw: (props?: AeonSelectVariantProps) => AeonSelectVariantProps
+  variantMap: AeonSelectVariantMap
+  variantKeys: Array<keyof AeonSelectVariant>
+  splitVariantProps<Props extends AeonSelectVariantProps>(props: Props): [AeonSelectVariantProps, Pretty<DistributiveOmit<Props, keyof AeonSelectVariantProps>>]
+  getVariantProps: (props?: AeonSelectVariantProps) => AeonSelectVariantProps
+}
+
+/**
+ * Custom listbox select — no native OS dropdown chrome
+
+
+ */
+export declare const aeonSelect: AeonSelectRecipe

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

@@ -0,0 +1,56 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonSelectDefaultVariants = {}
+const aeonSelectCompoundVariants = []
+
+const aeonSelectSlotNames = [
+  [
+    "root",
+    "aeonSelect__root"
+  ],
+  [
+    "trigger",
+    "aeonSelect__trigger"
+  ],
+  [
+    "value",
+    "aeonSelect__value"
+  ],
+  [
+    "icon",
+    "aeonSelect__icon"
+  ],
+  [
+    "positioner",
+    "aeonSelect__positioner"
+  ],
+  [
+    "content",
+    "aeonSelect__content"
+  ],
+  [
+    "item",
+    "aeonSelect__item"
+  ]
+]
+const aeonSelectSlotFns = /* @__PURE__ */ aeonSelectSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonSelectDefaultVariants, getSlotCompoundVariant(aeonSelectCompoundVariants, slotName))])
+
+const aeonSelectFn = memo((props = {}) => {
+  return Object.fromEntries(aeonSelectSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonSelectVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonSelectDefaultVariants, ...compact(variants) })
+
+export const aeonSelect = /* @__PURE__ */ Object.assign(aeonSelectFn, {
+  __recipe__: false,
+  __name__: 'aeonSelect',
+  raw: (props) => props,
+  variantKeys: aeonSelectVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonSelectVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonSwitchVariant {
+  
+}
+
+type AeonSwitchVariantMap = {
+  [key in keyof AeonSwitchVariant]: Array<AeonSwitchVariant[key]>
+}
+
+export type AeonSwitchVariantProps = {
+  [key in keyof AeonSwitchVariant]?: ConditionalValue<AeonSwitchVariant[key]> | undefined
+}
+
+export interface AeonSwitchRecipe {
+  __type: AeonSwitchVariantProps
+  (props?: AeonSwitchVariantProps): Pretty<Record<"root" | "control" | "thumb" | "label" | "hiddenInput", string>>
+  raw: (props?: AeonSwitchVariantProps) => AeonSwitchVariantProps
+  variantMap: AeonSwitchVariantMap
+  variantKeys: Array<keyof AeonSwitchVariant>
+  splitVariantProps<Props extends AeonSwitchVariantProps>(props: Props): [AeonSwitchVariantProps, Pretty<DistributiveOmit<Props, keyof AeonSwitchVariantProps>>]
+  getVariantProps: (props?: AeonSwitchVariantProps) => AeonSwitchVariantProps
+}
+
+
+export declare const aeonSwitch: AeonSwitchRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonSwitchDefaultVariants = {}
+const aeonSwitchCompoundVariants = []
+
+const aeonSwitchSlotNames = [
+  [
+    "root",
+    "aeonSwitch__root"
+  ],
+  [
+    "control",
+    "aeonSwitch__control"
+  ],
+  [
+    "thumb",
+    "aeonSwitch__thumb"
+  ],
+  [
+    "label",
+    "aeonSwitch__label"
+  ],
+  [
+    "hiddenInput",
+    "aeonSwitch__hiddenInput"
+  ]
+]
+const aeonSwitchSlotFns = /* @__PURE__ */ aeonSwitchSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonSwitchDefaultVariants, getSlotCompoundVariant(aeonSwitchCompoundVariants, slotName))])
+
+const aeonSwitchFn = memo((props = {}) => {
+  return Object.fromEntries(aeonSwitchSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonSwitchVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonSwitchDefaultVariants, ...compact(variants) })
+
+export const aeonSwitch = /* @__PURE__ */ Object.assign(aeonSwitchFn, {
+  __recipe__: false,
+  __name__: 'aeonSwitch',
+  raw: (props) => props,
+  variantKeys: aeonSwitchVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonSwitchVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonTabsVariant {
+  
+}
+
+type AeonTabsVariantMap = {
+  [key in keyof AeonTabsVariant]: Array<AeonTabsVariant[key]>
+}
+
+export type AeonTabsVariantProps = {
+  [key in keyof AeonTabsVariant]?: ConditionalValue<AeonTabsVariant[key]> | undefined
+}
+
+export interface AeonTabsRecipe {
+  __type: AeonTabsVariantProps
+  (props?: AeonTabsVariantProps): Pretty<Record<"root" | "list" | "trigger" | "content" | "indicator", string>>
+  raw: (props?: AeonTabsVariantProps) => AeonTabsVariantProps
+  variantMap: AeonTabsVariantMap
+  variantKeys: Array<keyof AeonTabsVariant>
+  splitVariantProps<Props extends AeonTabsVariantProps>(props: Props): [AeonTabsVariantProps, Pretty<DistributiveOmit<Props, keyof AeonTabsVariantProps>>]
+  getVariantProps: (props?: AeonTabsVariantProps) => AeonTabsVariantProps
+}
+
+
+export declare const aeonTabs: AeonTabsRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonTabsDefaultVariants = {}
+const aeonTabsCompoundVariants = []
+
+const aeonTabsSlotNames = [
+  [
+    "root",
+    "aeonTabs__root"
+  ],
+  [
+    "list",
+    "aeonTabs__list"
+  ],
+  [
+    "trigger",
+    "aeonTabs__trigger"
+  ],
+  [
+    "content",
+    "aeonTabs__content"
+  ],
+  [
+    "indicator",
+    "aeonTabs__indicator"
+  ]
+]
+const aeonTabsSlotFns = /* @__PURE__ */ aeonTabsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonTabsDefaultVariants, getSlotCompoundVariant(aeonTabsCompoundVariants, slotName))])
+
+const aeonTabsFn = memo((props = {}) => {
+  return Object.fromEntries(aeonTabsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonTabsVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonTabsDefaultVariants, ...compact(variants) })
+
+export const aeonTabs = /* @__PURE__ */ Object.assign(aeonTabsFn, {
+  __recipe__: false,
+  __name__: 'aeonTabs',
+  raw: (props) => props,
+  variantKeys: aeonTabsVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonTabsVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonToastVariant {
+  
+}
+
+type AeonToastVariantMap = {
+  [key in keyof AeonToastVariant]: Array<AeonToastVariant[key]>
+}
+
+export type AeonToastVariantProps = {
+  [key in keyof AeonToastVariant]?: ConditionalValue<AeonToastVariant[key]> | undefined
+}
+
+export interface AeonToastRecipe {
+  __type: AeonToastVariantProps
+  (props?: AeonToastVariantProps): Pretty<Record<"viewport" | "root" | "title" | "description" | "closeTrigger", string>>
+  raw: (props?: AeonToastVariantProps) => AeonToastVariantProps
+  variantMap: AeonToastVariantMap
+  variantKeys: Array<keyof AeonToastVariant>
+  splitVariantProps<Props extends AeonToastVariantProps>(props: Props): [AeonToastVariantProps, Pretty<DistributiveOmit<Props, keyof AeonToastVariantProps>>]
+  getVariantProps: (props?: AeonToastVariantProps) => AeonToastVariantProps
+}
+
+
+export declare const aeonToast: AeonToastRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonToastDefaultVariants = {}
+const aeonToastCompoundVariants = []
+
+const aeonToastSlotNames = [
+  [
+    "viewport",
+    "aeonToast__viewport"
+  ],
+  [
+    "root",
+    "aeonToast__root"
+  ],
+  [
+    "title",
+    "aeonToast__title"
+  ],
+  [
+    "description",
+    "aeonToast__description"
+  ],
+  [
+    "closeTrigger",
+    "aeonToast__closeTrigger"
+  ]
+]
+const aeonToastSlotFns = /* @__PURE__ */ aeonToastSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonToastDefaultVariants, getSlotCompoundVariant(aeonToastCompoundVariants, slotName))])
+
+const aeonToastFn = memo((props = {}) => {
+  return Object.fromEntries(aeonToastSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonToastVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonToastDefaultVariants, ...compact(variants) })
+
+export const aeonToast = /* @__PURE__ */ Object.assign(aeonToastFn, {
+  __recipe__: false,
+  __name__: 'aeonToast',
+  raw: (props) => props,
+  variantKeys: aeonToastVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonToastVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonTooltipVariant {
+  
+}
+
+type AeonTooltipVariantMap = {
+  [key in keyof AeonTooltipVariant]: Array<AeonTooltipVariant[key]>
+}
+
+export type AeonTooltipVariantProps = {
+  [key in keyof AeonTooltipVariant]?: ConditionalValue<AeonTooltipVariant[key]> | undefined
+}
+
+export interface AeonTooltipRecipe {
+  __type: AeonTooltipVariantProps
+  (props?: AeonTooltipVariantProps): Pretty<Record<"root" | "trigger" | "positioner" | "content" | "arrow", string>>
+  raw: (props?: AeonTooltipVariantProps) => AeonTooltipVariantProps
+  variantMap: AeonTooltipVariantMap
+  variantKeys: Array<keyof AeonTooltipVariant>
+  splitVariantProps<Props extends AeonTooltipVariantProps>(props: Props): [AeonTooltipVariantProps, Pretty<DistributiveOmit<Props, keyof AeonTooltipVariantProps>>]
+  getVariantProps: (props?: AeonTooltipVariantProps) => AeonTooltipVariantProps
+}
+
+
+export declare const aeonTooltip: AeonTooltipRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonTooltipDefaultVariants = {}
+const aeonTooltipCompoundVariants = []
+
+const aeonTooltipSlotNames = [
+  [
+    "root",
+    "aeonTooltip__root"
+  ],
+  [
+    "trigger",
+    "aeonTooltip__trigger"
+  ],
+  [
+    "positioner",
+    "aeonTooltip__positioner"
+  ],
+  [
+    "content",
+    "aeonTooltip__content"
+  ],
+  [
+    "arrow",
+    "aeonTooltip__arrow"
+  ]
+]
+const aeonTooltipSlotFns = /* @__PURE__ */ aeonTooltipSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonTooltipDefaultVariants, getSlotCompoundVariant(aeonTooltipCompoundVariants, slotName))])
+
+const aeonTooltipFn = memo((props = {}) => {
+  return Object.fromEntries(aeonTooltipSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonTooltipVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonTooltipDefaultVariants, ...compact(variants) })
+
+export const aeonTooltip = /* @__PURE__ */ Object.assign(aeonTooltipFn, {
+  __recipe__: false,
+  __name__: 'aeonTooltip',
+  raw: (props) => props,
+  variantKeys: aeonTooltipVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonTooltipVariantKeys)
+  },
+  getVariantProps
+})

package/packages/panda/styled-system/recipes/create-recipe.mjs

@@ -0,0 +1,82 @@
+import { finalizeConditions, sortConditions } from '../css/conditions.mjs';
+import { css } from '../css/css.mjs';
+import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.mjs';
+import { cx } from '../css/cx.mjs';
+import { compact, createCss, splitProps, uniq, withoutSpace } from '../helpers.mjs';
+
+export const createRecipe = (name, defaultVariants, compoundVariants) => {
+ const getVariantProps = (variants) => {
+   return {
+     [name]: '__ignore__',
+     ...defaultVariants,
+     ...compact(variants),
+   };
+ };
+
+  const recipeFn = (variants, withCompoundVariants = true) => {
+   const transform = (prop, value) => {
+     assertCompoundVariant(name, compoundVariants, variants, prop)
+
+      if (value === '__ignore__') {
+        return { className: name }
+      }
+
+      value = withoutSpace(value)
+      return { className: `${name}--${prop}_${value}` }
+   }
+
+   const recipeCss = createCss({
+     
+     conditions: {
+       shift: sortConditions,
+       finalize: finalizeConditions,
+       breakpoints: { keys: ["base","sm","md","lg","xl","2xl"] }
+     },
+     utility: {
+       
+       toHash: (path, hashFn) => hashFn(path.join(":")),
+       transform,
+     }
+   })
+
+   const recipeStyles = getVariantProps(variants)
+
+   if (withCompoundVariants) {
+     const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles)
+     return cx(recipeCss(recipeStyles), css(compoundVariantStyles))
+   }
+
+   return recipeCss(recipeStyles)
+  }
+
+   return {
+     recipeFn,
+     getVariantProps,
+     __getCompoundVariantCss__: (variants) => {
+       return getCompoundVariantCss(compoundVariants, getVariantProps(variants));
+     },
+   }
+}
+
+export const mergeRecipes = (recipeA, recipeB) => {
+ if (recipeA && !recipeB) return recipeA
+ if (!recipeA && recipeB) return recipeB
+
+ const recipeFn = (...args) => cx(recipeA(...args), recipeB(...args))
+ const variantKeys = uniq(recipeA.variantKeys, recipeB.variantKeys)
+ const variantMap = variantKeys.reduce((acc, key) => {
+   acc[key] = uniq(recipeA.variantMap[key], recipeB.variantMap[key])
+   return acc
+ }, {})
+
+ return Object.assign(recipeFn, {
+   __recipe__: true,
+   __name__: `${recipeA.__name__} ${recipeB.__name__}`,
+   raw: (props) => props,
+   variantKeys,
+   variantMap,
+   splitVariantProps(props) {
+     return splitProps(props, variantKeys)
+   },
+ })
+ }

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

@@ -0,0 +1,18 @@
+/* eslint-disable */
+export * from './aeon-button';
+export * from './aeon-button-group';
+export * from './aeon-badge';
+export * from './aeon-accordion';
+export * from './aeon-dialog';
+export * from './aeon-tabs';
+export * from './aeon-switch';
+export * from './aeon-checkbox';
+export * from './aeon-async';
+export * from './aeon-field';
+export * from './aeon-scroll';
+export * from './aeon-select';
+export * from './aeon-combobox';
+export * from './aeon-menu';
+export * from './aeon-popover';
+export * from './aeon-tooltip';
+export * from './aeon-toast';

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

@@ -0,0 +1,17 @@
+export * from './aeon-button.mjs';
+export * from './aeon-button-group.mjs';
+export * from './aeon-badge.mjs';
+export * from './aeon-accordion.mjs';
+export * from './aeon-dialog.mjs';
+export * from './aeon-tabs.mjs';
+export * from './aeon-switch.mjs';
+export * from './aeon-checkbox.mjs';
+export * from './aeon-async.mjs';
+export * from './aeon-field.mjs';
+export * from './aeon-scroll.mjs';
+export * from './aeon-select.mjs';
+export * from './aeon-combobox.mjs';
+export * from './aeon-menu.mjs';
+export * from './aeon-popover.mjs';
+export * from './aeon-tooltip.mjs';
+export * from './aeon-toast.mjs';