@svadmin/ui 0.70.0 → 0.73.0

package/dist/styled-system/recipes/product-workspace.js

@@ -0,0 +1,58 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productWorkspaceDefaultVariants = {
+  "hasSecondary": false
+}
+const productWorkspaceCompoundVariants = []
+
+const productWorkspaceSlotNames = [
+  [
+    "root",
+    "product-workspace__root"
+  ],
+  [
+    "summary",
+    "product-workspace__summary"
+  ],
+  [
+    "columns",
+    "product-workspace__columns"
+  ],
+  [
+    "primary",
+    "product-workspace__primary"
+  ],
+  [
+    "secondary",
+    "product-workspace__secondary"
+  ]
+]
+const productWorkspaceSlotFns = /* @__PURE__ */ productWorkspaceSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productWorkspaceDefaultVariants, getSlotCompoundVariant(productWorkspaceCompoundVariants, slotName))])
+
+const productWorkspaceFn = memo((props = {}) => {
+  return Object.fromEntries(productWorkspaceSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productWorkspaceVariantKeys = [
+  "hasSecondary"
+]
+const getVariantProps = (variants) => ({ ...productWorkspaceDefaultVariants, ...compact(variants) })
+
+export const productWorkspace = /* @__PURE__ */ Object.assign(productWorkspaceFn, {
+  __recipe__: false,
+  __name__: 'productWorkspace',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productWorkspaceVariantKeys,
+  variantMap: {
+  "hasSecondary": [
+    "true",
+    "false"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, productWorkspaceVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SurfaceMetricVariant {
+  /**
+ * @default "neutral"
+ */
+tone: "neutral" | "success" | "warning" | "danger" | "info"
+/**
+ * @default "comfortable"
+ */
+density: "comfortable" | "compact"
+}
+
+type SurfaceMetricVariantMap = {
+  [key in keyof SurfaceMetricVariant]: Array<SurfaceMetricVariant[key]>
+}
+
+type SurfaceMetricSlot = "root" | "card" | "description" | "state"
+
+export type SurfaceMetricVariantProps = {
+  [key in keyof SurfaceMetricVariant]?: ConditionalValue<SurfaceMetricVariant[key]> | undefined
+}
+
+export interface SurfaceMetricRecipe {
+  __slot: SurfaceMetricSlot
+  __type: SurfaceMetricVariantProps
+  (props?: SurfaceMetricVariantProps): Pretty<Record<SurfaceMetricSlot, string>>
+  raw: (props?: SurfaceMetricVariantProps) => SurfaceMetricVariantProps
+  variantMap: SurfaceMetricVariantMap
+  variantKeys: Array<keyof SurfaceMetricVariant>
+  splitVariantProps<Props extends SurfaceMetricVariantProps>(props: Props): [SurfaceMetricVariantProps, Pretty<DistributiveOmit<Props, keyof SurfaceMetricVariantProps>>]
+  getVariantProps: (props?: SurfaceMetricVariantProps) => SurfaceMetricVariantProps
+}
+
+
+export declare const surfaceMetric: SurfaceMetricRecipe

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,34 @@
+/* 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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,31 @@
+/* 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,32 @@
+/* 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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,31 @@
+/* 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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,31 @@
+/* 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

@@ -0,0 +1,24 @@
+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,
+})