@stokelp/styled-system 1.21.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stokelp/styled-system",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Stokelp UI styled-system",
   "type": "module",
   "publishConfig": {

package/panda.buildinfo.json

@@ -138,6 +138,13 @@
       "radioGroup": [
         "size]___[value:md]___[recipe:radioGroup"
       ],
+      "table": [],
+      "tableGroupTitle": [
+        "variant]___[value:primary]___[recipe:tableGroupTitle",
+        "variant]___[value:secondary]___[recipe:tableGroupTitle"
+      ],
+      "tableEmptyRow": [],
+      "tableContainer": [],
       "tabs": [
         "variant]___[value:line]___[recipe:tabs"
       ],

package/recipes/index.d.ts

@@ -10,6 +10,9 @@ export * from './form-helper-text';
 export * from './input';
 export * from './input-addon';
 export * from './input-group';
+export * from './table-group-title';
+export * from './table-empty-row';
+export * from './table-container';
 export * from './drawer';
 export * from './radio-button-group';
 export * from './radio-group';
@@ -23,4 +26,5 @@ export * from './select';
 export * from './chip';
 export * from './action-card';
 export * from './tooltip';
-export * from './alert';
+export * from './alert';
+export * from './table';

package/recipes/index.mjs

@@ -9,6 +9,9 @@ export * from './form-helper-text.mjs';
 export * from './input.mjs';
 export * from './input-addon.mjs';
 export * from './input-group.mjs';
+export * from './table-group-title.mjs';
+export * from './table-empty-row.mjs';
+export * from './table-container.mjs';
 export * from './drawer.mjs';
 export * from './radio-button-group.mjs';
 export * from './radio-group.mjs';
@@ -22,4 +25,5 @@ export * from './select.mjs';
 export * from './chip.mjs';
 export * from './action-card.mjs';
 export * from './tooltip.mjs';
-export * from './alert.mjs';
+export * from './alert.mjs';
+export * from './table.mjs';

package/recipes/table-container.d.ts

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

package/recipes/table-container.mjs

@@ -0,0 +1,24 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableContainerFn = /* @__PURE__ */ createRecipe('table-container', {}, [])
+
+const tableContainerVariantMap = {}
+
+const tableContainerVariantKeys = Object.keys(tableContainerVariantMap)
+
+export const tableContainer = /* @__PURE__ */ Object.assign(memo(tableContainerFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'tableContainer',
+  __getCompoundVariantCss__: tableContainerFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: tableContainerVariantKeys,
+  variantMap: tableContainerVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableContainerVariantKeys)
+  },
+  getVariantProps: tableContainerFn.getVariantProps,
+})

package/recipes/table-empty-row.d.ts

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

package/recipes/table-empty-row.mjs

@@ -0,0 +1,24 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableEmptyRowFn = /* @__PURE__ */ createRecipe('table-empty-row', {}, [])
+
+const tableEmptyRowVariantMap = {}
+
+const tableEmptyRowVariantKeys = Object.keys(tableEmptyRowVariantMap)
+
+export const tableEmptyRow = /* @__PURE__ */ Object.assign(memo(tableEmptyRowFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'tableEmptyRow',
+  __getCompoundVariantCss__: tableEmptyRowFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: tableEmptyRowVariantKeys,
+  variantMap: tableEmptyRowVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableEmptyRowVariantKeys)
+  },
+  getVariantProps: tableEmptyRowFn.getVariantProps,
+})

package/recipes/table-group-title.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableGroupTitleVariant {
+  /**
+ * @default "primary"
+ */
+variant: "primary" | "secondary"
+}
+
+type TableGroupTitleVariantMap = {
+  [key in keyof TableGroupTitleVariant]: Array<TableGroupTitleVariant[key]>
+}
+
+export type TableGroupTitleVariantProps = {
+  [key in keyof TableGroupTitleVariant]?: ConditionalValue<TableGroupTitleVariant[key]> | undefined
+}
+
+export interface TableGroupTitleRecipe {
+  __type: TableGroupTitleVariantProps
+  (props?: TableGroupTitleVariantProps): string
+  raw: (props?: TableGroupTitleVariantProps) => TableGroupTitleVariantProps
+  variantMap: TableGroupTitleVariantMap
+  variantKeys: Array<keyof TableGroupTitleVariant>
+  splitVariantProps<Props extends TableGroupTitleVariantProps>(props: Props): [TableGroupTitleVariantProps, Pretty<DistributiveOmit<Props, keyof TableGroupTitleVariantProps>>]
+  getVariantProps: (props?: TableGroupTitleVariantProps) => TableGroupTitleVariantProps
+}
+
+
+export declare const tableGroupTitle: TableGroupTitleRecipe

package/recipes/table-group-title.mjs

@@ -0,0 +1,31 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableGroupTitleFn = /* @__PURE__ */ createRecipe('table-group-title', {
+  "variant": "primary"
+}, [])
+
+const tableGroupTitleVariantMap = {
+  "variant": [
+    "primary",
+    "secondary"
+  ]
+}
+
+const tableGroupTitleVariantKeys = Object.keys(tableGroupTitleVariantMap)
+
+export const tableGroupTitle = /* @__PURE__ */ Object.assign(memo(tableGroupTitleFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'tableGroupTitle',
+  __getCompoundVariantCss__: tableGroupTitleFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: tableGroupTitleVariantKeys,
+  variantMap: tableGroupTitleVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableGroupTitleVariantKeys)
+  },
+  getVariantProps: tableGroupTitleFn.getVariantProps,
+})

package/recipes/table.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableVariant {
+  
+}
+
+type TableVariantMap = {
+  [key in keyof TableVariant]: Array<TableVariant[key]>
+}
+
+export type TableVariantProps = {
+  [key in keyof TableVariant]?: ConditionalValue<TableVariant[key]> | undefined
+}
+
+export interface TableRecipe {
+  __type: TableVariantProps
+  (props?: TableVariantProps): Pretty<Record<"root" | "thead" | "tbody" | "tr" | "th" | "td", string>>
+  raw: (props?: TableVariantProps) => TableVariantProps
+  variantMap: TableVariantMap
+  variantKeys: Array<keyof TableVariant>
+  splitVariantProps<Props extends TableVariantProps>(props: Props): [TableVariantProps, Pretty<DistributiveOmit<Props, keyof TableVariantProps>>]
+  getVariantProps: (props?: TableVariantProps) => TableVariantProps
+}
+
+
+export declare const table: TableRecipe

package/recipes/table.mjs

@@ -0,0 +1,52 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tableDefaultVariants = {}
+const tableCompoundVariants = []
+
+const tableSlotNames = [
+  [
+    "root",
+    "table__root"
+  ],
+  [
+    "thead",
+    "table__thead"
+  ],
+  [
+    "tbody",
+    "table__tbody"
+  ],
+  [
+    "tr",
+    "table__tr"
+  ],
+  [
+    "th",
+    "table__th"
+  ],
+  [
+    "td",
+    "table__td"
+  ]
+]
+const tableSlotFns = /* @__PURE__ */ tableSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tableDefaultVariants, getSlotCompoundVariant(tableCompoundVariants, slotName))])
+
+const tableFn = memo((props = {}) => {
+  return Object.fromEntries(tableSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const tableVariantKeys = []
+const getVariantProps = (variants) => ({ ...tableDefaultVariants, ...compact(variants) })
+
+export const table = /* @__PURE__ */ Object.assign(tableFn, {
+  __recipe__: false,
+  __name__: 'table',
+  raw: (props) => props,
+  variantKeys: tableVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, tableVariantKeys)
+  },
+  getVariantProps
+})