@moneyforward/mfui-components 3.6.0 → 3.8.0

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

@@ -1,28 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-const dataGridBodySlotRecipeDefaultVariants = {};
-const dataGridBodySlotRecipeCompoundVariants = [];
-const dataGridBodySlotRecipeSlotNames = [
-    [
-        "root",
-        "DataGridBody__root"
-    ]
-];
-const dataGridBodySlotRecipeSlotFns = /* @__PURE__ */ dataGridBodySlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataGridBodySlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridBodySlotRecipeCompoundVariants, slotName))]);
-const dataGridBodySlotRecipeFn = memo((props = {}) => {
-    return Object.fromEntries(dataGridBodySlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
-});
-const dataGridBodySlotRecipeVariantKeys = [];
-const getVariantProps = (variants) => ({ ...dataGridBodySlotRecipeDefaultVariants, ...compact(variants) });
-export const dataGridBodySlotRecipe = /* @__PURE__ */ Object.assign(dataGridBodySlotRecipeFn, {
-    __recipe__: false,
-    __name__: 'dataGridBodySlotRecipe',
-    raw: (props) => props,
-    classNameMap: {},
-    variantKeys: dataGridBodySlotRecipeVariantKeys,
-    variantMap: {},
-    splitVariantProps(props) {
-        return splitProps(props, dataGridBodySlotRecipeVariantKeys);
-    },
-    getVariantProps
-});

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

@@ -1,38 +0,0 @@
-/* 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/styled-system/recipes/data-grid-cell-slot-recipe.js

@@ -1,77 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './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, createRecipe(slotKey, dataGridCellSlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridCellSlotRecipeCompoundVariants, slotName))]);
-const dataGridCellSlotRecipeFn = 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, ...compact(variants) });
-export const dataGridCellSlotRecipe = /* @__PURE__ */ 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 splitProps(props, dataGridCellSlotRecipeVariantKeys);
-    },
-    getVariantProps
-});

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

@@ -1,37 +0,0 @@
-/* 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/styled-system/recipes/data-grid-header-cell-slot-recipe.js

@@ -1,73 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './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, createRecipe(slotKey, dataGridHeaderCellSlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridHeaderCellSlotRecipeCompoundVariants, slotName))]);
-const dataGridHeaderCellSlotRecipeFn = memo((props = {}) => {
-    return Object.fromEntries(dataGridHeaderCellSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
-});
-const dataGridHeaderCellSlotRecipeVariantKeys = [
-    "size",
-    "fixedColumn",
-    "edgeFixedColumn",
-    "isCheckboxCell",
-    "type"
-];
-const getVariantProps = (variants) => ({ ...dataGridHeaderCellSlotRecipeDefaultVariants, ...compact(variants) });
-export const dataGridHeaderCellSlotRecipe = /* @__PURE__ */ 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 splitProps(props, dataGridHeaderCellSlotRecipeVariantKeys);
-    },
-    getVariantProps
-});

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

@@ -1,33 +0,0 @@
-/* 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/styled-system/recipes/data-grid-header-row-slot-recipe.js

@@ -1,28 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-const dataGridHeaderRowSlotRecipeDefaultVariants = {};
-const dataGridHeaderRowSlotRecipeCompoundVariants = [];
-const dataGridHeaderRowSlotRecipeSlotNames = [
-    [
-        "root",
-        "DataGridHeaderRow__root"
-    ]
-];
-const dataGridHeaderRowSlotRecipeSlotFns = /* @__PURE__ */ dataGridHeaderRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataGridHeaderRowSlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridHeaderRowSlotRecipeCompoundVariants, slotName))]);
-const dataGridHeaderRowSlotRecipeFn = memo((props = {}) => {
-    return Object.fromEntries(dataGridHeaderRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
-});
-const dataGridHeaderRowSlotRecipeVariantKeys = [];
-const getVariantProps = (variants) => ({ ...dataGridHeaderRowSlotRecipeDefaultVariants, ...compact(variants) });
-export const dataGridHeaderRowSlotRecipe = /* @__PURE__ */ Object.assign(dataGridHeaderRowSlotRecipeFn, {
-    __recipe__: false,
-    __name__: 'dataGridHeaderRowSlotRecipe',
-    raw: (props) => props,
-    classNameMap: {},
-    variantKeys: dataGridHeaderRowSlotRecipeVariantKeys,
-    variantMap: {},
-    splitVariantProps(props) {
-        return splitProps(props, dataGridHeaderRowSlotRecipeVariantKeys);
-    },
-    getVariantProps
-});

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

@@ -1,33 +0,0 @@
-/* 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/styled-system/recipes/data-grid-header-slot-recipe.js

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

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

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

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

@@ -1,36 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface DataGridSlotRecipeVariant {
-  /**
- * @default "default"
- */
-layout: "default" | "edge-to-edge"
-}
-
-type DataGridSlotRecipeVariantMap = {
-  [key in keyof DataGridSlotRecipeVariant]: Array<DataGridSlotRecipeVariant[key]>
-}
-
-type DataGridSlotRecipeSlot = "wrapper" | "table" | "emptyState"
-
-export type DataGridSlotRecipeVariantProps = {
-  [key in keyof DataGridSlotRecipeVariant]?: ConditionalValue<DataGridSlotRecipeVariant[key]> | undefined
-}
-
-export interface DataGridSlotRecipeRecipe {
-  __slot: DataGridSlotRecipeSlot
-  __type: DataGridSlotRecipeVariantProps
-  (props?: DataGridSlotRecipeVariantProps): Pretty<Record<DataGridSlotRecipeSlot, string>>
-  raw: (props?: DataGridSlotRecipeVariantProps) => DataGridSlotRecipeVariantProps
-  variantMap: DataGridSlotRecipeVariantMap
-  variantKeys: Array<keyof DataGridSlotRecipeVariant>
-  splitVariantProps<Props extends DataGridSlotRecipeVariantProps>(props: Props): [DataGridSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataGridSlotRecipeVariantProps>>]
-  getVariantProps: (props?: DataGridSlotRecipeVariantProps) => DataGridSlotRecipeVariantProps
-}
-
-/**
- * Slot class created for the MFUI DataGrid component.
- */
-export declare const dataGridSlotRecipe: DataGridSlotRecipeRecipe

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

@@ -1,45 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-const dataGridSlotRecipeDefaultVariants = {
-    "layout": "default"
-};
-const dataGridSlotRecipeCompoundVariants = [];
-const dataGridSlotRecipeSlotNames = [
-    [
-        "wrapper",
-        "DataGrid__wrapper"
-    ],
-    [
-        "table",
-        "DataGrid__table"
-    ],
-    [
-        "emptyState",
-        "DataGrid__emptyState"
-    ]
-];
-const dataGridSlotRecipeSlotFns = /* @__PURE__ */ dataGridSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataGridSlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridSlotRecipeCompoundVariants, slotName))]);
-const dataGridSlotRecipeFn = memo((props = {}) => {
-    return Object.fromEntries(dataGridSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
-});
-const dataGridSlotRecipeVariantKeys = [
-    "layout"
-];
-const getVariantProps = (variants) => ({ ...dataGridSlotRecipeDefaultVariants, ...compact(variants) });
-export const dataGridSlotRecipe = /* @__PURE__ */ Object.assign(dataGridSlotRecipeFn, {
-    __recipe__: false,
-    __name__: 'dataGridSlotRecipe',
-    raw: (props) => props,
-    classNameMap: {},
-    variantKeys: dataGridSlotRecipeVariantKeys,
-    variantMap: {
-        "layout": [
-            "default",
-            "edge-to-edge"
-        ]
-    },
-    splitVariantProps(props) {
-        return splitProps(props, dataGridSlotRecipeVariantKeys);
-    },
-    getVariantProps
-});