@svadmin/surface 0.9.0 → 0.10.0

package/dist/styled-system/patterns/wrap.js

@@ -1,25 +0,0 @@
-import { getPatternStyles, patternFns } from '../helpers.js';
-import { css } from '../css/index.js';
-
-const wrapConfig = {
-transform(props) {
-  const { columnGap, rowGap, gap = columnGap || rowGap ? void 0 : "8px", align, justify, ...rest } = props;
-  return {
-    display: "flex",
-    flexWrap: "wrap",
-    alignItems: align,
-    justifyContent: justify,
-    gap,
-    columnGap,
-    rowGap,
-    ...rest
-  };
-}}
-
-export const getWrapStyle = (styles = {}) => {
-  const _styles = getPatternStyles(wrapConfig, styles)
-  return wrapConfig.transform(_styles, patternFns)
-}
-
-export const wrap = (styles) => css(getWrapStyle(styles))
-wrap.raw = getWrapStyle

package/dist/styled-system/recipes/content-header.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ContentHeaderVariant {
-  
-}
-
-type ContentHeaderVariantMap = {
-  [key in keyof ContentHeaderVariant]: Array<ContentHeaderVariant[key]>
-}
-
-type ContentHeaderSlot = "root" | "breadcrumbs" | "currentCrumb" | "row" | "heading" | "eyebrow" | "title" | "description" | "actions"
-
-export type ContentHeaderVariantProps = {
-  [key in keyof ContentHeaderVariant]?: ConditionalValue<ContentHeaderVariant[key]> | undefined
-}
-
-export interface ContentHeaderRecipe {
-  __slot: ContentHeaderSlot
-  __type: ContentHeaderVariantProps
-  (props?: ContentHeaderVariantProps): Pretty<Record<ContentHeaderSlot, string>>
-  raw: (props?: ContentHeaderVariantProps) => ContentHeaderVariantProps
-  variantMap: ContentHeaderVariantMap
-  variantKeys: Array<keyof ContentHeaderVariant>
-  splitVariantProps<Props extends ContentHeaderVariantProps>(props: Props): [ContentHeaderVariantProps, Pretty<DistributiveOmit<Props, keyof ContentHeaderVariantProps>>]
-  getVariantProps: (props?: ContentHeaderVariantProps) => ContentHeaderVariantProps
-}
-
-
-export declare const contentHeader: ContentHeaderRecipe

package/dist/styled-system/recipes/content-header.js

@@ -1,65 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const contentHeaderDefaultVariants = {}
-const contentHeaderCompoundVariants = []
-
-const contentHeaderSlotNames = [
-  [
-    "root",
-    "content-header__root"
-  ],
-  [
-    "breadcrumbs",
-    "content-header__breadcrumbs"
-  ],
-  [
-    "currentCrumb",
-    "content-header__currentCrumb"
-  ],
-  [
-    "row",
-    "content-header__row"
-  ],
-  [
-    "heading",
-    "content-header__heading"
-  ],
-  [
-    "eyebrow",
-    "content-header__eyebrow"
-  ],
-  [
-    "title",
-    "content-header__title"
-  ],
-  [
-    "description",
-    "content-header__description"
-  ],
-  [
-    "actions",
-    "content-header__actions"
-  ]
-]
-const contentHeaderSlotFns = /* @__PURE__ */ contentHeaderSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, contentHeaderDefaultVariants, getSlotCompoundVariant(contentHeaderCompoundVariants, slotName))])
-
-const contentHeaderFn = memo((props = {}) => {
-  return Object.fromEntries(contentHeaderSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const contentHeaderVariantKeys = []
-const getVariantProps = (variants) => ({ ...contentHeaderDefaultVariants, ...compact(variants) })
-
-export const contentHeader = /* @__PURE__ */ Object.assign(contentHeaderFn, {
-  __recipe__: false,
-  __name__: 'contentHeader',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: contentHeaderVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, contentHeaderVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/content-page.d.ts

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ContentPageVariant {
-  /**
- * @default "default"
- */
-width: "narrow" | "default" | "wide"
-}
-
-type ContentPageVariantMap = {
-  [key in keyof ContentPageVariant]: Array<ContentPageVariant[key]>
-}
-
-type ContentPageSlot = "root"
-
-export type ContentPageVariantProps = {
-  [key in keyof ContentPageVariant]?: ConditionalValue<ContentPageVariant[key]> | undefined
-}
-
-export interface ContentPageRecipe {
-  __slot: ContentPageSlot
-  __type: ContentPageVariantProps
-  (props?: ContentPageVariantProps): Pretty<Record<ContentPageSlot, string>>
-  raw: (props?: ContentPageVariantProps) => ContentPageVariantProps
-  variantMap: ContentPageVariantMap
-  variantKeys: Array<keyof ContentPageVariant>
-  splitVariantProps<Props extends ContentPageVariantProps>(props: Props): [ContentPageVariantProps, Pretty<DistributiveOmit<Props, keyof ContentPageVariantProps>>]
-  getVariantProps: (props?: ContentPageVariantProps) => ContentPageVariantProps
-}
-
-
-export declare const contentPage: ContentPageRecipe

package/dist/styled-system/recipes/content-page.js

@@ -1,43 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const contentPageDefaultVariants = {
-  "width": "default"
-}
-const contentPageCompoundVariants = []
-
-const contentPageSlotNames = [
-  [
-    "root",
-    "content-page__root"
-  ]
-]
-const contentPageSlotFns = /* @__PURE__ */ contentPageSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, contentPageDefaultVariants, getSlotCompoundVariant(contentPageCompoundVariants, slotName))])
-
-const contentPageFn = memo((props = {}) => {
-  return Object.fromEntries(contentPageSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const contentPageVariantKeys = [
-  "width"
-]
-const getVariantProps = (variants) => ({ ...contentPageDefaultVariants, ...compact(variants) })
-
-export const contentPage = /* @__PURE__ */ Object.assign(contentPageFn, {
-  __recipe__: false,
-  __name__: 'contentPage',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: contentPageVariantKeys,
-  variantMap: {
-  "width": [
-    "narrow",
-    "default",
-    "wide"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, contentPageVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/create-recipe.js

@@ -1,82 +0,0 @@
-import { finalizeConditions, sortConditions } from '../css/conditions.js';
-import { css } from '../css/css.js';
-import { assertCompoundVariant, getCompoundVariantCss } from '../css/cva.js';
-import { cx } from '../css/cx.js';
-import { compact, createCss, splitProps, uniq, withoutSpace } from '../helpers.js';
-
-export const createRecipe = (name, defaultVariants, compoundVariants) => {
- const getVariantProps = (variants) => {
-   return {
-     [name]: '__ignore__',
-     ...defaultVariants,
-     ...compact(variants),
-   };
- };
-
-  const recipeFn = (variants, withCompoundVariants = true) => {
-   const transform = (prop, value) => {
-     assertCompoundVariant(name, compoundVariants, variants, prop)
-
-      if (value === '__ignore__') {
-        return { className: name }
-      }
-
-      value = withoutSpace(value)
-      return { className: `${name}--${prop}_${value}` }
-   }
-
-   const recipeCss = createCss({
-     
-     conditions: {
-       shift: sortConditions,
-       finalize: finalizeConditions,
-       breakpoints: { keys: ["base"] }
-     },
-     utility: {
-       prefix: "svadmin",
-       toHash: (path, hashFn) => hashFn(path.join(":")),
-       transform,
-     }
-   })
-
-   const recipeStyles = getVariantProps(variants)
-
-   if (withCompoundVariants) {
-     const compoundVariantStyles = getCompoundVariantCss(compoundVariants, recipeStyles)
-     return cx(recipeCss(recipeStyles), css(compoundVariantStyles))
-   }
-
-   return recipeCss(recipeStyles)
-  }
-
-   return {
-     recipeFn,
-     getVariantProps,
-     __getCompoundVariantCss__: (variants) => {
-       return getCompoundVariantCss(compoundVariants, getVariantProps(variants));
-     },
-   }
-}
-
-export const mergeRecipes = (recipeA, recipeB) => {
- if (recipeA && !recipeB) return recipeA
- if (!recipeA && recipeB) return recipeB
-
- const recipeFn = (...args) => cx(recipeA(...args), recipeB(...args))
- const variantKeys = uniq(recipeA.variantKeys, recipeB.variantKeys)
- const variantMap = variantKeys.reduce((acc, key) => {
-   acc[key] = uniq(recipeA.variantMap[key], recipeB.variantMap[key])
-   return acc
- }, {})
-
- return Object.assign(recipeFn, {
-   __recipe__: true,
-   __name__: `${recipeA.__name__} ${recipeB.__name__}`,
-   raw: (props) => props,
-   variantKeys,
-   variantMap,
-   splitVariantProps(props) {
-     return splitProps(props, variantKeys)
-   },
- })
- }

package/dist/styled-system/recipes/index.d.ts

@@ -1,17 +0,0 @@
-/* eslint-disable */
-export * from './ui-button';
-export * from './ui-badge';
-export * from './ui-textarea';
-export * from './surface-metric';
-export * from './surface-table';
-export * from './ui-input';
-export * from './product-section';
-export * from './product-toolbar';
-export * from './product-workspace';
-export * from './product-settings';
-export * from './product-settings-row';
-export * from './product-list';
-export * from './product-status';
-export * from './content-page';
-export * from './content-header';
-export * from './metric-block';

package/dist/styled-system/recipes/index.js

@@ -1,16 +0,0 @@
-export * from './ui-button.js';
-export * from './ui-badge.js';
-export * from './ui-textarea.js';
-export * from './surface-metric.js';
-export * from './surface-table.js';
-export * from './ui-input.js';
-export * from './product-section.js';
-export * from './product-toolbar.js';
-export * from './product-workspace.js';
-export * from './product-settings.js';
-export * from './product-settings-row.js';
-export * from './product-list.js';
-export * from './product-status.js';
-export * from './content-page.js';
-export * from './content-header.js';
-export * from './metric-block.js';

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

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface MetricBlockVariant {
-  /**
- * @default "neutral"
- */
-trendTone: "positive" | "negative" | "warning" | "neutral"
-}
-
-type MetricBlockVariantMap = {
-  [key in keyof MetricBlockVariant]: Array<MetricBlockVariant[key]>
-}
-
-type MetricBlockSlot = "root" | "header" | "label" | "icon" | "skeleton" | "value" | "meta" | "trend" | "detail"
-
-export type MetricBlockVariantProps = {
-  [key in keyof MetricBlockVariant]?: ConditionalValue<MetricBlockVariant[key]> | undefined
-}
-
-export interface MetricBlockRecipe {
-  __slot: MetricBlockSlot
-  __type: MetricBlockVariantProps
-  (props?: MetricBlockVariantProps): Pretty<Record<MetricBlockSlot, string>>
-  raw: (props?: MetricBlockVariantProps) => MetricBlockVariantProps
-  variantMap: MetricBlockVariantMap
-  variantKeys: Array<keyof MetricBlockVariant>
-  splitVariantProps<Props extends MetricBlockVariantProps>(props: Props): [MetricBlockVariantProps, Pretty<DistributiveOmit<Props, keyof MetricBlockVariantProps>>]
-  getVariantProps: (props?: MetricBlockVariantProps) => MetricBlockVariantProps
-}
-
-
-export declare const metricBlock: MetricBlockRecipe

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

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

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

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

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

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

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