@becket-ui/tokens 0.1.0

package/styled-system/recipes/radio.mjs

@@ -0,0 +1,70 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioDefaultVariants = {
+  "size": "md"
+}
+const radioCompoundVariants = []
+
+const radioSlotNames = [
+  [
+    "group",
+    "radio__group"
+  ],
+  [
+    "legend",
+    "radio__legend"
+  ],
+  [
+    "root",
+    "radio__root"
+  ],
+  [
+    "control",
+    "radio__control"
+  ],
+  [
+    "indicator",
+    "radio__indicator"
+  ],
+  [
+    "text",
+    "radio__text"
+  ],
+  [
+    "label",
+    "radio__label"
+  ],
+  [
+    "description",
+    "radio__description"
+  ]
+]
+const radioSlotFns = /* @__PURE__ */ radioSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioDefaultVariants, getSlotCompoundVariant(radioCompoundVariants, slotName))])
+
+const radioFn = memo((props = {}) => {
+  return Object.fromEntries(radioSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const radioVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...radioDefaultVariants, ...compact(variants) })
+
+export const radio = /* @__PURE__ */ Object.assign(radioFn, {
+  __recipe__: false,
+  __name__: 'radio',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: radioVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, radioVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/select-recipe.d.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SelectRecipeVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+/**
+ * @default false
+ */
+invalid: boolean
+}
+
+type SelectRecipeVariantMap = {
+  [key in keyof SelectRecipeVariant]: Array<SelectRecipeVariant[key]>
+}
+
+
+
+export type SelectRecipeVariantProps = {
+  [key in keyof SelectRecipeVariant]?: ConditionalValue<SelectRecipeVariant[key]> | undefined
+}
+
+export interface SelectRecipeRecipe {
+  
+  __type: SelectRecipeVariantProps
+  (props?: SelectRecipeVariantProps): string
+  raw: (props?: SelectRecipeVariantProps) => SelectRecipeVariantProps
+  variantMap: SelectRecipeVariantMap
+  variantKeys: Array<keyof SelectRecipeVariant>
+  splitVariantProps<Props extends SelectRecipeVariantProps>(props: Props): [SelectRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SelectRecipeVariantProps>>]
+  getVariantProps: (props?: SelectRecipeVariantProps) => SelectRecipeVariantProps
+}
+
+/**
+ * Native select. Label / helper / error live on Field.
+ */
+export declare const selectRecipe: SelectRecipeRecipe

package/styled-system/recipes/select-recipe.mjs

@@ -0,0 +1,37 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const selectRecipeFn = /* @__PURE__ */ createRecipe('select', {
+  "size": "md",
+  "invalid": false
+}, [])
+
+const selectRecipeVariantMap = {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "invalid": [
+    "true",
+    "false"
+  ]
+}
+
+const selectRecipeVariantKeys = Object.keys(selectRecipeVariantMap)
+
+export const selectRecipe = /* @__PURE__ */ Object.assign(memo(selectRecipeFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'selectRecipe',
+  __getCompoundVariantCss__: selectRecipeFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: selectRecipeVariantKeys,
+  variantMap: selectRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, selectRecipeVariantKeys)
+  },
+  getVariantProps: selectRecipeFn.getVariantProps,
+})

package/styled-system/recipes/separator.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SeparatorVariant {
+  /**
+ * @default "horizontal"
+ */
+orientation: "horizontal" | "vertical"
+}
+
+type SeparatorVariantMap = {
+  [key in keyof SeparatorVariant]: Array<SeparatorVariant[key]>
+}
+
+
+
+export type SeparatorVariantProps = {
+  [key in keyof SeparatorVariant]?: ConditionalValue<SeparatorVariant[key]> | undefined
+}
+
+export interface SeparatorRecipe {
+  
+  __type: SeparatorVariantProps
+  (props?: SeparatorVariantProps): string
+  raw: (props?: SeparatorVariantProps) => SeparatorVariantProps
+  variantMap: SeparatorVariantMap
+  variantKeys: Array<keyof SeparatorVariant>
+  splitVariantProps<Props extends SeparatorVariantProps>(props: Props): [SeparatorVariantProps, Pretty<DistributiveOmit<Props, keyof SeparatorVariantProps>>]
+  getVariantProps: (props?: SeparatorVariantProps) => SeparatorVariantProps
+}
+
+/**
+ * Horizontal or vertical rule
+ */
+export declare const separator: SeparatorRecipe

package/styled-system/recipes/separator.mjs

@@ -0,0 +1,31 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const separatorFn = /* @__PURE__ */ createRecipe('separator', {
+  "orientation": "horizontal"
+}, [])
+
+const separatorVariantMap = {
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ]
+}
+
+const separatorVariantKeys = Object.keys(separatorVariantMap)
+
+export const separator = /* @__PURE__ */ Object.assign(memo(separatorFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'separator',
+  __getCompoundVariantCss__: separatorFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: separatorVariantKeys,
+  variantMap: separatorVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, separatorVariantKeys)
+  },
+  getVariantProps: separatorFn.getVariantProps,
+})

package/styled-system/recipes/spinner.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SpinnerVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type SpinnerVariantMap = {
+  [key in keyof SpinnerVariant]: Array<SpinnerVariant[key]>
+}
+
+
+
+export type SpinnerVariantProps = {
+  [key in keyof SpinnerVariant]?: ConditionalValue<SpinnerVariant[key]> | undefined
+}
+
+export interface SpinnerRecipe {
+  
+  __type: SpinnerVariantProps
+  (props?: SpinnerVariantProps): string
+  raw: (props?: SpinnerVariantProps) => SpinnerVariantProps
+  variantMap: SpinnerVariantMap
+  variantKeys: Array<keyof SpinnerVariant>
+  splitVariantProps<Props extends SpinnerVariantProps>(props: Props): [SpinnerVariantProps, Pretty<DistributiveOmit<Props, keyof SpinnerVariantProps>>]
+  getVariantProps: (props?: SpinnerVariantProps) => SpinnerVariantProps
+}
+
+/**
+ * Pure CSS loading spinner
+ */
+export declare const spinner: SpinnerRecipe

package/styled-system/recipes/spinner.mjs

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const spinnerFn = /* @__PURE__ */ createRecipe('spinner', {
+  "size": "md"
+}, [])
+
+const spinnerVariantMap = {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ]
+}
+
+const spinnerVariantKeys = Object.keys(spinnerVariantMap)
+
+export const spinner = /* @__PURE__ */ Object.assign(memo(spinnerFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'spinner',
+  __getCompoundVariantCss__: spinnerFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: spinnerVariantKeys,
+  variantMap: spinnerVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, spinnerVariantKeys)
+  },
+  getVariantProps: spinnerFn.getVariantProps,
+})

package/styled-system/recipes/switch-recipe.d.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SwitchRecipeVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+/**
+ * @default false
+ */
+checked: boolean
+}
+
+type SwitchRecipeVariantMap = {
+  [key in keyof SwitchRecipeVariant]: Array<SwitchRecipeVariant[key]>
+}
+
+type SwitchRecipeSlot = "root" | "track" | "thumb" | "wrap" | "label"
+
+export type SwitchRecipeVariantProps = {
+  [key in keyof SwitchRecipeVariant]?: SwitchRecipeVariant[key] | undefined
+}
+
+export interface SwitchRecipeRecipe {
+  __slot: SwitchRecipeSlot
+  __type: SwitchRecipeVariantProps
+  (props?: SwitchRecipeVariantProps): Pretty<Record<SwitchRecipeSlot, string>>
+  raw: (props?: SwitchRecipeVariantProps) => SwitchRecipeVariantProps
+  variantMap: SwitchRecipeVariantMap
+  variantKeys: Array<keyof SwitchRecipeVariant>
+  splitVariantProps<Props extends SwitchRecipeVariantProps>(props: Props): [SwitchRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SwitchRecipeVariantProps>>]
+  getVariantProps: (props?: SwitchRecipeVariantProps) => SwitchRecipeVariantProps
+}
+
+/**
+ * Accessible switch control with track and thumb slots
+ */
+export declare const switchRecipe: SwitchRecipeRecipe

package/styled-system/recipes/switch-recipe.mjs

@@ -0,0 +1,93 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const switchRecipeDefaultVariants = {
+  "size": "md",
+  "checked": false
+}
+const switchRecipeCompoundVariants = [
+  {
+    "size": "sm",
+    "checked": true,
+    "css": {
+      "thumb": {
+        "transform": "translateX(0.75rem)"
+      }
+    }
+  },
+  {
+    "size": "md",
+    "checked": true,
+    "css": {
+      "thumb": {
+        "transform": "translateX(1.25rem)"
+      }
+    }
+  },
+  {
+    "size": "lg",
+    "checked": true,
+    "css": {
+      "thumb": {
+        "transform": "translateX(1.5rem)"
+      }
+    }
+  }
+]
+
+const switchRecipeSlotNames = [
+  [
+    "root",
+    "switch__root"
+  ],
+  [
+    "track",
+    "switch__track"
+  ],
+  [
+    "thumb",
+    "switch__thumb"
+  ],
+  [
+    "wrap",
+    "switch__wrap"
+  ],
+  [
+    "label",
+    "switch__label"
+  ]
+]
+const switchRecipeSlotFns = /* @__PURE__ */ switchRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, switchRecipeDefaultVariants, getSlotCompoundVariant(switchRecipeCompoundVariants, slotName))])
+
+const switchRecipeFn = memo((props = {}) => {
+  return Object.fromEntries(switchRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const switchRecipeVariantKeys = [
+  "size",
+  "checked"
+]
+const getVariantProps = (variants) => ({ ...switchRecipeDefaultVariants, ...compact(variants) })
+
+export const switchRecipe = /* @__PURE__ */ Object.assign(switchRecipeFn, {
+  __recipe__: false,
+  __name__: 'switchRecipe',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: switchRecipeVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md",
+    "lg"
+  ],
+  "checked": [
+    "true",
+    "false"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, switchRecipeVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/table.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md"
+}
+
+type TableVariantMap = {
+  [key in keyof TableVariant]: Array<TableVariant[key]>
+}
+
+type TableSlot = "root" | "caption" | "thead" | "tbody" | "tfoot" | "tr" | "th" | "td"
+
+export type TableVariantProps = {
+  [key in keyof TableVariant]?: ConditionalValue<TableVariant[key]> | undefined
+}
+
+export interface TableRecipe {
+  __slot: TableSlot
+  __type: TableVariantProps
+  (props?: TableVariantProps): Pretty<Record<TableSlot, string>>
+  raw: (props?: TableVariantProps) => TableVariantProps
+  variantMap: TableVariantMap
+  variantKeys: Array<keyof TableVariant>
+  splitVariantProps<Props extends TableVariantProps>(props: Props): [TableVariantProps, Pretty<DistributiveOmit<Props, keyof TableVariantProps>>]
+  getVariantProps: (props?: TableVariantProps) => TableVariantProps
+}
+
+/**
+ * Semantic table slots
+ */
+export declare const table: TableRecipe

package/styled-system/recipes/table.mjs

@@ -0,0 +1,70 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableDefaultVariants = {
+  "size": "md"
+}
+const tableCompoundVariants = []
+
+const tableSlotNames = [
+  [
+    "root",
+    "table__root"
+  ],
+  [
+    "caption",
+    "table__caption"
+  ],
+  [
+    "thead",
+    "table__thead"
+  ],
+  [
+    "tbody",
+    "table__tbody"
+  ],
+  [
+    "tfoot",
+    "table__tfoot"
+  ],
+  [
+    "tr",
+    "table__tr"
+  ],
+  [
+    "th",
+    "table__th"
+  ],
+  [
+    "td",
+    "table__td"
+  ]
+]
+const tableSlotFns = /* @__PURE__ */ tableSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableDefaultVariants, getSlotCompoundVariant(tableCompoundVariants, slotName))])
+
+const tableFn = memo((props = {}) => {
+  return Object.fromEntries(tableSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tableVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...tableDefaultVariants, ...compact(variants) })
+
+export const table = /* @__PURE__ */ Object.assign(tableFn, {
+  __recipe__: false,
+  __name__: 'table',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tableVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tableVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/tabs.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TabsVariant {
+  
+}
+
+type TabsVariantMap = {
+  [key in keyof TabsVariant]: Array<TabsVariant[key]>
+}
+
+type TabsSlot = "root" | "list" | "tab" | "panel"
+
+export type TabsVariantProps = {
+  [key in keyof TabsVariant]?: ConditionalValue<TabsVariant[key]> | undefined
+}
+
+export interface TabsRecipe {
+  __slot: TabsSlot
+  __type: TabsVariantProps
+  (props?: TabsVariantProps): Pretty<Record<TabsSlot, string>>
+  raw: (props?: TabsVariantProps) => TabsVariantProps
+  variantMap: TabsVariantMap
+  variantKeys: Array<keyof TabsVariant>
+  splitVariantProps<Props extends TabsVariantProps>(props: Props): [TabsVariantProps, Pretty<DistributiveOmit<Props, keyof TabsVariantProps>>]
+  getVariantProps: (props?: TabsVariantProps) => TabsVariantProps
+}
+
+/**
+ * ARIA tabs with list, tab, and panel slots
+ */
+export declare const tabs: TabsRecipe

package/styled-system/recipes/tabs.mjs

@@ -0,0 +1,45 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tabsDefaultVariants = {}
+const tabsCompoundVariants = []
+
+const tabsSlotNames = [
+  [
+    "root",
+    "tabs__root"
+  ],
+  [
+    "list",
+    "tabs__list"
+  ],
+  [
+    "tab",
+    "tabs__tab"
+  ],
+  [
+    "panel",
+    "tabs__panel"
+  ]
+]
+const tabsSlotFns = /* @__PURE__ */ tabsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tabsDefaultVariants, getSlotCompoundVariant(tabsCompoundVariants, slotName))])
+
+const tabsFn = memo((props = {}) => {
+  return Object.fromEntries(tabsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tabsVariantKeys = []
+const getVariantProps = (variants) => ({ ...tabsDefaultVariants, ...compact(variants) })
+
+export const tabs = /* @__PURE__ */ Object.assign(tabsFn, {
+  __recipe__: false,
+  __name__: 'tabs',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tabsVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tabsVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/tag.d.ts

@@ -0,0 +1,48 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TagVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+/**
+ * @default "neutral"
+ */
+visual: "primary" | "secondary" | "neutral" | "outline"
+/**
+ * @default "full"
+ */
+borderRadius: "none" | "sm" | "md" | "lg" | "xl" | "full"
+/**
+ * @default false
+ */
+withGradient: boolean
+}
+
+type TagVariantMap = {
+  [key in keyof TagVariant]: Array<TagVariant[key]>
+}
+
+
+
+export type TagVariantProps = {
+  [key in keyof TagVariant]?: TagVariant[key] | undefined
+}
+
+export interface TagRecipe {
+  
+  __type: TagVariantProps
+  (props?: TagVariantProps): string
+  raw: (props?: TagVariantProps) => TagVariantProps
+  variantMap: TagVariantMap
+  variantKeys: Array<keyof TagVariant>
+  splitVariantProps<Props extends TagVariantProps>(props: Props): [TagVariantProps, Pretty<DistributiveOmit<Props, keyof TagVariantProps>>]
+  getVariantProps: (props?: TagVariantProps) => TagVariantProps
+}
+
+/**
+ * Non-interactive metadata chip (Tag)
+ */
+export declare const tag: TagRecipe