@svadmin/ui 0.73.0 → 0.75.0

package/dist/styled-system/recipes/surface-metric.js

@@ -1,63 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const surfaceMetricDefaultVariants = {
-  "tone": "neutral",
-  "density": "comfortable"
-}
-const surfaceMetricCompoundVariants = []
-
-const surfaceMetricSlotNames = [
-  [
-    "root",
-    "surface-metric__root"
-  ],
-  [
-    "card",
-    "surface-metric__card"
-  ],
-  [
-    "description",
-    "surface-metric__description"
-  ],
-  [
-    "state",
-    "surface-metric__state"
-  ]
-]
-const surfaceMetricSlotFns = /* @__PURE__ */ surfaceMetricSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, surfaceMetricDefaultVariants, getSlotCompoundVariant(surfaceMetricCompoundVariants, slotName))])
-
-const surfaceMetricFn = memo((props = {}) => {
-  return Object.fromEntries(surfaceMetricSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const surfaceMetricVariantKeys = [
-  "tone",
-  "density"
-]
-const getVariantProps = (variants) => ({ ...surfaceMetricDefaultVariants, ...compact(variants) })
-
-export const surfaceMetric = /* @__PURE__ */ Object.assign(surfaceMetricFn, {
-  __recipe__: false,
-  __name__: 'surfaceMetric',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: surfaceMetricVariantKeys,
-  variantMap: {
-  "tone": [
-    "neutral",
-    "success",
-    "warning",
-    "danger",
-    "info"
-  ],
-  "density": [
-    "comfortable",
-    "compact"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, surfaceMetricVariantKeys)
-  },
-  getVariantProps
-})

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

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface SurfaceTableVariant {
-  /**
- * @default "comfortable"
- */
-density: "comfortable" | "compact"
-}
-
-type SurfaceTableVariantMap = {
-  [key in keyof SurfaceTableVariant]: Array<SurfaceTableVariant[key]>
-}
-
-type SurfaceTableSlot = "root" | "header" | "content" | "head" | "cell" | "state"
-
-export type SurfaceTableVariantProps = {
-  [key in keyof SurfaceTableVariant]?: ConditionalValue<SurfaceTableVariant[key]> | undefined
-}
-
-export interface SurfaceTableRecipe {
-  __slot: SurfaceTableSlot
-  __type: SurfaceTableVariantProps
-  (props?: SurfaceTableVariantProps): Pretty<Record<SurfaceTableSlot, string>>
-  raw: (props?: SurfaceTableVariantProps) => SurfaceTableVariantProps
-  variantMap: SurfaceTableVariantMap
-  variantKeys: Array<keyof SurfaceTableVariant>
-  splitVariantProps<Props extends SurfaceTableVariantProps>(props: Props): [SurfaceTableVariantProps, Pretty<DistributiveOmit<Props, keyof SurfaceTableVariantProps>>]
-  getVariantProps: (props?: SurfaceTableVariantProps) => SurfaceTableVariantProps
-}
-
-
-export declare const surfaceTable: SurfaceTableRecipe

package/dist/styled-system/recipes/surface-table.js

@@ -1,62 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const surfaceTableDefaultVariants = {
-  "density": "comfortable"
-}
-const surfaceTableCompoundVariants = []
-
-const surfaceTableSlotNames = [
-  [
-    "root",
-    "surface-table__root"
-  ],
-  [
-    "header",
-    "surface-table__header"
-  ],
-  [
-    "content",
-    "surface-table__content"
-  ],
-  [
-    "head",
-    "surface-table__head"
-  ],
-  [
-    "cell",
-    "surface-table__cell"
-  ],
-  [
-    "state",
-    "surface-table__state"
-  ]
-]
-const surfaceTableSlotFns = /* @__PURE__ */ surfaceTableSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, surfaceTableDefaultVariants, getSlotCompoundVariant(surfaceTableCompoundVariants, slotName))])
-
-const surfaceTableFn = memo((props = {}) => {
-  return Object.fromEntries(surfaceTableSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const surfaceTableVariantKeys = [
-  "density"
-]
-const getVariantProps = (variants) => ({ ...surfaceTableDefaultVariants, ...compact(variants) })
-
-export const surfaceTable = /* @__PURE__ */ Object.assign(surfaceTableFn, {
-  __recipe__: false,
-  __name__: 'surfaceTable',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: surfaceTableVariantKeys,
-  variantMap: {
-  "density": [
-    "comfortable",
-    "compact"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, surfaceTableVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/ui-badge.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface UiBadgeVariant {
-  variant: "default" | "secondary" | "destructive" | "subtle" | "subtle-success" | "subtle-warning" | "subtle-destructive" | "subtle-pill" | "outline" | "ghost" | "link"
-}
-
-type UiBadgeVariantMap = {
-  [key in keyof UiBadgeVariant]: Array<UiBadgeVariant[key]>
-}
-
-
-
-export type UiBadgeVariantProps = {
-  [key in keyof UiBadgeVariant]?: ConditionalValue<UiBadgeVariant[key]> | undefined
-}
-
-export interface UiBadgeRecipe {
-  
-  __type: UiBadgeVariantProps
-  (props?: UiBadgeVariantProps): string
-  raw: (props?: UiBadgeVariantProps) => UiBadgeVariantProps
-  variantMap: UiBadgeVariantMap
-  variantKeys: Array<keyof UiBadgeVariant>
-  splitVariantProps<Props extends UiBadgeVariantProps>(props: Props): [UiBadgeVariantProps, Pretty<DistributiveOmit<Props, keyof UiBadgeVariantProps>>]
-  getVariantProps: (props?: UiBadgeVariantProps) => UiBadgeVariantProps
-}
-
-
-export declare const uiBadge: UiBadgeRecipe

package/dist/styled-system/recipes/ui-badge.js

@@ -1,38 +0,0 @@
-import { memo, splitProps } from '../helpers.js';
-import { createRecipe, mergeRecipes } from './create-recipe.js';
-
-const uiBadgeFn = /* @__PURE__ */ createRecipe('ui-badge', {}, [])
-
-const uiBadgeVariantMap = {
-  "variant": [
-    "default",
-    "secondary",
-    "destructive",
-    "subtle",
-    "subtle-success",
-    "subtle-warning",
-    "subtle-destructive",
-    "subtle-pill",
-    "outline",
-    "ghost",
-    "link"
-  ]
-}
-
-const uiBadgeVariantKeys = Object.keys(uiBadgeVariantMap)
-
-export const uiBadge = /* @__PURE__ */ Object.assign(memo(uiBadgeFn.recipeFn), {
-  __recipe__: true,
-  __name__: 'uiBadge',
-  __getCompoundVariantCss__: uiBadgeFn.__getCompoundVariantCss__,
-  raw: (props) => props,
-  variantKeys: uiBadgeVariantKeys,
-  variantMap: uiBadgeVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
-  splitVariantProps(props) {
-    return splitProps(props, uiBadgeVariantKeys)
-  },
-  getVariantProps: uiBadgeFn.getVariantProps,
-})

package/dist/styled-system/recipes/ui-button.d.ts

@@ -1,32 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface UiButtonVariant {
-  variant: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link"
-size: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg"
-}
-
-type UiButtonVariantMap = {
-  [key in keyof UiButtonVariant]: Array<UiButtonVariant[key]>
-}
-
-
-
-export type UiButtonVariantProps = {
-  [key in keyof UiButtonVariant]?: ConditionalValue<UiButtonVariant[key]> | undefined
-}
-
-export interface UiButtonRecipe {
-  
-  __type: UiButtonVariantProps
-  (props?: UiButtonVariantProps): string
-  raw: (props?: UiButtonVariantProps) => UiButtonVariantProps
-  variantMap: UiButtonVariantMap
-  variantKeys: Array<keyof UiButtonVariant>
-  splitVariantProps<Props extends UiButtonVariantProps>(props: Props): [UiButtonVariantProps, Pretty<DistributiveOmit<Props, keyof UiButtonVariantProps>>]
-  getVariantProps: (props?: UiButtonVariantProps) => UiButtonVariantProps
-}
-
-
-export declare const uiButton: UiButtonRecipe

package/dist/styled-system/recipes/ui-button.js

@@ -1,43 +0,0 @@
-import { memo, splitProps } from '../helpers.js';
-import { createRecipe, mergeRecipes } from './create-recipe.js';
-
-const uiButtonFn = /* @__PURE__ */ createRecipe('ui-button', {}, [])
-
-const uiButtonVariantMap = {
-  "variant": [
-    "default",
-    "outline",
-    "secondary",
-    "ghost",
-    "destructive",
-    "link"
-  ],
-  "size": [
-    "default",
-    "xs",
-    "sm",
-    "lg",
-    "icon",
-    "icon-xs",
-    "icon-sm",
-    "icon-lg"
-  ]
-}
-
-const uiButtonVariantKeys = Object.keys(uiButtonVariantMap)
-
-export const uiButton = /* @__PURE__ */ Object.assign(memo(uiButtonFn.recipeFn), {
-  __recipe__: true,
-  __name__: 'uiButton',
-  __getCompoundVariantCss__: uiButtonFn.__getCompoundVariantCss__,
-  raw: (props) => props,
-  variantKeys: uiButtonVariantKeys,
-  variantMap: uiButtonVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
-  splitVariantProps(props) {
-    return splitProps(props, uiButtonVariantKeys)
-  },
-  getVariantProps: uiButtonFn.getVariantProps,
-})

package/dist/styled-system/recipes/ui-input.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface UiInputVariant {
-  
-}
-
-type UiInputVariantMap = {
-  [key in keyof UiInputVariant]: Array<UiInputVariant[key]>
-}
-
-type UiInputSlot = "root" | "control" | "visual" | "button" | "name"
-
-export type UiInputVariantProps = {
-  [key in keyof UiInputVariant]?: ConditionalValue<UiInputVariant[key]> | undefined
-}
-
-export interface UiInputRecipe {
-  __slot: UiInputSlot
-  __type: UiInputVariantProps
-  (props?: UiInputVariantProps): Pretty<Record<UiInputSlot, string>>
-  raw: (props?: UiInputVariantProps) => UiInputVariantProps
-  variantMap: UiInputVariantMap
-  variantKeys: Array<keyof UiInputVariant>
-  splitVariantProps<Props extends UiInputVariantProps>(props: Props): [UiInputVariantProps, Pretty<DistributiveOmit<Props, keyof UiInputVariantProps>>]
-  getVariantProps: (props?: UiInputVariantProps) => UiInputVariantProps
-}
-
-
-export declare const uiInput: UiInputRecipe

package/dist/styled-system/recipes/ui-input.js

@@ -1,49 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const uiInputDefaultVariants = {}
-const uiInputCompoundVariants = []
-
-const uiInputSlotNames = [
-  [
-    "root",
-    "ui-input__root"
-  ],
-  [
-    "control",
-    "ui-input__control"
-  ],
-  [
-    "visual",
-    "ui-input__visual"
-  ],
-  [
-    "button",
-    "ui-input__button"
-  ],
-  [
-    "name",
-    "ui-input__name"
-  ]
-]
-const uiInputSlotFns = /* @__PURE__ */ uiInputSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, uiInputDefaultVariants, getSlotCompoundVariant(uiInputCompoundVariants, slotName))])
-
-const uiInputFn = memo((props = {}) => {
-  return Object.fromEntries(uiInputSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const uiInputVariantKeys = []
-const getVariantProps = (variants) => ({ ...uiInputDefaultVariants, ...compact(variants) })
-
-export const uiInput = /* @__PURE__ */ Object.assign(uiInputFn, {
-  __recipe__: false,
-  __name__: 'uiInput',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: uiInputVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, uiInputVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/ui-textarea.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface UiTextareaVariant {
-  
-}
-
-type UiTextareaVariantMap = {
-  [key in keyof UiTextareaVariant]: Array<UiTextareaVariant[key]>
-}
-
-
-
-export type UiTextareaVariantProps = {
-  [key in keyof UiTextareaVariant]?: ConditionalValue<UiTextareaVariant[key]> | undefined
-}
-
-export interface UiTextareaRecipe {
-  
-  __type: UiTextareaVariantProps
-  (props?: UiTextareaVariantProps): string
-  raw: (props?: UiTextareaVariantProps) => UiTextareaVariantProps
-  variantMap: UiTextareaVariantMap
-  variantKeys: Array<keyof UiTextareaVariant>
-  splitVariantProps<Props extends UiTextareaVariantProps>(props: Props): [UiTextareaVariantProps, Pretty<DistributiveOmit<Props, keyof UiTextareaVariantProps>>]
-  getVariantProps: (props?: UiTextareaVariantProps) => UiTextareaVariantProps
-}
-
-
-export declare const uiTextarea: UiTextareaRecipe

package/dist/styled-system/recipes/ui-textarea.js

@@ -1,24 +0,0 @@
-import { memo, splitProps } from '../helpers.js';
-import { createRecipe, mergeRecipes } from './create-recipe.js';
-
-const uiTextareaFn = /* @__PURE__ */ createRecipe('ui-textarea', {}, [])
-
-const uiTextareaVariantMap = {}
-
-const uiTextareaVariantKeys = Object.keys(uiTextareaVariantMap)
-
-export const uiTextarea = /* @__PURE__ */ Object.assign(memo(uiTextareaFn.recipeFn), {
-  __recipe__: true,
-  __name__: 'uiTextarea',
-  __getCompoundVariantCss__: uiTextareaFn.__getCompoundVariantCss__,
-  raw: (props) => props,
-  variantKeys: uiTextareaVariantKeys,
-  variantMap: uiTextareaVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
-  splitVariantProps(props) {
-    return splitProps(props, uiTextareaVariantKeys)
-  },
-  getVariantProps: uiTextareaFn.getVariantProps,
-})