@svadmin/surface 0.8.19 → 0.9.0

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

@@ -0,0 +1,49 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productSectionDefaultVariants = {}
+const productSectionCompoundVariants = []
+
+const productSectionSlotNames = [
+  [
+    "root",
+    "product-section__root"
+  ],
+  [
+    "heading",
+    "product-section__heading"
+  ],
+  [
+    "title",
+    "product-section__title"
+  ],
+  [
+    "description",
+    "product-section__description"
+  ],
+  [
+    "actions",
+    "product-section__actions"
+  ]
+]
+const productSectionSlotFns = /* @__PURE__ */ productSectionSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productSectionDefaultVariants, getSlotCompoundVariant(productSectionCompoundVariants, slotName))])
+
+const productSectionFn = memo((props = {}) => {
+  return Object.fromEntries(productSectionSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productSectionVariantKeys = []
+const getVariantProps = (variants) => ({ ...productSectionDefaultVariants, ...compact(variants) })
+
+export const productSection = /* @__PURE__ */ Object.assign(productSectionFn, {
+  __recipe__: false,
+  __name__: 'productSection',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productSectionVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, productSectionVariantKeys)
+  },
+  getVariantProps
+})

package/dist/styled-system/recipes/product-settings-row.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductSettingsRowVariant {
+  /**
+ * @default false
+ */
+separated: boolean
+}
+
+type ProductSettingsRowVariantMap = {
+  [key in keyof ProductSettingsRowVariant]: Array<ProductSettingsRowVariant[key]>
+}
+
+type ProductSettingsRowSlot = "root" | "heading" | "label" | "description" | "control"
+
+export type ProductSettingsRowVariantProps = {
+  [key in keyof ProductSettingsRowVariant]?: ConditionalValue<ProductSettingsRowVariant[key]> | undefined
+}
+
+export interface ProductSettingsRowRecipe {
+  __slot: ProductSettingsRowSlot
+  __type: ProductSettingsRowVariantProps
+  (props?: ProductSettingsRowVariantProps): Pretty<Record<ProductSettingsRowSlot, string>>
+  raw: (props?: ProductSettingsRowVariantProps) => ProductSettingsRowVariantProps
+  variantMap: ProductSettingsRowVariantMap
+  variantKeys: Array<keyof ProductSettingsRowVariant>
+  splitVariantProps<Props extends ProductSettingsRowVariantProps>(props: Props): [ProductSettingsRowVariantProps, Pretty<DistributiveOmit<Props, keyof ProductSettingsRowVariantProps>>]
+  getVariantProps: (props?: ProductSettingsRowVariantProps) => ProductSettingsRowVariantProps
+}
+
+
+export declare const productSettingsRow: ProductSettingsRowRecipe

package/dist/styled-system/recipes/product-settings-row.js

@@ -0,0 +1,58 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productSettingsRowDefaultVariants = {
+  "separated": false
+}
+const productSettingsRowCompoundVariants = []
+
+const productSettingsRowSlotNames = [
+  [
+    "root",
+    "product-settings-row__root"
+  ],
+  [
+    "heading",
+    "product-settings-row__heading"
+  ],
+  [
+    "label",
+    "product-settings-row__label"
+  ],
+  [
+    "description",
+    "product-settings-row__description"
+  ],
+  [
+    "control",
+    "product-settings-row__control"
+  ]
+]
+const productSettingsRowSlotFns = /* @__PURE__ */ productSettingsRowSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productSettingsRowDefaultVariants, getSlotCompoundVariant(productSettingsRowCompoundVariants, slotName))])
+
+const productSettingsRowFn = memo((props = {}) => {
+  return Object.fromEntries(productSettingsRowSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productSettingsRowVariantKeys = [
+  "separated"
+]
+const getVariantProps = (variants) => ({ ...productSettingsRowDefaultVariants, ...compact(variants) })
+
+export const productSettingsRow = /* @__PURE__ */ Object.assign(productSettingsRowFn, {
+  __recipe__: false,
+  __name__: 'productSettingsRow',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productSettingsRowVariantKeys,
+  variantMap: {
+  "separated": [
+    "true",
+    "false"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, productSettingsRowVariantKeys)
+  },
+  getVariantProps
+})

package/dist/styled-system/recipes/product-settings.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductSettingsVariant {
+  
+}
+
+type ProductSettingsVariantMap = {
+  [key in keyof ProductSettingsVariant]: Array<ProductSettingsVariant[key]>
+}
+
+type ProductSettingsSlot = "root" | "header" | "heading" | "title" | "description" | "actions" | "body"
+
+export type ProductSettingsVariantProps = {
+  [key in keyof ProductSettingsVariant]?: ConditionalValue<ProductSettingsVariant[key]> | undefined
+}
+
+export interface ProductSettingsRecipe {
+  __slot: ProductSettingsSlot
+  __type: ProductSettingsVariantProps
+  (props?: ProductSettingsVariantProps): Pretty<Record<ProductSettingsSlot, string>>
+  raw: (props?: ProductSettingsVariantProps) => ProductSettingsVariantProps
+  variantMap: ProductSettingsVariantMap
+  variantKeys: Array<keyof ProductSettingsVariant>
+  splitVariantProps<Props extends ProductSettingsVariantProps>(props: Props): [ProductSettingsVariantProps, Pretty<DistributiveOmit<Props, keyof ProductSettingsVariantProps>>]
+  getVariantProps: (props?: ProductSettingsVariantProps) => ProductSettingsVariantProps
+}
+
+
+export declare const productSettings: ProductSettingsRecipe

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

@@ -0,0 +1,57 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productSettingsDefaultVariants = {}
+const productSettingsCompoundVariants = []
+
+const productSettingsSlotNames = [
+  [
+    "root",
+    "product-settings__root"
+  ],
+  [
+    "header",
+    "product-settings__header"
+  ],
+  [
+    "heading",
+    "product-settings__heading"
+  ],
+  [
+    "title",
+    "product-settings__title"
+  ],
+  [
+    "description",
+    "product-settings__description"
+  ],
+  [
+    "actions",
+    "product-settings__actions"
+  ],
+  [
+    "body",
+    "product-settings__body"
+  ]
+]
+const productSettingsSlotFns = /* @__PURE__ */ productSettingsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productSettingsDefaultVariants, getSlotCompoundVariant(productSettingsCompoundVariants, slotName))])
+
+const productSettingsFn = memo((props = {}) => {
+  return Object.fromEntries(productSettingsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productSettingsVariantKeys = []
+const getVariantProps = (variants) => ({ ...productSettingsDefaultVariants, ...compact(variants) })
+
+export const productSettings = /* @__PURE__ */ Object.assign(productSettingsFn, {
+  __recipe__: false,
+  __name__: 'productSettings',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productSettingsVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, productSettingsVariantKeys)
+  },
+  getVariantProps
+})

package/dist/styled-system/recipes/product-status.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductStatusVariant {
+  /**
+ * @default "neutral"
+ */
+status: "success" | "warning" | "danger" | "info" | "neutral"
+}
+
+type ProductStatusVariantMap = {
+  [key in keyof ProductStatusVariant]: Array<ProductStatusVariant[key]>
+}
+
+type ProductStatusSlot = "root"
+
+export type ProductStatusVariantProps = {
+  [key in keyof ProductStatusVariant]?: ConditionalValue<ProductStatusVariant[key]> | undefined
+}
+
+export interface ProductStatusRecipe {
+  __slot: ProductStatusSlot
+  __type: ProductStatusVariantProps
+  (props?: ProductStatusVariantProps): Pretty<Record<ProductStatusSlot, string>>
+  raw: (props?: ProductStatusVariantProps) => ProductStatusVariantProps
+  variantMap: ProductStatusVariantMap
+  variantKeys: Array<keyof ProductStatusVariant>
+  splitVariantProps<Props extends ProductStatusVariantProps>(props: Props): [ProductStatusVariantProps, Pretty<DistributiveOmit<Props, keyof ProductStatusVariantProps>>]
+  getVariantProps: (props?: ProductStatusVariantProps) => ProductStatusVariantProps
+}
+
+
+export declare const productStatus: ProductStatusRecipe

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

@@ -0,0 +1,45 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productStatusDefaultVariants = {
+  "status": "neutral"
+}
+const productStatusCompoundVariants = []
+
+const productStatusSlotNames = [
+  [
+    "root",
+    "product-status__root"
+  ]
+]
+const productStatusSlotFns = /* @__PURE__ */ productStatusSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productStatusDefaultVariants, getSlotCompoundVariant(productStatusCompoundVariants, slotName))])
+
+const productStatusFn = memo((props = {}) => {
+  return Object.fromEntries(productStatusSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productStatusVariantKeys = [
+  "status"
+]
+const getVariantProps = (variants) => ({ ...productStatusDefaultVariants, ...compact(variants) })
+
+export const productStatus = /* @__PURE__ */ Object.assign(productStatusFn, {
+  __recipe__: false,
+  __name__: 'productStatus',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productStatusVariantKeys,
+  variantMap: {
+  "status": [
+    "success",
+    "warning",
+    "danger",
+    "info",
+    "neutral"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, productStatusVariantKeys)
+  },
+  getVariantProps
+})

package/dist/styled-system/recipes/product-toolbar.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductToolbarVariant {
+  
+}
+
+type ProductToolbarVariantMap = {
+  [key in keyof ProductToolbarVariant]: Array<ProductToolbarVariant[key]>
+}
+
+type ProductToolbarSlot = "root" | "leading" | "trailing"
+
+export type ProductToolbarVariantProps = {
+  [key in keyof ProductToolbarVariant]?: ConditionalValue<ProductToolbarVariant[key]> | undefined
+}
+
+export interface ProductToolbarRecipe {
+  __slot: ProductToolbarSlot
+  __type: ProductToolbarVariantProps
+  (props?: ProductToolbarVariantProps): Pretty<Record<ProductToolbarSlot, string>>
+  raw: (props?: ProductToolbarVariantProps) => ProductToolbarVariantProps
+  variantMap: ProductToolbarVariantMap
+  variantKeys: Array<keyof ProductToolbarVariant>
+  splitVariantProps<Props extends ProductToolbarVariantProps>(props: Props): [ProductToolbarVariantProps, Pretty<DistributiveOmit<Props, keyof ProductToolbarVariantProps>>]
+  getVariantProps: (props?: ProductToolbarVariantProps) => ProductToolbarVariantProps
+}
+
+
+export declare const productToolbar: ProductToolbarRecipe

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

@@ -0,0 +1,41 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productToolbarDefaultVariants = {}
+const productToolbarCompoundVariants = []
+
+const productToolbarSlotNames = [
+  [
+    "root",
+    "product-toolbar__root"
+  ],
+  [
+    "leading",
+    "product-toolbar__leading"
+  ],
+  [
+    "trailing",
+    "product-toolbar__trailing"
+  ]
+]
+const productToolbarSlotFns = /* @__PURE__ */ productToolbarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productToolbarDefaultVariants, getSlotCompoundVariant(productToolbarCompoundVariants, slotName))])
+
+const productToolbarFn = memo((props = {}) => {
+  return Object.fromEntries(productToolbarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productToolbarVariantKeys = []
+const getVariantProps = (variants) => ({ ...productToolbarDefaultVariants, ...compact(variants) })
+
+export const productToolbar = /* @__PURE__ */ Object.assign(productToolbarFn, {
+  __recipe__: false,
+  __name__: 'productToolbar',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productToolbarVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, productToolbarVariantKeys)
+  },
+  getVariantProps
+})

package/dist/styled-system/recipes/product-workspace.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductWorkspaceVariant {
+  /**
+ * @default false
+ */
+hasSecondary: boolean
+}
+
+type ProductWorkspaceVariantMap = {
+  [key in keyof ProductWorkspaceVariant]: Array<ProductWorkspaceVariant[key]>
+}
+
+type ProductWorkspaceSlot = "root" | "summary" | "columns" | "primary" | "secondary"
+
+export type ProductWorkspaceVariantProps = {
+  [key in keyof ProductWorkspaceVariant]?: ConditionalValue<ProductWorkspaceVariant[key]> | undefined
+}
+
+export interface ProductWorkspaceRecipe {
+  __slot: ProductWorkspaceSlot
+  __type: ProductWorkspaceVariantProps
+  (props?: ProductWorkspaceVariantProps): Pretty<Record<ProductWorkspaceSlot, string>>
+  raw: (props?: ProductWorkspaceVariantProps) => ProductWorkspaceVariantProps
+  variantMap: ProductWorkspaceVariantMap
+  variantKeys: Array<keyof ProductWorkspaceVariant>
+  splitVariantProps<Props extends ProductWorkspaceVariantProps>(props: Props): [ProductWorkspaceVariantProps, Pretty<DistributiveOmit<Props, keyof ProductWorkspaceVariantProps>>]
+  getVariantProps: (props?: ProductWorkspaceVariantProps) => ProductWorkspaceVariantProps
+}
+
+
+export declare const productWorkspace: ProductWorkspaceRecipe

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
+})