@svadmin/ui 0.70.0 → 0.73.0

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

@@ -0,0 +1,76 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const metricBlockDefaultVariants = {
+  "trendTone": "neutral"
+}
+const metricBlockCompoundVariants = []
+
+const metricBlockSlotNames = [
+  [
+    "root",
+    "metric-block__root"
+  ],
+  [
+    "header",
+    "metric-block__header"
+  ],
+  [
+    "label",
+    "metric-block__label"
+  ],
+  [
+    "icon",
+    "metric-block__icon"
+  ],
+  [
+    "skeleton",
+    "metric-block__skeleton"
+  ],
+  [
+    "value",
+    "metric-block__value"
+  ],
+  [
+    "meta",
+    "metric-block__meta"
+  ],
+  [
+    "trend",
+    "metric-block__trend"
+  ],
+  [
+    "detail",
+    "metric-block__detail"
+  ]
+]
+const metricBlockSlotFns = /* @__PURE__ */ metricBlockSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, metricBlockDefaultVariants, getSlotCompoundVariant(metricBlockCompoundVariants, slotName))])
+
+const metricBlockFn = memo((props = {}) => {
+  return Object.fromEntries(metricBlockSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const metricBlockVariantKeys = [
+  "trendTone"
+]
+const getVariantProps = (variants) => ({ ...metricBlockDefaultVariants, ...compact(variants) })
+
+export const metricBlock = /* @__PURE__ */ Object.assign(metricBlockFn, {
+  __recipe__: false,
+  __name__: 'metricBlock',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: metricBlockVariantKeys,
+  variantMap: {
+  "trendTone": [
+    "positive",
+    "negative",
+    "warning",
+    "neutral"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, metricBlockVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProductListVariant {
+  
+}
+
+type ProductListVariantMap = {
+  [key in keyof ProductListVariant]: Array<ProductListVariant[key]>
+}
+
+type ProductListSlot = "filters" | "filter" | "filterCount" | "table" | "identity" | "avatar" | "name" | "secondary" | "numeric" | "footer" | "help"
+
+export type ProductListVariantProps = {
+  [key in keyof ProductListVariant]?: ConditionalValue<ProductListVariant[key]> | undefined
+}
+
+export interface ProductListRecipe {
+  __slot: ProductListSlot
+  __type: ProductListVariantProps
+  (props?: ProductListVariantProps): Pretty<Record<ProductListSlot, string>>
+  raw: (props?: ProductListVariantProps) => ProductListVariantProps
+  variantMap: ProductListVariantMap
+  variantKeys: Array<keyof ProductListVariant>
+  splitVariantProps<Props extends ProductListVariantProps>(props: Props): [ProductListVariantProps, Pretty<DistributiveOmit<Props, keyof ProductListVariantProps>>]
+  getVariantProps: (props?: ProductListVariantProps) => ProductListVariantProps
+}
+
+
+export declare const productList: ProductListRecipe

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

@@ -0,0 +1,73 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const productListDefaultVariants = {}
+const productListCompoundVariants = []
+
+const productListSlotNames = [
+  [
+    "filters",
+    "product-list__filters"
+  ],
+  [
+    "filter",
+    "product-list__filter"
+  ],
+  [
+    "filterCount",
+    "product-list__filterCount"
+  ],
+  [
+    "table",
+    "product-list__table"
+  ],
+  [
+    "identity",
+    "product-list__identity"
+  ],
+  [
+    "avatar",
+    "product-list__avatar"
+  ],
+  [
+    "name",
+    "product-list__name"
+  ],
+  [
+    "secondary",
+    "product-list__secondary"
+  ],
+  [
+    "numeric",
+    "product-list__numeric"
+  ],
+  [
+    "footer",
+    "product-list__footer"
+  ],
+  [
+    "help",
+    "product-list__help"
+  ]
+]
+const productListSlotFns = /* @__PURE__ */ productListSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productListDefaultVariants, getSlotCompoundVariant(productListCompoundVariants, slotName))])
+
+const productListFn = memo((props = {}) => {
+  return Object.fromEntries(productListSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const productListVariantKeys = []
+const getVariantProps = (variants) => ({ ...productListDefaultVariants, ...compact(variants) })
+
+export const productList = /* @__PURE__ */ Object.assign(productListFn, {
+  __recipe__: false,
+  __name__: 'productList',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: productListVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, productListVariantKeys)
+  },
+  getVariantProps
+})

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

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

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