@moneyforward/mfui-components 2.48.1

package/dist/esm/styled-system/patterns/stack.d.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface StackProperties {
+   align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+	direction?: SystemProperties["flexDirection"]
+	gap?: SystemProperties["gap"]
+}
+
+interface StackStyles extends StackProperties, DistributiveOmit<SystemStyleObject, keyof StackProperties > {}
+
+interface StackPatternFn {
+  (styles?: StackStyles): string
+  raw: (styles?: StackStyles) => SystemStyleObject
+}
+
+
+export declare const stack: StackPatternFn;

package/dist/esm/styled-system/patterns/stack.js

@@ -0,0 +1,22 @@
+import { getPatternStyles, patternFns } from '../helpers.js';
+import { css } from '../css/index.js';
+const stackConfig = {
+    transform(props) {
+        const { align, justify, direction, gap, ...rest } = props;
+        return {
+            display: "flex",
+            flexDirection: direction,
+            alignItems: align,
+            justifyContent: justify,
+            gap,
+            ...rest
+        };
+    },
+    defaultValues: { direction: 'column', gap: '8px' }
+};
+export const getStackStyle = (styles = {}) => {
+    const _styles = getPatternStyles(stackConfig, styles);
+    return stackConfig.transform(_styles, patternFns);
+};
+export const stack = (styles) => css(getStackStyle(styles));
+stack.raw = getStackStyle;

package/dist/esm/styled-system/patterns/visually-hidden.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VisuallyHiddenProperties {
+   
+}
+
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, DistributiveOmit<SystemStyleObject, keyof VisuallyHiddenProperties > {}
+
+interface VisuallyHiddenPatternFn {
+  (styles?: VisuallyHiddenStyles): string
+  raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+}
+
+
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

package/dist/esm/styled-system/patterns/visually-hidden.js

@@ -0,0 +1,16 @@
+import { getPatternStyles, patternFns } from '../helpers.js';
+import { css } from '../css/index.js';
+const visuallyHiddenConfig = {
+    transform(props) {
+        return {
+            srOnly: true,
+            ...props
+        };
+    }
+};
+export const getVisuallyHiddenStyle = (styles = {}) => {
+    const _styles = getPatternStyles(visuallyHiddenConfig, styles);
+    return visuallyHiddenConfig.transform(_styles, patternFns);
+};
+export const visuallyHidden = (styles) => css(getVisuallyHiddenStyle(styles));
+visuallyHidden.raw = getVisuallyHiddenStyle;

package/dist/esm/styled-system/patterns/vstack.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VstackProperties {
+   justify?: SystemProperties["justifyContent"]
+	gap?: SystemProperties["gap"]
+}
+
+interface VstackStyles extends VstackProperties, DistributiveOmit<SystemStyleObject, keyof VstackProperties > {}
+
+interface VstackPatternFn {
+  (styles?: VstackStyles): string
+  raw: (styles?: VstackStyles) => SystemStyleObject
+}
+
+
+export declare const vstack: VstackPatternFn;

package/dist/esm/styled-system/patterns/vstack.js

@@ -0,0 +1,22 @@
+import { getPatternStyles, patternFns } from '../helpers.js';
+import { css } from '../css/index.js';
+const vstackConfig = {
+    transform(props) {
+        const { justify, gap, ...rest } = props;
+        return {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: justify,
+            gap,
+            flexDirection: "column",
+            ...rest
+        };
+    },
+    defaultValues: { gap: '8px' }
+};
+export const getVstackStyle = (styles = {}) => {
+    const _styles = getPatternStyles(vstackConfig, styles);
+    return vstackConfig.transform(_styles, patternFns);
+};
+export const vstack = (styles) => css(getVstackStyle(styles));
+vstack.raw = getVstackStyle;

package/dist/esm/styled-system/patterns/wrap.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface WrapProperties {
+   gap?: SystemProperties["gap"]
+	rowGap?: SystemProperties["gap"]
+	columnGap?: SystemProperties["gap"]
+	align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+}
+
+interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+}
+
+
+export declare const wrap: WrapPatternFn;

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

@@ -0,0 +1,23 @@
+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/esm/styled-system/recipes/accordion-slot-recipe.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AccordionSlotRecipeVariant {
+  size: "small" | "medium"
+isOpen: boolean
+}
+
+type AccordionSlotRecipeVariantMap = {
+  [key in keyof AccordionSlotRecipeVariant]: Array<AccordionSlotRecipeVariant[key]>
+}
+
+type AccordionSlotRecipeSlot = "trigger" | "target"
+
+export type AccordionSlotRecipeVariantProps = {
+  [key in keyof AccordionSlotRecipeVariant]?: AccordionSlotRecipeVariant[key] | undefined
+}
+
+export interface AccordionSlotRecipeRecipe {
+  __slot: AccordionSlotRecipeSlot
+  __type: AccordionSlotRecipeVariantProps
+  (props?: AccordionSlotRecipeVariantProps): Pretty<Record<AccordionSlotRecipeSlot, string>>
+  raw: (props?: AccordionSlotRecipeVariantProps) => AccordionSlotRecipeVariantProps
+  variantMap: AccordionSlotRecipeVariantMap
+  variantKeys: Array<keyof AccordionSlotRecipeVariant>
+  splitVariantProps<Props extends AccordionSlotRecipeVariantProps>(props: Props): [AccordionSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionSlotRecipeVariantProps>>]
+  getVariantProps: (props?: AccordionSlotRecipeVariantProps) => AccordionSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Accordion component.
+ */
+export declare const accordionSlotRecipe: AccordionSlotRecipeRecipe

package/dist/esm/styled-system/recipes/accordion-slot-recipe.js

@@ -0,0 +1,54 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const accordionSlotRecipeDefaultVariants = {};
+const accordionSlotRecipeCompoundVariants = [
+    {
+        "size": "small",
+        "isOpen": false,
+        "css": {
+            "trigger": {
+                "paddingBottom": "[calc({spacing.mfui.size.padding.control-container.vertical.condensed} - 1px)]"
+            }
+        }
+    }
+];
+const accordionSlotRecipeSlotNames = [
+    [
+        "trigger",
+        "Accordion__trigger"
+    ],
+    [
+        "target",
+        "Accordion__target"
+    ]
+];
+const accordionSlotRecipeSlotFns = /* @__PURE__ */ accordionSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, accordionSlotRecipeDefaultVariants, getSlotCompoundVariant(accordionSlotRecipeCompoundVariants, slotName))]);
+const accordionSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(accordionSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const accordionSlotRecipeVariantKeys = [
+    "size",
+    "isOpen"
+];
+const getVariantProps = (variants) => ({ ...accordionSlotRecipeDefaultVariants, ...compact(variants) });
+export const accordionSlotRecipe = /* @__PURE__ */ Object.assign(accordionSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'accordionSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: accordionSlotRecipeVariantKeys,
+    variantMap: {
+        "size": [
+            "small",
+            "medium"
+        ],
+        "isOpen": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, accordionSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/badge-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 BadgeSlotRecipeVariant {
+  hasChildren: boolean
+}
+
+type BadgeSlotRecipeVariantMap = {
+  [key in keyof BadgeSlotRecipeVariant]: Array<BadgeSlotRecipeVariant[key]>
+}
+
+type BadgeSlotRecipeSlot = "root" | "indicator"
+
+export type BadgeSlotRecipeVariantProps = {
+  [key in keyof BadgeSlotRecipeVariant]?: ConditionalValue<BadgeSlotRecipeVariant[key]> | undefined
+}
+
+export interface BadgeSlotRecipeRecipe {
+  __slot: BadgeSlotRecipeSlot
+  __type: BadgeSlotRecipeVariantProps
+  (props?: BadgeSlotRecipeVariantProps): Pretty<Record<BadgeSlotRecipeSlot, string>>
+  raw: (props?: BadgeSlotRecipeVariantProps) => BadgeSlotRecipeVariantProps
+  variantMap: BadgeSlotRecipeVariantMap
+  variantKeys: Array<keyof BadgeSlotRecipeVariant>
+  splitVariantProps<Props extends BadgeSlotRecipeVariantProps>(props: Props): [BadgeSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BadgeSlotRecipeVariantProps>>]
+  getVariantProps: (props?: BadgeSlotRecipeVariantProps) => BadgeSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Badge component.
+ */
+export declare const badgeSlotRecipe: BadgeSlotRecipeRecipe

package/dist/esm/styled-system/recipes/badge-slot-recipe.js

@@ -0,0 +1,39 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const badgeSlotRecipeDefaultVariants = {};
+const badgeSlotRecipeCompoundVariants = [];
+const badgeSlotRecipeSlotNames = [
+    [
+        "root",
+        "Badge__root"
+    ],
+    [
+        "indicator",
+        "Badge__indicator"
+    ]
+];
+const badgeSlotRecipeSlotFns = /* @__PURE__ */ badgeSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, badgeSlotRecipeDefaultVariants, getSlotCompoundVariant(badgeSlotRecipeCompoundVariants, slotName))]);
+const badgeSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(badgeSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const badgeSlotRecipeVariantKeys = [
+    "hasChildren"
+];
+const getVariantProps = (variants) => ({ ...badgeSlotRecipeDefaultVariants, ...compact(variants) });
+export const badgeSlotRecipe = /* @__PURE__ */ Object.assign(badgeSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'badgeSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: badgeSlotRecipeVariantKeys,
+    variantMap: {
+        "hasChildren": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, badgeSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/base-main-navigation-slot-recipe.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BaseMainNavigationSlotRecipeVariant {
+  width: "normal" | "wide"
+disableResponsive: boolean
+}
+
+type BaseMainNavigationSlotRecipeVariantMap = {
+  [key in keyof BaseMainNavigationSlotRecipeVariant]: Array<BaseMainNavigationSlotRecipeVariant[key]>
+}
+
+type BaseMainNavigationSlotRecipeSlot = "root" | "nav" | "list" | "featureShortcut" | "featureShortcutAnchor" | "labelGroup" | "iconAndLabel" | "lockIcon" | "listItem" | "listItemTooltip" | "listItemAnchor" | "listItemAnchorIcon" | "parentDetails" | "parentSummary" | "parentSummaryIcon" | "childrenList" | "childrenListItem" | "childrenListItemAnchor" | "popoverChildrenList" | "footer" | "toggleButton" | "toggleButtonIcon"
+
+export type BaseMainNavigationSlotRecipeVariantProps = {
+  [key in keyof BaseMainNavigationSlotRecipeVariant]?: ConditionalValue<BaseMainNavigationSlotRecipeVariant[key]> | undefined
+}
+
+export interface BaseMainNavigationSlotRecipeRecipe {
+  __slot: BaseMainNavigationSlotRecipeSlot
+  __type: BaseMainNavigationSlotRecipeVariantProps
+  (props?: BaseMainNavigationSlotRecipeVariantProps): Pretty<Record<BaseMainNavigationSlotRecipeSlot, string>>
+  raw: (props?: BaseMainNavigationSlotRecipeVariantProps) => BaseMainNavigationSlotRecipeVariantProps
+  variantMap: BaseMainNavigationSlotRecipeVariantMap
+  variantKeys: Array<keyof BaseMainNavigationSlotRecipeVariant>
+  splitVariantProps<Props extends BaseMainNavigationSlotRecipeVariantProps>(props: Props): [BaseMainNavigationSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BaseMainNavigationSlotRecipeVariantProps>>]
+  getVariantProps: (props?: BaseMainNavigationSlotRecipeVariantProps) => BaseMainNavigationSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI BaseMainNavigation component
+ */
+export declare const baseMainNavigationSlotRecipe: BaseMainNavigationSlotRecipeRecipe

package/dist/esm/styled-system/recipes/base-main-navigation-slot-recipe.js

@@ -0,0 +1,124 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const baseMainNavigationSlotRecipeDefaultVariants = {};
+const baseMainNavigationSlotRecipeCompoundVariants = [];
+const baseMainNavigationSlotRecipeSlotNames = [
+    [
+        "root",
+        "BaseMainNavigation__root"
+    ],
+    [
+        "nav",
+        "BaseMainNavigation__nav"
+    ],
+    [
+        "list",
+        "BaseMainNavigation__list"
+    ],
+    [
+        "featureShortcut",
+        "BaseMainNavigation__featureShortcut"
+    ],
+    [
+        "featureShortcutAnchor",
+        "BaseMainNavigation__featureShortcutAnchor"
+    ],
+    [
+        "labelGroup",
+        "BaseMainNavigation__labelGroup"
+    ],
+    [
+        "iconAndLabel",
+        "BaseMainNavigation__iconAndLabel"
+    ],
+    [
+        "lockIcon",
+        "BaseMainNavigation__lockIcon"
+    ],
+    [
+        "listItem",
+        "BaseMainNavigation__listItem"
+    ],
+    [
+        "listItemTooltip",
+        "BaseMainNavigation__listItemTooltip"
+    ],
+    [
+        "listItemAnchor",
+        "BaseMainNavigation__listItemAnchor"
+    ],
+    [
+        "listItemAnchorIcon",
+        "BaseMainNavigation__listItemAnchorIcon"
+    ],
+    [
+        "parentDetails",
+        "BaseMainNavigation__parentDetails"
+    ],
+    [
+        "parentSummary",
+        "BaseMainNavigation__parentSummary"
+    ],
+    [
+        "parentSummaryIcon",
+        "BaseMainNavigation__parentSummaryIcon"
+    ],
+    [
+        "childrenList",
+        "BaseMainNavigation__childrenList"
+    ],
+    [
+        "childrenListItem",
+        "BaseMainNavigation__childrenListItem"
+    ],
+    [
+        "childrenListItemAnchor",
+        "BaseMainNavigation__childrenListItemAnchor"
+    ],
+    [
+        "popoverChildrenList",
+        "BaseMainNavigation__popoverChildrenList"
+    ],
+    [
+        "footer",
+        "BaseMainNavigation__footer"
+    ],
+    [
+        "toggleButton",
+        "BaseMainNavigation__toggleButton"
+    ],
+    [
+        "toggleButtonIcon",
+        "BaseMainNavigation__toggleButtonIcon"
+    ]
+];
+const baseMainNavigationSlotRecipeSlotFns = /* @__PURE__ */ baseMainNavigationSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, baseMainNavigationSlotRecipeDefaultVariants, getSlotCompoundVariant(baseMainNavigationSlotRecipeCompoundVariants, slotName))]);
+const baseMainNavigationSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(baseMainNavigationSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const baseMainNavigationSlotRecipeVariantKeys = [
+    "width",
+    "disableResponsive"
+];
+const getVariantProps = (variants) => ({ ...baseMainNavigationSlotRecipeDefaultVariants, ...compact(variants) });
+export const baseMainNavigationSlotRecipe = /* @__PURE__ */ Object.assign(baseMainNavigationSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'baseMainNavigationSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: baseMainNavigationSlotRecipeVariantKeys,
+    variantMap: {
+        "width": [
+            "normal",
+            "wide"
+        ],
+        "disableResponsive": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, baseMainNavigationSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/button-slot-recipe.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ButtonSlotRecipeVariant {
+  size: "small" | "medium" | "large"
+priority: "primary" | "secondary" | "tertiary"
+destructive: boolean
+}
+
+type ButtonSlotRecipeVariantMap = {
+  [key in keyof ButtonSlotRecipeVariant]: Array<ButtonSlotRecipeVariant[key]>
+}
+
+type ButtonSlotRecipeSlot = "root" | "leftIcon" | "rightIcon" | "dropdownIcon" | "loadingIndicator"
+
+export type ButtonSlotRecipeVariantProps = {
+  [key in keyof ButtonSlotRecipeVariant]?: ButtonSlotRecipeVariant[key] | undefined
+}
+
+export interface ButtonSlotRecipeRecipe {
+  __slot: ButtonSlotRecipeSlot
+  __type: ButtonSlotRecipeVariantProps
+  (props?: ButtonSlotRecipeVariantProps): Pretty<Record<ButtonSlotRecipeSlot, string>>
+  raw: (props?: ButtonSlotRecipeVariantProps) => ButtonSlotRecipeVariantProps
+  variantMap: ButtonSlotRecipeVariantMap
+  variantKeys: Array<keyof ButtonSlotRecipeVariant>
+  splitVariantProps<Props extends ButtonSlotRecipeVariantProps>(props: Props): [ButtonSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ButtonSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ButtonSlotRecipeVariantProps) => ButtonSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Button component.
+ */
+export declare const buttonSlotRecipe: ButtonSlotRecipeRecipe