@moneyforward/mfui-components 3.6.0 → 3.8.0

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

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dataTableHeaderRowSlotRecipeDefaultVariants = {};
+const dataTableHeaderRowSlotRecipeCompoundVariants = [];
+const dataTableHeaderRowSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataTableHeaderRow__root"
+    ]
+];
+const dataTableHeaderRowSlotRecipeSlotFns = /* @__PURE__ */ dataTableHeaderRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataTableHeaderRowSlotRecipeDefaultVariants, getSlotCompoundVariant(dataTableHeaderRowSlotRecipeCompoundVariants, slotName))]);
+const dataTableHeaderRowSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dataTableHeaderRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataTableHeaderRowSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dataTableHeaderRowSlotRecipeDefaultVariants, ...compact(variants) });
+export const dataTableHeaderRowSlotRecipe = /* @__PURE__ */ Object.assign(dataTableHeaderRowSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataTableHeaderRowSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataTableHeaderRowSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dataTableHeaderRowSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/data-table-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 DataTableHeaderSlotRecipeVariant {
+  fixedHeader: boolean
+}
+
+type DataTableHeaderSlotRecipeVariantMap = {
+  [key in keyof DataTableHeaderSlotRecipeVariant]: Array<DataTableHeaderSlotRecipeVariant[key]>
+}
+
+type DataTableHeaderSlotRecipeSlot = "root"
+
+export type DataTableHeaderSlotRecipeVariantProps = {
+  [key in keyof DataTableHeaderSlotRecipeVariant]?: ConditionalValue<DataTableHeaderSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataTableHeaderSlotRecipeRecipe {
+  __slot: DataTableHeaderSlotRecipeSlot
+  __type: DataTableHeaderSlotRecipeVariantProps
+  (props?: DataTableHeaderSlotRecipeVariantProps): Pretty<Record<DataTableHeaderSlotRecipeSlot, string>>
+  raw: (props?: DataTableHeaderSlotRecipeVariantProps) => DataTableHeaderSlotRecipeVariantProps
+  variantMap: DataTableHeaderSlotRecipeVariantMap
+  variantKeys: Array<keyof DataTableHeaderSlotRecipeVariant>
+  splitVariantProps<Props extends DataTableHeaderSlotRecipeVariantProps>(props: Props): [DataTableHeaderSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataTableHeaderSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataTableHeaderSlotRecipeVariantProps) => DataTableHeaderSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataTableHeader component.
+ */
+export declare const dataTableHeaderSlotRecipe: DataTableHeaderSlotRecipeRecipe

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

@@ -0,0 +1,35 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dataTableHeaderSlotRecipeDefaultVariants = {};
+const dataTableHeaderSlotRecipeCompoundVariants = [];
+const dataTableHeaderSlotRecipeSlotNames = [
+    [
+        "root",
+        "DataTableHeader__root"
+    ]
+];
+const dataTableHeaderSlotRecipeSlotFns = /* @__PURE__ */ dataTableHeaderSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataTableHeaderSlotRecipeDefaultVariants, getSlotCompoundVariant(dataTableHeaderSlotRecipeCompoundVariants, slotName))]);
+const dataTableHeaderSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dataTableHeaderSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataTableHeaderSlotRecipeVariantKeys = [
+    "fixedHeader"
+];
+const getVariantProps = (variants) => ({ ...dataTableHeaderSlotRecipeDefaultVariants, ...compact(variants) });
+export const dataTableHeaderSlotRecipe = /* @__PURE__ */ Object.assign(dataTableHeaderSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataTableHeaderSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataTableHeaderSlotRecipeVariantKeys,
+    variantMap: {
+        "fixedHeader": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, dataTableHeaderSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/data-table-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 DataTableRowSlotRecipeVariant {
+  layout: "default" | "edge-to-edge"
+highlighted: boolean
+interactive: boolean
+disabled: boolean
+}
+
+type DataTableRowSlotRecipeVariantMap = {
+  [key in keyof DataTableRowSlotRecipeVariant]: Array<DataTableRowSlotRecipeVariant[key]>
+}
+
+type DataTableRowSlotRecipeSlot = "root"
+
+export type DataTableRowSlotRecipeVariantProps = {
+  [key in keyof DataTableRowSlotRecipeVariant]?: DataTableRowSlotRecipeVariant[key] | undefined
+}
+
+export interface DataTableRowSlotRecipeRecipe {
+  __slot: DataTableRowSlotRecipeSlot
+  __type: DataTableRowSlotRecipeVariantProps
+  (props?: DataTableRowSlotRecipeVariantProps): Pretty<Record<DataTableRowSlotRecipeSlot, string>>
+  raw: (props?: DataTableRowSlotRecipeVariantProps) => DataTableRowSlotRecipeVariantProps
+  variantMap: DataTableRowSlotRecipeVariantMap
+  variantKeys: Array<keyof DataTableRowSlotRecipeVariant>
+  splitVariantProps<Props extends DataTableRowSlotRecipeVariantProps>(props: Props): [DataTableRowSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataTableRowSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataTableRowSlotRecipeVariantProps) => DataTableRowSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataTableRow component.
+ */
+export declare const dataTableRowSlotRecipe: DataTableRowSlotRecipeRecipe

package/dist/styled-system/recipes/{data-grid-row-slot-recipe.js → data-table-row-slot-recipe.js}

@@ -1,7 +1,7 @@
 import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
 import { createRecipe } from './create-recipe.js';
-const dataGridRowSlotRecipeDefaultVariants = {};
-const dataGridRowSlotRecipeCompoundVariants = [
+const dataTableRowSlotRecipeDefaultVariants = {};
+const dataTableRowSlotRecipeCompoundVariants = [
     {
         "highlighted": true,
         "interactive": true,
@@ -29,29 +29,29 @@ const dataGridRowSlotRecipeCompoundVariants = [
         }
     }
 ];
-const dataGridRowSlotRecipeSlotNames = [
+const dataTableRowSlotRecipeSlotNames = [
     [
         "root",
-        "DataGridRow__root"
+        "DataTableRow__root"
     ]
 ];
-const dataGridRowSlotRecipeSlotFns = /* @__PURE__ */ dataGridRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataGridRowSlotRecipeDefaultVariants, getSlotCompoundVariant(dataGridRowSlotRecipeCompoundVariants, slotName))]);
-const dataGridRowSlotRecipeFn = memo((props = {}) => {
-    return Object.fromEntries(dataGridRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+const dataTableRowSlotRecipeSlotFns = /* @__PURE__ */ dataTableRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataTableRowSlotRecipeDefaultVariants, getSlotCompoundVariant(dataTableRowSlotRecipeCompoundVariants, slotName))]);
+const dataTableRowSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dataTableRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
 });
-const dataGridRowSlotRecipeVariantKeys = [
+const dataTableRowSlotRecipeVariantKeys = [
     "layout",
     "highlighted",
     "interactive",
     "disabled"
 ];
-const getVariantProps = (variants) => ({ ...dataGridRowSlotRecipeDefaultVariants, ...compact(variants) });
-export const dataGridRowSlotRecipe = /* @__PURE__ */ Object.assign(dataGridRowSlotRecipeFn, {
+const getVariantProps = (variants) => ({ ...dataTableRowSlotRecipeDefaultVariants, ...compact(variants) });
+export const dataTableRowSlotRecipe = /* @__PURE__ */ Object.assign(dataTableRowSlotRecipeFn, {
     __recipe__: false,
-    __name__: 'dataGridRowSlotRecipe',
+    __name__: 'dataTableRowSlotRecipe',
     raw: (props) => props,
     classNameMap: {},
-    variantKeys: dataGridRowSlotRecipeVariantKeys,
+    variantKeys: dataTableRowSlotRecipeVariantKeys,
     variantMap: {
         "layout": [
             "default",
@@ -71,7 +71,7 @@ export const dataGridRowSlotRecipe = /* @__PURE__ */ Object.assign(dataGridRowSl
         ]
     },
     splitVariantProps(props) {
-        return splitProps(props, dataGridRowSlotRecipeVariantKeys);
+        return splitProps(props, dataTableRowSlotRecipeVariantKeys);
     },
     getVariantProps
 });

package/dist/styled-system/recipes/data-table-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 DataTableSlotRecipeVariant {
+  /**
+ * @default "default"
+ */
+layout: "default" | "edge-to-edge"
+}
+
+type DataTableSlotRecipeVariantMap = {
+  [key in keyof DataTableSlotRecipeVariant]: Array<DataTableSlotRecipeVariant[key]>
+}
+
+type DataTableSlotRecipeSlot = "wrapper" | "table" | "emptyState"
+
+export type DataTableSlotRecipeVariantProps = {
+  [key in keyof DataTableSlotRecipeVariant]?: ConditionalValue<DataTableSlotRecipeVariant[key]> | undefined
+}
+
+export interface DataTableSlotRecipeRecipe {
+  __slot: DataTableSlotRecipeSlot
+  __type: DataTableSlotRecipeVariantProps
+  (props?: DataTableSlotRecipeVariantProps): Pretty<Record<DataTableSlotRecipeSlot, string>>
+  raw: (props?: DataTableSlotRecipeVariantProps) => DataTableSlotRecipeVariantProps
+  variantMap: DataTableSlotRecipeVariantMap
+  variantKeys: Array<keyof DataTableSlotRecipeVariant>
+  splitVariantProps<Props extends DataTableSlotRecipeVariantProps>(props: Props): [DataTableSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DataTableSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DataTableSlotRecipeVariantProps) => DataTableSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DataTable component.
+ */
+export declare const dataTableSlotRecipe: DataTableSlotRecipeRecipe

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

@@ -0,0 +1,45 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dataTableSlotRecipeDefaultVariants = {
+    "layout": "default"
+};
+const dataTableSlotRecipeCompoundVariants = [];
+const dataTableSlotRecipeSlotNames = [
+    [
+        "wrapper",
+        "DataTable__wrapper"
+    ],
+    [
+        "table",
+        "DataTable__table"
+    ],
+    [
+        "emptyState",
+        "DataTable__emptyState"
+    ]
+];
+const dataTableSlotRecipeSlotFns = /* @__PURE__ */ dataTableSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dataTableSlotRecipeDefaultVariants, getSlotCompoundVariant(dataTableSlotRecipeCompoundVariants, slotName))]);
+const dataTableSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dataTableSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dataTableSlotRecipeVariantKeys = [
+    "layout"
+];
+const getVariantProps = (variants) => ({ ...dataTableSlotRecipeDefaultVariants, ...compact(variants) });
+export const dataTableSlotRecipe = /* @__PURE__ */ Object.assign(dataTableSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dataTableSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dataTableSlotRecipeVariantKeys,
+    variantMap: {
+        "layout": [
+            "default",
+            "edge-to-edge"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, dataTableSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

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

@@ -43,13 +43,13 @@ export * from './items-count-slot-recipe';
 export * from './page-picker-slot-recipe';
 export * from './items-per-page-slot-recipe';
 export * from './tag-slot-recipe';
-export * from './data-grid-body-slot-recipe';
-export * from './data-grid-cell-slot-recipe';
-export * from './data-grid-slot-recipe';
-export * from './data-grid-header-cell-slot-recipe';
-export * from './data-grid-header-row-slot-recipe';
-export * from './data-grid-header-slot-recipe';
-export * from './data-grid-row-slot-recipe';
+export * from './data-table-body-slot-recipe';
+export * from './data-table-cell-slot-recipe';
+export * from './data-table-slot-recipe';
+export * from './data-table-header-cell-slot-recipe';
+export * from './data-table-header-row-slot-recipe';
+export * from './data-table-header-slot-recipe';
+export * from './data-table-row-slot-recipe';
 export * from './sub-navigation-slot-recipe';
 export * from './progress-indicator-slot-recipe';
 export * from './stack-slot-recipe';

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

@@ -42,13 +42,13 @@ export * from './items-count-slot-recipe.js';
 export * from './page-picker-slot-recipe.js';
 export * from './items-per-page-slot-recipe.js';
 export * from './tag-slot-recipe.js';
-export * from './data-grid-body-slot-recipe.js';
-export * from './data-grid-cell-slot-recipe.js';
-export * from './data-grid-slot-recipe.js';
-export * from './data-grid-header-cell-slot-recipe.js';
-export * from './data-grid-header-row-slot-recipe.js';
-export * from './data-grid-header-slot-recipe.js';
-export * from './data-grid-row-slot-recipe.js';
+export * from './data-table-body-slot-recipe.js';
+export * from './data-table-cell-slot-recipe.js';
+export * from './data-table-slot-recipe.js';
+export * from './data-table-header-cell-slot-recipe.js';
+export * from './data-table-header-row-slot-recipe.js';
+export * from './data-table-header-slot-recipe.js';
+export * from './data-table-row-slot-recipe.js';
 export * from './sub-navigation-slot-recipe.js';
 export * from './progress-indicator-slot-recipe.js';
 export * from './stack-slot-recipe.js';

package/dist/styled-system/recipes/narrow-viewport-main-navigation-slot-recipe.d.ts

@@ -10,7 +10,7 @@ type NarrowViewportMainNavigationSlotRecipeVariantMap = {
   [key in keyof NarrowViewportMainNavigationSlotRecipeVariant]: Array<NarrowViewportMainNavigationSlotRecipeVariant[key]>
 }
 
-type NarrowViewportMainNavigationSlotRecipeSlot = "root" | "backdrop" | "container" | "nav" | "list" | "featureShortcut" | "featureShortcutAnchor" | "labelGroup" | "iconAndLabel" | "lockIcon" | "listItem" | "listItemAnchor" | "listItemAnchorIcon" | "parentDetails" | "parentSummary" | "parentSummaryIcon" | "childrenList" | "childrenListItem" | "childrenListItemAnchor" | "footer" | "toggleButton" | "toggleButtonIcon"
+type NarrowViewportMainNavigationSlotRecipeSlot = "root" | "backdrop" | "container" | "nav" | "list" | "featureShortcut" | "featureShortcutAnchor" | "labelGroup" | "iconAndLabel" | "lockIcon" | "listItem" | "listItemAnchor" | "listItemAnchorIcon" | "parentDetails" | "parentSummary" | "parentSummaryIcon" | "groupLabelSection" | "groupLabel" | "groupLabelText" | "childrenList" | "childrenListItem" | "childrenListItemAnchor" | "footer" | "toggleButton" | "toggleButtonIcon"
 
 export type NarrowViewportMainNavigationSlotRecipeVariantProps = {
   [key in keyof NarrowViewportMainNavigationSlotRecipeVariant]?: ConditionalValue<NarrowViewportMainNavigationSlotRecipeVariant[key]> | undefined

package/dist/styled-system/recipes/narrow-viewport-main-navigation-slot-recipe.js

@@ -67,6 +67,18 @@ const narrowViewportMainNavigationSlotRecipeSlotNames = [
         "parentSummaryIcon",
         "NarrowViewportMainNavigation__parentSummaryIcon"
     ],
+    [
+        "groupLabelSection",
+        "NarrowViewportMainNavigation__groupLabelSection"
+    ],
+    [
+        "groupLabel",
+        "NarrowViewportMainNavigation__groupLabel"
+    ],
+    [
+        "groupLabelText",
+        "NarrowViewportMainNavigation__groupLabelText"
+    ],
     [
         "childrenList",
         "NarrowViewportMainNavigation__childrenList"

package/dist/styled-system/recipes/status-label-slot-recipe.d.ts

@@ -4,6 +4,10 @@ import type { DistributiveOmit, Pretty } from '../types/system-types';
 
 interface StatusLabelSlotRecipeVariant {
   /**
+ * @default "neutral"
+ */
+status: "neutral" | "success" | "error" | "caution"
+/**
  * @default "medium"
  */
 size: "medium" | "small"

package/dist/styled-system/recipes/status-label-slot-recipe.js

@@ -1,7 +1,8 @@
 import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
 import { createRecipe } from './create-recipe.js';
 const statusLabelSlotRecipeDefaultVariants = {
-    "size": "medium"
+    "size": "medium",
+    "status": "neutral"
 };
 const statusLabelSlotRecipeCompoundVariants = [];
 const statusLabelSlotRecipeSlotNames = [
@@ -23,6 +24,7 @@ const statusLabelSlotRecipeFn = memo((props = {}) => {
     return Object.fromEntries(statusLabelSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
 });
 const statusLabelSlotRecipeVariantKeys = [
+    "status",
     "size"
 ];
 const getVariantProps = (variants) => ({ ...statusLabelSlotRecipeDefaultVariants, ...compact(variants) });
@@ -33,6 +35,12 @@ export const statusLabelSlotRecipe = /* @__PURE__ */ Object.assign(statusLabelSl
     classNameMap: {},
     variantKeys: statusLabelSlotRecipeVariantKeys,
     variantMap: {
+        "status": [
+            "neutral",
+            "success",
+            "error",
+            "caution"
+        ],
         "size": [
             "medium",
             "small"