@pyck/styled-system 0.0.1

package/dist/recipes/tags-input.mjs

@@ -0,0 +1,86 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tagsInputDefaultVariants = {
+  "size": "md",
+  "variant": "surface"
+}
+const tagsInputCompoundVariants = []
+
+const tagsInputSlotNames = [
+  [
+    "root",
+    "tags-input__root"
+  ],
+  [
+    "label",
+    "tags-input__label"
+  ],
+  [
+    "control",
+    "tags-input__control"
+  ],
+  [
+    "input",
+    "tags-input__input"
+  ],
+  [
+    "clearTrigger",
+    "tags-input__clearTrigger"
+  ],
+  [
+    "item",
+    "tags-input__item"
+  ],
+  [
+    "itemPreview",
+    "tags-input__itemPreview"
+  ],
+  [
+    "itemInput",
+    "tags-input__itemInput"
+  ],
+  [
+    "itemText",
+    "tags-input__itemText"
+  ],
+  [
+    "itemDeleteTrigger",
+    "tags-input__itemDeleteTrigger"
+  ]
+]
+const tagsInputSlotFns = /* @__PURE__ */ tagsInputSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tagsInputDefaultVariants, getSlotCompoundVariant(tagsInputCompoundVariants, slotName))])
+
+const tagsInputFn = memo((props = {}) => {
+  return Object.fromEntries(tagsInputSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tagsInputVariantKeys = [
+  "variant",
+  "size"
+]
+const getVariantProps = (variants) => ({ ...tagsInputDefaultVariants, ...compact(variants) })
+
+export const tagsInput = /* @__PURE__ */ Object.assign(tagsInputFn, {
+  __recipe__: false,
+  __name__: 'tagsInput',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tagsInputVariantKeys,
+  variantMap: {
+  "variant": [
+    "outline",
+    "surface"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tagsInputVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/text.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextVariant {
+  size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl" | "7xl"
+}
+
+type TextVariantMap = {
+  [key in keyof TextVariant]: Array<TextVariant[key]>
+}
+
+
+
+export type TextVariantProps = {
+  [key in keyof TextVariant]?: ConditionalValue<TextVariant[key]> | undefined
+}
+
+export interface TextRecipe {
+  
+  __type: TextVariantProps
+  (props?: TextVariantProps): string
+  raw: (props?: TextVariantProps) => TextVariantProps
+  variantMap: TextVariantMap
+  variantKeys: Array<keyof TextVariant>
+  splitVariantProps<Props extends TextVariantProps>(props: Props): [TextVariantProps, Pretty<DistributiveOmit<Props, keyof TextVariantProps>>]
+  getVariantProps: (props?: TextVariantProps) => TextVariantProps
+}
+
+
+export declare const text: TextRecipe

package/dist/recipes/text.mjs

@@ -0,0 +1,38 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const textFn = /* @__PURE__ */ createRecipe('text', {}, [])
+
+const textVariantMap = {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl",
+    "3xl",
+    "4xl",
+    "5xl",
+    "6xl",
+    "7xl"
+  ]
+}
+
+const textVariantKeys = Object.keys(textVariantMap)
+
+export const text = /* @__PURE__ */ Object.assign(memo(textFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'text',
+  __getCompoundVariantCss__: textFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: textVariantKeys,
+  variantMap: textVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, textVariantKeys)
+  },
+  getVariantProps: textFn.getVariantProps,
+})

package/dist/recipes/textarea.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextareaVariant {
+  /**
+ * @default "surface"
+ */
+variant: "outline" | "surface" | "subtle" | "plain"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl"
+}
+
+type TextareaVariantMap = {
+  [key in keyof TextareaVariant]: Array<TextareaVariant[key]>
+}
+
+
+
+export type TextareaVariantProps = {
+  [key in keyof TextareaVariant]?: ConditionalValue<TextareaVariant[key]> | undefined
+}
+
+export interface TextareaRecipe {
+  
+  __type: TextareaVariantProps
+  (props?: TextareaVariantProps): string
+  raw: (props?: TextareaVariantProps) => TextareaVariantProps
+  variantMap: TextareaVariantMap
+  variantKeys: Array<keyof TextareaVariant>
+  splitVariantProps<Props extends TextareaVariantProps>(props: Props): [TextareaVariantProps, Pretty<DistributiveOmit<Props, keyof TextareaVariantProps>>]
+  getVariantProps: (props?: TextareaVariantProps) => TextareaVariantProps
+}
+
+
+export declare const textarea: TextareaRecipe

package/dist/recipes/textarea.mjs

@@ -0,0 +1,41 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const textareaFn = /* @__PURE__ */ createRecipe('textarea', {
+  "size": "md",
+  "variant": "surface"
+}, [])
+
+const textareaVariantMap = {
+  "variant": [
+    "outline",
+    "surface",
+    "subtle",
+    "plain"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl"
+  ]
+}
+
+const textareaVariantKeys = Object.keys(textareaVariantMap)
+
+export const textarea = /* @__PURE__ */ Object.assign(memo(textareaFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'textarea',
+  __getCompoundVariantCss__: textareaFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: textareaVariantKeys,
+  variantMap: textareaVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, textareaVariantKeys)
+  },
+  getVariantProps: textareaFn.getVariantProps,
+})

package/dist/recipes/toast.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ToastVariant {
+  
+}
+
+type ToastVariantMap = {
+  [key in keyof ToastVariant]: Array<ToastVariant[key]>
+}
+
+type ToastSlot = "group" | "root" | "title" | "description" | "actionTrigger" | "closeTrigger"
+
+export type ToastVariantProps = {
+  [key in keyof ToastVariant]?: ConditionalValue<ToastVariant[key]> | undefined
+}
+
+export interface ToastRecipe {
+  __slot: ToastSlot
+  __type: ToastVariantProps
+  (props?: ToastVariantProps): Pretty<Record<ToastSlot, string>>
+  raw: (props?: ToastVariantProps) => ToastVariantProps
+  variantMap: ToastVariantMap
+  variantKeys: Array<keyof ToastVariant>
+  splitVariantProps<Props extends ToastVariantProps>(props: Props): [ToastVariantProps, Pretty<DistributiveOmit<Props, keyof ToastVariantProps>>]
+  getVariantProps: (props?: ToastVariantProps) => ToastVariantProps
+}
+
+
+export declare const toast: ToastRecipe

package/dist/recipes/toast.mjs

@@ -0,0 +1,53 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toastDefaultVariants = {}
+const toastCompoundVariants = []
+
+const toastSlotNames = [
+  [
+    "group",
+    "toast__group"
+  ],
+  [
+    "root",
+    "toast__root"
+  ],
+  [
+    "title",
+    "toast__title"
+  ],
+  [
+    "description",
+    "toast__description"
+  ],
+  [
+    "actionTrigger",
+    "toast__actionTrigger"
+  ],
+  [
+    "closeTrigger",
+    "toast__closeTrigger"
+  ]
+]
+const toastSlotFns = /* @__PURE__ */ toastSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toastDefaultVariants, getSlotCompoundVariant(toastCompoundVariants, slotName))])
+
+const toastFn = memo((props = {}) => {
+  return Object.fromEntries(toastSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const toastVariantKeys = []
+const getVariantProps = (variants) => ({ ...toastDefaultVariants, ...compact(variants) })
+
+export const toast = /* @__PURE__ */ Object.assign(toastFn, {
+  __recipe__: false,
+  __name__: 'toast',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: toastVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, toastVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/toggle-group.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ToggleGroupVariant {
+  variant: "surface" | "outline"
+}
+
+type ToggleGroupVariantMap = {
+  [key in keyof ToggleGroupVariant]: Array<ToggleGroupVariant[key]>
+}
+
+type ToggleGroupSlot = "root" | "item"
+
+export type ToggleGroupVariantProps = {
+  [key in keyof ToggleGroupVariant]?: ConditionalValue<ToggleGroupVariant[key]> | undefined
+}
+
+export interface ToggleGroupRecipe {
+  __slot: ToggleGroupSlot
+  __type: ToggleGroupVariantProps
+  (props?: ToggleGroupVariantProps): Pretty<Record<ToggleGroupSlot, string>>
+  raw: (props?: ToggleGroupVariantProps) => ToggleGroupVariantProps
+  variantMap: ToggleGroupVariantMap
+  variantKeys: Array<keyof ToggleGroupVariant>
+  splitVariantProps<Props extends ToggleGroupVariantProps>(props: Props): [ToggleGroupVariantProps, Pretty<DistributiveOmit<Props, keyof ToggleGroupVariantProps>>]
+  getVariantProps: (props?: ToggleGroupVariantProps) => ToggleGroupVariantProps
+}
+
+
+export declare const toggleGroup: ToggleGroupRecipe

package/dist/recipes/toggle-group.mjs

@@ -0,0 +1,44 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const toggleGroupDefaultVariants = {}
+const toggleGroupCompoundVariants = []
+
+const toggleGroupSlotNames = [
+  [
+    "root",
+    "toggle-group__root"
+  ],
+  [
+    "item",
+    "toggle-group__item"
+  ]
+]
+const toggleGroupSlotFns = /* @__PURE__ */ toggleGroupSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, toggleGroupDefaultVariants, getSlotCompoundVariant(toggleGroupCompoundVariants, slotName))])
+
+const toggleGroupFn = memo((props = {}) => {
+  return Object.fromEntries(toggleGroupSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const toggleGroupVariantKeys = [
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...toggleGroupDefaultVariants, ...compact(variants) })
+
+export const toggleGroup = /* @__PURE__ */ Object.assign(toggleGroupFn, {
+  __recipe__: false,
+  __name__: 'toggleGroup',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: toggleGroupVariantKeys,
+  variantMap: {
+  "variant": [
+    "surface",
+    "outline"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, toggleGroupVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/tooltip.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TooltipVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid"
+}
+
+type TooltipVariantMap = {
+  [key in keyof TooltipVariant]: Array<TooltipVariant[key]>
+}
+
+type TooltipSlot = "trigger" | "arrow" | "arrowTip" | "positioner" | "content"
+
+export type TooltipVariantProps = {
+  [key in keyof TooltipVariant]?: ConditionalValue<TooltipVariant[key]> | undefined
+}
+
+export interface TooltipRecipe {
+  __slot: TooltipSlot
+  __type: TooltipVariantProps
+  (props?: TooltipVariantProps): Pretty<Record<TooltipSlot, string>>
+  raw: (props?: TooltipVariantProps) => TooltipVariantProps
+  variantMap: TooltipVariantMap
+  variantKeys: Array<keyof TooltipVariant>
+  splitVariantProps<Props extends TooltipVariantProps>(props: Props): [TooltipVariantProps, Pretty<DistributiveOmit<Props, keyof TooltipVariantProps>>]
+  getVariantProps: (props?: TooltipVariantProps) => TooltipVariantProps
+}
+
+
+export declare const tooltip: TooltipRecipe

package/dist/recipes/tooltip.mjs

@@ -0,0 +1,57 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tooltipDefaultVariants = {
+  "variant": "solid"
+}
+const tooltipCompoundVariants = []
+
+const tooltipSlotNames = [
+  [
+    "trigger",
+    "tooltip__trigger"
+  ],
+  [
+    "arrow",
+    "tooltip__arrow"
+  ],
+  [
+    "arrowTip",
+    "tooltip__arrowTip"
+  ],
+  [
+    "positioner",
+    "tooltip__positioner"
+  ],
+  [
+    "content",
+    "tooltip__content"
+  ]
+]
+const tooltipSlotFns = /* @__PURE__ */ tooltipSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tooltipDefaultVariants, getSlotCompoundVariant(tooltipCompoundVariants, slotName))])
+
+const tooltipFn = memo((props = {}) => {
+  return Object.fromEntries(tooltipSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tooltipVariantKeys = [
+  "variant"
+]
+const getVariantProps = (variants) => ({ ...tooltipDefaultVariants, ...compact(variants) })
+
+export const tooltip = /* @__PURE__ */ Object.assign(tooltipFn, {
+  __recipe__: false,
+  __name__: 'tooltip',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: tooltipVariantKeys,
+  variantMap: {
+  "variant": [
+    "solid"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tooltipVariantKeys)
+  },
+  getVariantProps
+})

package/dist/recipes/tree-view.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TreeViewVariant {
+  /**
+ * @default "sm"
+ */
+size: "sm"
+}
+
+type TreeViewVariantMap = {
+  [key in keyof TreeViewVariant]: Array<TreeViewVariant[key]>
+}
+
+type TreeViewSlot = "branch" | "branchContent" | "branchControl" | "branchIndentGuide" | "branchIndicator" | "branchText" | "branchTrigger" | "item" | "itemIndicator" | "itemText" | "label" | "nodeCheckbox" | "nodeRenameInput" | "root" | "tree"
+
+export type TreeViewVariantProps = {
+  [key in keyof TreeViewVariant]?: ConditionalValue<TreeViewVariant[key]> | undefined
+}
+
+export interface TreeViewRecipe {
+  __slot: TreeViewSlot
+  __type: TreeViewVariantProps
+  (props?: TreeViewVariantProps): Pretty<Record<TreeViewSlot, string>>
+  raw: (props?: TreeViewVariantProps) => TreeViewVariantProps
+  variantMap: TreeViewVariantMap
+  variantKeys: Array<keyof TreeViewVariant>
+  splitVariantProps<Props extends TreeViewVariantProps>(props: Props): [TreeViewVariantProps, Pretty<DistributiveOmit<Props, keyof TreeViewVariantProps>>]
+  getVariantProps: (props?: TreeViewVariantProps) => TreeViewVariantProps
+}
+
+
+export declare const treeView: TreeViewRecipe

package/dist/recipes/tree-view.mjs

@@ -0,0 +1,97 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const treeViewDefaultVariants = {
+  "size": "sm"
+}
+const treeViewCompoundVariants = []
+
+const treeViewSlotNames = [
+  [
+    "branch",
+    "tree-view__branch"
+  ],
+  [
+    "branchContent",
+    "tree-view__branchContent"
+  ],
+  [
+    "branchControl",
+    "tree-view__branchControl"
+  ],
+  [
+    "branchIndentGuide",
+    "tree-view__branchIndentGuide"
+  ],
+  [
+    "branchIndicator",
+    "tree-view__branchIndicator"
+  ],
+  [
+    "branchText",
+    "tree-view__branchText"
+  ],
+  [
+    "branchTrigger",
+    "tree-view__branchTrigger"
+  ],
+  [
+    "item",
+    "tree-view__item"
+  ],
+  [
+    "itemIndicator",
+    "tree-view__itemIndicator"
+  ],
+  [
+    "itemText",
+    "tree-view__itemText"
+  ],
+  [
+    "label",
+    "tree-view__label"
+  ],
+  [
+    "nodeCheckbox",
+    "tree-view__nodeCheckbox"
+  ],
+  [
+    "nodeRenameInput",
+    "tree-view__nodeRenameInput"
+  ],
+  [
+    "root",
+    "tree-view__root"
+  ],
+  [
+    "tree",
+    "tree-view__tree"
+  ]
+]
+const treeViewSlotFns = /* @__PURE__ */ treeViewSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, treeViewDefaultVariants, getSlotCompoundVariant(treeViewCompoundVariants, slotName))])
+
+const treeViewFn = memo((props = {}) => {
+  return Object.fromEntries(treeViewSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const treeViewVariantKeys = [
+  "size"
+]
+const getVariantProps = (variants) => ({ ...treeViewDefaultVariants, ...compact(variants) })
+
+export const treeView = /* @__PURE__ */ Object.assign(treeViewFn, {
+  __recipe__: false,
+  __name__: 'treeView',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: treeViewVariantKeys,
+  variantMap: {
+  "size": [
+    "sm"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, treeViewVariantKeys)
+  },
+  getVariantProps
+})

package/dist/tokens/index.d.ts

@@ -0,0 +1,9 @@
+/* eslint-disable */
+import type { Token } from './tokens';
+
+export declare const token: {
+  (path: Token, fallback?: string): string
+  var: (path: Token, fallback?: string) => string
+}
+
+export * from './tokens';