@moneyforward/mfui-components 2.48.1

package/dist/cjs/styled-system/recipes/checkbox-slot-recipe.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkboxSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const checkboxSlotRecipeDefaultVariants = {};
+const checkboxSlotRecipeCompoundVariants = [];
+const checkboxSlotRecipeSlotNames = [
+    [
+        "root",
+        "Checkbox__root"
+    ],
+    [
+        "input",
+        "Checkbox__input"
+    ],
+    [
+        "icon",
+        "Checkbox__icon"
+    ],
+    [
+        "label",
+        "Checkbox__label"
+    ],
+    [
+        "indeterminate",
+        "Checkbox__indeterminate"
+    ]
+];
+const checkboxSlotRecipeSlotFns = /* @__PURE__ */ checkboxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, checkboxSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(checkboxSlotRecipeCompoundVariants, slotName))]);
+const checkboxSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(checkboxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const checkboxSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...checkboxSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.checkboxSlotRecipe = Object.assign(checkboxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'checkboxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: checkboxSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, checkboxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/create-recipe.d.ts

@@ -0,0 +1,6 @@
+export function createRecipe(name: any, defaultVariants: any, compoundVariants: any): {
+    recipeFn: (variants: any, withCompoundVariants?: boolean) => any;
+    getVariantProps: (variants: any) => any;
+    __getCompoundVariantCss__: (variants: any) => any;
+};
+export function mergeRecipes(recipeA: any, recipeB: any): any;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRecipes = exports.createRecipe = void 0;
+const conditions_js_1 = require("../css/conditions.js");
+const css_js_1 = require("../css/css.js");
+const cva_js_1 = require("../css/cva.js");
+const cx_js_1 = require("../css/cx.js");
+const helpers_js_1 = require("../helpers.js");
+const createRecipe = (name, defaultVariants, compoundVariants) => {
+    const getVariantProps = (variants) => {
+        return {
+            [name]: '__ignore__',
+            ...defaultVariants,
+            ...(0, helpers_js_1.compact)(variants),
+        };
+    };
+    const recipeFn = (variants, withCompoundVariants = true) => {
+        const transform = (prop, value) => {
+            (0, cva_js_1.assertCompoundVariant)(name, compoundVariants, variants, prop);
+            if (value === '__ignore__') {
+                return { className: name };
+            }
+            value = (0, helpers_js_1.withoutSpace)(value);
+            return { className: `${name}--${prop}_${value}` };
+        };
+        const recipeCss = (0, helpers_js_1.createCss)({
+            hash: true,
+            conditions: {
+                shift: conditions_js_1.sortConditions,
+                finalize: conditions_js_1.finalizeConditions,
+                breakpoints: { keys: ["base", "sm", "lg"] }
+            },
+            utility: {
+                prefix: "mfui-2-48-1",
+                toHash: (path, hashFn) => hashFn(path.join(":")),
+                transform,
+            }
+        });
+        const recipeStyles = getVariantProps(variants);
+        if (withCompoundVariants) {
+            const compoundVariantStyles = (0, cva_js_1.getCompoundVariantCss)(compoundVariants, recipeStyles);
+            return (0, cx_js_1.cx)(recipeCss(recipeStyles), (0, css_js_1.css)(compoundVariantStyles));
+        }
+        return recipeCss(recipeStyles);
+    };
+    return {
+        recipeFn,
+        getVariantProps,
+        __getCompoundVariantCss__: (variants) => {
+            return (0, cva_js_1.getCompoundVariantCss)(compoundVariants, getVariantProps(variants));
+        },
+    };
+};
+exports.createRecipe = createRecipe;
+const mergeRecipes = (recipeA, recipeB) => {
+    if (recipeA && !recipeB)
+        return recipeA;
+    if (!recipeA && recipeB)
+        return recipeB;
+    const recipeFn = (...args) => (0, cx_js_1.cx)(recipeA(...args), recipeB(...args));
+    const variantKeys = (0, helpers_js_1.uniq)(recipeA.variantKeys, recipeB.variantKeys);
+    const variantMap = variantKeys.reduce((acc, key) => {
+        acc[key] = (0, helpers_js_1.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 (0, helpers_js_1.splitProps)(props, variantKeys);
+        },
+    });
+};
+exports.mergeRecipes = mergeRecipes;

package/dist/cjs/styled-system/recipes/data-grid-body-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridBodySlotRecipeVariant {
+  
+}
+
+type DataGridBodySlotRecipeVariantMap = {
+  [key in keyof DataGridBodySlotRecipeVariant]: Array<DataGridBodySlotRecipeVariant[key]>
+}
+
+type DataGridBodySlotRecipeSlot = "root"
+
+export type DataGridBodySlotRecipeVariantProps = {
+  [key in keyof DataGridBodySlotRecipeVariant]?: ConditionalValue<DataGridBodySlotRecipeVariant[key]> | undefined
+}
+
+export interface DataGridBodySlotRecipeRecipe {
+  __slot: DataGridBodySlotRecipeSlot
+  __type: DataGridBodySlotRecipeVariantProps
+  (props?: DataGridBodySlotRecipeVariantProps): Pretty<Record<DataGridBodySlotRecipeSlot, string>>
+  raw: (props?: DataGridBodySlotRecipeVariantProps) => DataGridBodySlotRecipeVariantProps
+  variantMap: DataGridBodySlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridBodySlotRecipeVariant>
+  splitVariantProps<Props extends DataGridBodySlotRecipeVariantProps>(props: Props): [DataGridBodySlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridBodySlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridBodySlotRecipeVariantProps) => DataGridBodySlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridBody component.
+ */
+export declare const dataGridBodySlotRecipe: DataGridBodySlotRecipeRecipe

package/dist/cjs/styled-system/recipes/data-grid-body-slot-recipe.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridBodySlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const dataGridBodySlotRecipeDefaultVariants = {};
+const dataGridBodySlotRecipeCompoundVariants = [];
+const dataGridBodySlotRecipeSlotNames = [
+    [
+        "root",
+        "DataGridBody__root"
+    ]
+];
+const dataGridBodySlotRecipeSlotFns = /* @__PURE__ */ dataGridBodySlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, dataGridBodySlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(dataGridBodySlotRecipeCompoundVariants, slotName))]);
+const dataGridBodySlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(dataGridBodySlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataGridBodySlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dataGridBodySlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.dataGridBodySlotRecipe = Object.assign(dataGridBodySlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataGridBodySlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataGridBodySlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, dataGridBodySlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/data-grid-cell-slot-recipe.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridCellSlotRecipeVariant {
+  size: "small" | "medium"
+isCheckboxCell: boolean
+rowHighlighted: boolean
+fixedColumn: boolean
+edgeFixedColumn: "left" | "right"
+type: "text" | "amount"
+}
+
+type DataGridCellSlotRecipeVariantMap = {
+  [key in keyof DataGridCellSlotRecipeVariant]: Array<DataGridCellSlotRecipeVariant[key]>
+}
+
+type DataGridCellSlotRecipeSlot = "root" | "defaultCell" | "interactiveCell" | "disclosureIconWrapper" | "disclosureSpacing" | "skeletonCell"
+
+export type DataGridCellSlotRecipeVariantProps = {
+  [key in keyof DataGridCellSlotRecipeVariant]?: ConditionalValue<DataGridCellSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataGridCellSlotRecipeRecipe {
+  __slot: DataGridCellSlotRecipeSlot
+  __type: DataGridCellSlotRecipeVariantProps
+  (props?: DataGridCellSlotRecipeVariantProps): Pretty<Record<DataGridCellSlotRecipeSlot, string>>
+  raw: (props?: DataGridCellSlotRecipeVariantProps) => DataGridCellSlotRecipeVariantProps
+  variantMap: DataGridCellSlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridCellSlotRecipeVariant>
+  splitVariantProps<Props extends DataGridCellSlotRecipeVariantProps>(props: Props): [DataGridCellSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridCellSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridCellSlotRecipeVariantProps) => DataGridCellSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridCell component.
+ */
+export declare const dataGridCellSlotRecipe: DataGridCellSlotRecipeRecipe

package/dist/cjs/styled-system/recipes/data-grid-cell-slot-recipe.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridCellSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const dataGridCellSlotRecipeDefaultVariants = {};
+const dataGridCellSlotRecipeCompoundVariants = [];
+const dataGridCellSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataGridCell__root"
+    ],
+    [
+        "defaultCell",
+        "DataGridCell__defaultCell"
+    ],
+    [
+        "interactiveCell",
+        "DataGridCell__interactiveCell"
+    ],
+    [
+        "disclosureIconWrapper",
+        "DataGridCell__disclosureIconWrapper"
+    ],
+    [
+        "disclosureSpacing",
+        "DataGridCell__disclosureSpacing"
+    ],
+    [
+        "skeletonCell",
+        "DataGridCell__skeletonCell"
+    ]
+];
+const dataGridCellSlotRecipeSlotFns = /* @__PURE__ */ dataGridCellSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, dataGridCellSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(dataGridCellSlotRecipeCompoundVariants, slotName))]);
+const dataGridCellSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(dataGridCellSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataGridCellSlotRecipeVariantKeys = [
+    "size",
+    "isCheckboxCell",
+    "rowHighlighted",
+    "fixedColumn",
+    "edgeFixedColumn",
+    "type"
+];
+const getVariantProps = (variants) => ({ ...dataGridCellSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.dataGridCellSlotRecipe = Object.assign(dataGridCellSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataGridCellSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataGridCellSlotRecipeVariantKeys,
+    variantMap: {
+        "size": [
+            "small",
+            "medium"
+        ],
+        "isCheckboxCell": [
+            "true"
+        ],
+        "rowHighlighted": [
+            "true"
+        ],
+        "fixedColumn": [
+            "true"
+        ],
+        "edgeFixedColumn": [
+            "left",
+            "right"
+        ],
+        "type": [
+            "text",
+            "amount"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, dataGridCellSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/data-grid-header-cell-slot-recipe.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridHeaderCellSlotRecipeVariant {
+  size: "small" | "medium"
+fixedColumn: boolean
+edgeFixedColumn: "left" | "right"
+isCheckboxCell: boolean
+type: "text" | "amount"
+}
+
+type DataGridHeaderCellSlotRecipeVariantMap = {
+  [key in keyof DataGridHeaderCellSlotRecipeVariant]: Array<DataGridHeaderCellSlotRecipeVariant[key]>
+}
+
+type DataGridHeaderCellSlotRecipeSlot = "root" | "headerCell" | "sortButton" | "sortIconContainer" | "sortIcon" | "unsortedIcon"
+
+export type DataGridHeaderCellSlotRecipeVariantProps = {
+  [key in keyof DataGridHeaderCellSlotRecipeVariant]?: ConditionalValue<DataGridHeaderCellSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataGridHeaderCellSlotRecipeRecipe {
+  __slot: DataGridHeaderCellSlotRecipeSlot
+  __type: DataGridHeaderCellSlotRecipeVariantProps
+  (props?: DataGridHeaderCellSlotRecipeVariantProps): Pretty<Record<DataGridHeaderCellSlotRecipeSlot, string>>
+  raw: (props?: DataGridHeaderCellSlotRecipeVariantProps) => DataGridHeaderCellSlotRecipeVariantProps
+  variantMap: DataGridHeaderCellSlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridHeaderCellSlotRecipeVariant>
+  splitVariantProps<Props extends DataGridHeaderCellSlotRecipeVariantProps>(props: Props): [DataGridHeaderCellSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridHeaderCellSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridHeaderCellSlotRecipeVariantProps) => DataGridHeaderCellSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridHeaderCell component.
+ */
+export declare const dataGridHeaderCellSlotRecipe: DataGridHeaderCellSlotRecipeRecipe

package/dist/cjs/styled-system/recipes/data-grid-header-cell-slot-recipe.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridHeaderCellSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const dataGridHeaderCellSlotRecipeDefaultVariants = {};
+const dataGridHeaderCellSlotRecipeCompoundVariants = [];
+const dataGridHeaderCellSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataGridHeaderCell__root"
+    ],
+    [
+        "headerCell",
+        "DataGridHeaderCell__headerCell"
+    ],
+    [
+        "sortButton",
+        "DataGridHeaderCell__sortButton"
+    ],
+    [
+        "sortIconContainer",
+        "DataGridHeaderCell__sortIconContainer"
+    ],
+    [
+        "sortIcon",
+        "DataGridHeaderCell__sortIcon"
+    ],
+    [
+        "unsortedIcon",
+        "DataGridHeaderCell__unsortedIcon"
+    ]
+];
+const dataGridHeaderCellSlotRecipeSlotFns = /* @__PURE__ */ dataGridHeaderCellSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, dataGridHeaderCellSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(dataGridHeaderCellSlotRecipeCompoundVariants, slotName))]);
+const dataGridHeaderCellSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(dataGridHeaderCellSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataGridHeaderCellSlotRecipeVariantKeys = [
+    "size",
+    "fixedColumn",
+    "edgeFixedColumn",
+    "isCheckboxCell",
+    "type"
+];
+const getVariantProps = (variants) => ({ ...dataGridHeaderCellSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.dataGridHeaderCellSlotRecipe = Object.assign(dataGridHeaderCellSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataGridHeaderCellSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataGridHeaderCellSlotRecipeVariantKeys,
+    variantMap: {
+        "size": [
+            "small",
+            "medium"
+        ],
+        "fixedColumn": [
+            "true"
+        ],
+        "edgeFixedColumn": [
+            "left",
+            "right"
+        ],
+        "isCheckboxCell": [
+            "true"
+        ],
+        "type": [
+            "text",
+            "amount"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, dataGridHeaderCellSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/data-grid-header-row-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridHeaderRowSlotRecipeVariant {
+  
+}
+
+type DataGridHeaderRowSlotRecipeVariantMap = {
+  [key in keyof DataGridHeaderRowSlotRecipeVariant]: Array<DataGridHeaderRowSlotRecipeVariant[key]>
+}
+
+type DataGridHeaderRowSlotRecipeSlot = "root"
+
+export type DataGridHeaderRowSlotRecipeVariantProps = {
+  [key in keyof DataGridHeaderRowSlotRecipeVariant]?: ConditionalValue<DataGridHeaderRowSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataGridHeaderRowSlotRecipeRecipe {
+  __slot: DataGridHeaderRowSlotRecipeSlot
+  __type: DataGridHeaderRowSlotRecipeVariantProps
+  (props?: DataGridHeaderRowSlotRecipeVariantProps): Pretty<Record<DataGridHeaderRowSlotRecipeSlot, string>>
+  raw: (props?: DataGridHeaderRowSlotRecipeVariantProps) => DataGridHeaderRowSlotRecipeVariantProps
+  variantMap: DataGridHeaderRowSlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridHeaderRowSlotRecipeVariant>
+  splitVariantProps<Props extends DataGridHeaderRowSlotRecipeVariantProps>(props: Props): [DataGridHeaderRowSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridHeaderRowSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridHeaderRowSlotRecipeVariantProps) => DataGridHeaderRowSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridHeaderRow component.
+ */
+export declare const dataGridHeaderRowSlotRecipe: DataGridHeaderRowSlotRecipeRecipe

package/dist/cjs/styled-system/recipes/data-grid-header-row-slot-recipe.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridHeaderRowSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const dataGridHeaderRowSlotRecipeDefaultVariants = {};
+const dataGridHeaderRowSlotRecipeCompoundVariants = [];
+const dataGridHeaderRowSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataGridHeaderRow__root"
+    ]
+];
+const dataGridHeaderRowSlotRecipeSlotFns = /* @__PURE__ */ dataGridHeaderRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, dataGridHeaderRowSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(dataGridHeaderRowSlotRecipeCompoundVariants, slotName))]);
+const dataGridHeaderRowSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(dataGridHeaderRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataGridHeaderRowSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dataGridHeaderRowSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.dataGridHeaderRowSlotRecipe = Object.assign(dataGridHeaderRowSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataGridHeaderRowSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataGridHeaderRowSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, dataGridHeaderRowSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/data-grid-header-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridHeaderSlotRecipeVariant {
+  fixedHeader: boolean
+}
+
+type DataGridHeaderSlotRecipeVariantMap = {
+  [key in keyof DataGridHeaderSlotRecipeVariant]: Array<DataGridHeaderSlotRecipeVariant[key]>
+}
+
+type DataGridHeaderSlotRecipeSlot = "root"
+
+export type DataGridHeaderSlotRecipeVariantProps = {
+  [key in keyof DataGridHeaderSlotRecipeVariant]?: ConditionalValue<DataGridHeaderSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataGridHeaderSlotRecipeRecipe {
+  __slot: DataGridHeaderSlotRecipeSlot
+  __type: DataGridHeaderSlotRecipeVariantProps
+  (props?: DataGridHeaderSlotRecipeVariantProps): Pretty<Record<DataGridHeaderSlotRecipeSlot, string>>
+  raw: (props?: DataGridHeaderSlotRecipeVariantProps) => DataGridHeaderSlotRecipeVariantProps
+  variantMap: DataGridHeaderSlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridHeaderSlotRecipeVariant>
+  splitVariantProps<Props extends DataGridHeaderSlotRecipeVariantProps>(props: Props): [DataGridHeaderSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridHeaderSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridHeaderSlotRecipeVariantProps) => DataGridHeaderSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridHeader component.
+ */
+export declare const dataGridHeaderSlotRecipe: DataGridHeaderSlotRecipeRecipe

package/dist/cjs/styled-system/recipes/data-grid-header-slot-recipe.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataGridHeaderSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const dataGridHeaderSlotRecipeDefaultVariants = {};
+const dataGridHeaderSlotRecipeCompoundVariants = [];
+const dataGridHeaderSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataGridHeader__root"
+    ]
+];
+const dataGridHeaderSlotRecipeSlotFns = /* @__PURE__ */ dataGridHeaderSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, dataGridHeaderSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(dataGridHeaderSlotRecipeCompoundVariants, slotName))]);
+const dataGridHeaderSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(dataGridHeaderSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataGridHeaderSlotRecipeVariantKeys = [
+    "fixedHeader"
+];
+const getVariantProps = (variants) => ({ ...dataGridHeaderSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.dataGridHeaderSlotRecipe = Object.assign(dataGridHeaderSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataGridHeaderSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataGridHeaderSlotRecipeVariantKeys,
+    variantMap: {
+        "fixedHeader": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, dataGridHeaderSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/data-grid-row-slot-recipe.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DataGridRowSlotRecipeVariant {
+  layout: "default" | "edge-to-edge"
+highlighted: boolean
+interactive: boolean
+disabled: boolean
+}
+
+type DataGridRowSlotRecipeVariantMap = {
+  [key in keyof DataGridRowSlotRecipeVariant]: Array<DataGridRowSlotRecipeVariant[key]>
+}
+
+type DataGridRowSlotRecipeSlot = "root"
+
+export type DataGridRowSlotRecipeVariantProps = {
+  [key in keyof DataGridRowSlotRecipeVariant]?: DataGridRowSlotRecipeVariant[key] | undefined
+}
+
+export interface DataGridRowSlotRecipeRecipe {
+  __slot: DataGridRowSlotRecipeSlot
+  __type: DataGridRowSlotRecipeVariantProps
+  (props?: DataGridRowSlotRecipeVariantProps): Pretty<Record<DataGridRowSlotRecipeSlot, string>>
+  raw: (props?: DataGridRowSlotRecipeVariantProps) => DataGridRowSlotRecipeVariantProps
+  variantMap: DataGridRowSlotRecipeVariantMap
+  variantKeys: Array<keyof DataGridRowSlotRecipeVariant>
+  splitVariantProps<Props extends DataGridRowSlotRecipeVariantProps>(props: Props): [DataGridRowSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridRowSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataGridRowSlotRecipeVariantProps) => DataGridRowSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataGridRow component.
+ */
+export declare const dataGridRowSlotRecipe: DataGridRowSlotRecipeRecipe