@moneyforward/mfui-components 2.48.1

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subNavigationSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const subNavigationSlotRecipeDefaultVariants = {};
+const subNavigationSlotRecipeCompoundVariants = [];
+const subNavigationSlotRecipeSlotNames = [
+    [
+        "root",
+        "SubNavigation__root"
+    ],
+    [
+        "list",
+        "SubNavigation__list"
+    ],
+    [
+        "listItem",
+        "SubNavigation__listItem"
+    ],
+    [
+        "link",
+        "SubNavigation__link"
+    ],
+    [
+        "labelIcon",
+        "SubNavigation__labelIcon"
+    ],
+    [
+        "label",
+        "SubNavigation__label"
+    ],
+    [
+        "statusSlot",
+        "SubNavigation__statusSlot"
+    ],
+    [
+        "details",
+        "SubNavigation__details"
+    ],
+    [
+        "summary",
+        "SubNavigation__summary"
+    ],
+    [
+        "disclosureIcon",
+        "SubNavigation__disclosureIcon"
+    ],
+    [
+        "nestedListItem",
+        "SubNavigation__nestedListItem"
+    ]
+];
+const subNavigationSlotRecipeSlotFns = /* @__PURE__ */ subNavigationSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, subNavigationSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(subNavigationSlotRecipeCompoundVariants, slotName))]);
+const subNavigationSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(subNavigationSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const subNavigationSlotRecipeVariantKeys = [
+    "orientation",
+    "hasLabelIcon"
+];
+const getVariantProps = (variants) => ({ ...subNavigationSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.subNavigationSlotRecipe = Object.assign(subNavigationSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'subNavigationSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: subNavigationSlotRecipeVariantKeys,
+    variantMap: {
+        "orientation": [
+            "vertical",
+            "horizontal"
+        ],
+        "hasLabelIcon": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, subNavigationSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/tab-item-slot-recipe.d.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TabItemSlotRecipeVariant {
+  /**
+ * @default false
+ */
+selected: boolean
+/**
+ * @default "only"
+ */
+position: "start" | "middle" | "end" | "only"
+}
+
+type TabItemSlotRecipeVariantMap = {
+  [key in keyof TabItemSlotRecipeVariant]: Array<TabItemSlotRecipeVariant[key]>
+}
+
+type TabItemSlotRecipeSlot = "button" | "tooltip" | "badge" | "selectedIndicator" | "label"
+
+export type TabItemSlotRecipeVariantProps = {
+  [key in keyof TabItemSlotRecipeVariant]?: ConditionalValue<TabItemSlotRecipeVariant[key]> | undefined
+}
+
+export interface TabItemSlotRecipeRecipe {
+  __slot: TabItemSlotRecipeSlot
+  __type: TabItemSlotRecipeVariantProps
+  (props?: TabItemSlotRecipeVariantProps): Pretty<Record<TabItemSlotRecipeSlot, string>>
+  raw: (props?: TabItemSlotRecipeVariantProps) => TabItemSlotRecipeVariantProps
+  variantMap: TabItemSlotRecipeVariantMap
+  variantKeys: Array<keyof TabItemSlotRecipeVariant>
+  splitVariantProps<Props extends TabItemSlotRecipeVariantProps>(props: Props): [TabItemSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabItemSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TabItemSlotRecipeVariantProps) => TabItemSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI TabItem component.
+ */
+export declare const tabItemSlotRecipe: TabItemSlotRecipeRecipe

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tabItemSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const tabItemSlotRecipeDefaultVariants = {
+    "selected": false,
+    "position": "only"
+};
+const tabItemSlotRecipeCompoundVariants = [];
+const tabItemSlotRecipeSlotNames = [
+    [
+        "button",
+        "TabItem__button"
+    ],
+    [
+        "tooltip",
+        "TabItem__tooltip"
+    ],
+    [
+        "badge",
+        "TabItem__badge"
+    ],
+    [
+        "selectedIndicator",
+        "TabItem__selectedIndicator"
+    ],
+    [
+        "label",
+        "TabItem__label"
+    ]
+];
+const tabItemSlotRecipeSlotFns = /* @__PURE__ */ tabItemSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, tabItemSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(tabItemSlotRecipeCompoundVariants, slotName))]);
+const tabItemSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(tabItemSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const tabItemSlotRecipeVariantKeys = [
+    "selected",
+    "position"
+];
+const getVariantProps = (variants) => ({ ...tabItemSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.tabItemSlotRecipe = Object.assign(tabItemSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'tabItemSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: tabItemSlotRecipeVariantKeys,
+    variantMap: {
+        "selected": [
+            "true",
+            "false"
+        ],
+        "position": [
+            "start",
+            "middle",
+            "end",
+            "only"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, tabItemSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/tab-list-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 TabListSlotRecipeVariant {
+  
+}
+
+type TabListSlotRecipeVariantMap = {
+  [key in keyof TabListSlotRecipeVariant]: Array<TabListSlotRecipeVariant[key]>
+}
+
+type TabListSlotRecipeSlot = "root" | "tabList" | "blankSpace" | "isOverflowed"
+
+export type TabListSlotRecipeVariantProps = {
+  [key in keyof TabListSlotRecipeVariant]?: ConditionalValue<TabListSlotRecipeVariant[key]> | undefined
+}
+
+export interface TabListSlotRecipeRecipe {
+  __slot: TabListSlotRecipeSlot
+  __type: TabListSlotRecipeVariantProps
+  (props?: TabListSlotRecipeVariantProps): Pretty<Record<TabListSlotRecipeSlot, string>>
+  raw: (props?: TabListSlotRecipeVariantProps) => TabListSlotRecipeVariantProps
+  variantMap: TabListSlotRecipeVariantMap
+  variantKeys: Array<keyof TabListSlotRecipeVariant>
+  splitVariantProps<Props extends TabListSlotRecipeVariantProps>(props: Props): [TabListSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabListSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TabListSlotRecipeVariantProps) => TabListSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI TabList component.
+ */
+export declare const tabListSlotRecipe: TabListSlotRecipeRecipe

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tabListSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const tabListSlotRecipeDefaultVariants = {};
+const tabListSlotRecipeCompoundVariants = [];
+const tabListSlotRecipeSlotNames = [
+    [
+        "root",
+        "TabList__root"
+    ],
+    [
+        "tabList",
+        "TabList__tabList"
+    ],
+    [
+        "blankSpace",
+        "TabList__blankSpace"
+    ],
+    [
+        "isOverflowed",
+        "TabList__isOverflowed"
+    ]
+];
+const tabListSlotRecipeSlotFns = /* @__PURE__ */ tabListSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, tabListSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(tabListSlotRecipeCompoundVariants, slotName))]);
+const tabListSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(tabListSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const tabListSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...tabListSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.tabListSlotRecipe = Object.assign(tabListSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'tabListSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: tabListSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, tabListSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/tab-menu-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 TabMenuSlotRecipeVariant {
+  
+}
+
+type TabMenuSlotRecipeVariantMap = {
+  [key in keyof TabMenuSlotRecipeVariant]: Array<TabMenuSlotRecipeVariant[key]>
+}
+
+type TabMenuSlotRecipeSlot = "root" | "scrollButtons" | "scrollButton"
+
+export type TabMenuSlotRecipeVariantProps = {
+  [key in keyof TabMenuSlotRecipeVariant]?: ConditionalValue<TabMenuSlotRecipeVariant[key]> | undefined
+}
+
+export interface TabMenuSlotRecipeRecipe {
+  __slot: TabMenuSlotRecipeSlot
+  __type: TabMenuSlotRecipeVariantProps
+  (props?: TabMenuSlotRecipeVariantProps): Pretty<Record<TabMenuSlotRecipeSlot, string>>
+  raw: (props?: TabMenuSlotRecipeVariantProps) => TabMenuSlotRecipeVariantProps
+  variantMap: TabMenuSlotRecipeVariantMap
+  variantKeys: Array<keyof TabMenuSlotRecipeVariant>
+  splitVariantProps<Props extends TabMenuSlotRecipeVariantProps>(props: Props): [TabMenuSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabMenuSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TabMenuSlotRecipeVariantProps) => TabMenuSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI TabMenu component.
+ */
+export declare const tabMenuSlotRecipe: TabMenuSlotRecipeRecipe

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tabMenuSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const tabMenuSlotRecipeDefaultVariants = {};
+const tabMenuSlotRecipeCompoundVariants = [];
+const tabMenuSlotRecipeSlotNames = [
+    [
+        "root",
+        "TabMenu__root"
+    ],
+    [
+        "scrollButtons",
+        "TabMenu__scrollButtons"
+    ],
+    [
+        "scrollButton",
+        "TabMenu__scrollButton"
+    ]
+];
+const tabMenuSlotRecipeSlotFns = /* @__PURE__ */ tabMenuSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, tabMenuSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(tabMenuSlotRecipeCompoundVariants, slotName))]);
+const tabMenuSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(tabMenuSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const tabMenuSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...tabMenuSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.tabMenuSlotRecipe = Object.assign(tabMenuSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'tabMenuSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: tabMenuSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, tabMenuSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/tab-panel-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 TabPanelSlotRecipeVariant {
+  
+}
+
+type TabPanelSlotRecipeVariantMap = {
+  [key in keyof TabPanelSlotRecipeVariant]: Array<TabPanelSlotRecipeVariant[key]>
+}
+
+type TabPanelSlotRecipeSlot = "root"
+
+export type TabPanelSlotRecipeVariantProps = {
+  [key in keyof TabPanelSlotRecipeVariant]?: ConditionalValue<TabPanelSlotRecipeVariant[key]> | undefined
+}
+
+export interface TabPanelSlotRecipeRecipe {
+  __slot: TabPanelSlotRecipeSlot
+  __type: TabPanelSlotRecipeVariantProps
+  (props?: TabPanelSlotRecipeVariantProps): Pretty<Record<TabPanelSlotRecipeSlot, string>>
+  raw: (props?: TabPanelSlotRecipeVariantProps) => TabPanelSlotRecipeVariantProps
+  variantMap: TabPanelSlotRecipeVariantMap
+  variantKeys: Array<keyof TabPanelSlotRecipeVariant>
+  splitVariantProps<Props extends TabPanelSlotRecipeVariantProps>(props: Props): [TabPanelSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabPanelSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TabPanelSlotRecipeVariantProps) => TabPanelSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI TabPanel component.
+ */
+export declare const tabPanelSlotRecipe: TabPanelSlotRecipeRecipe

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

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

package/dist/cjs/styled-system/recipes/tabs-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 TabsSlotRecipeVariant {
+  
+}
+
+type TabsSlotRecipeVariantMap = {
+  [key in keyof TabsSlotRecipeVariant]: Array<TabsSlotRecipeVariant[key]>
+}
+
+type TabsSlotRecipeSlot = "root"
+
+export type TabsSlotRecipeVariantProps = {
+  [key in keyof TabsSlotRecipeVariant]?: ConditionalValue<TabsSlotRecipeVariant[key]> | undefined
+}
+
+export interface TabsSlotRecipeRecipe {
+  __slot: TabsSlotRecipeSlot
+  __type: TabsSlotRecipeVariantProps
+  (props?: TabsSlotRecipeVariantProps): Pretty<Record<TabsSlotRecipeSlot, string>>
+  raw: (props?: TabsSlotRecipeVariantProps) => TabsSlotRecipeVariantProps
+  variantMap: TabsSlotRecipeVariantMap
+  variantKeys: Array<keyof TabsSlotRecipeVariant>
+  splitVariantProps<Props extends TabsSlotRecipeVariantProps>(props: Props): [TabsSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabsSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TabsSlotRecipeVariantProps) => TabsSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Tabs component.
+ */
+export declare const tabsSlotRecipe: TabsSlotRecipeRecipe

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

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

package/dist/cjs/styled-system/recipes/tag-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 TagSlotRecipeVariant {
+  interactable: boolean
+showCloseButton: boolean
+}
+
+type TagSlotRecipeVariantMap = {
+  [key in keyof TagSlotRecipeVariant]: Array<TagSlotRecipeVariant[key]>
+}
+
+type TagSlotRecipeSlot = "root" | "wrapper" | "closeButton"
+
+export type TagSlotRecipeVariantProps = {
+  [key in keyof TagSlotRecipeVariant]?: ConditionalValue<TagSlotRecipeVariant[key]> | undefined
+}
+
+export interface TagSlotRecipeRecipe {
+  __slot: TagSlotRecipeSlot
+  __type: TagSlotRecipeVariantProps
+  (props?: TagSlotRecipeVariantProps): Pretty<Record<TagSlotRecipeSlot, string>>
+  raw: (props?: TagSlotRecipeVariantProps) => TagSlotRecipeVariantProps
+  variantMap: TagSlotRecipeVariantMap
+  variantKeys: Array<keyof TagSlotRecipeVariant>
+  splitVariantProps<Props extends TagSlotRecipeVariantProps>(props: Props): [TagSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TagSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TagSlotRecipeVariantProps) => TagSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Tag component.
+ */
+export declare const tagSlotRecipe: TagSlotRecipeRecipe

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const tagSlotRecipeDefaultVariants = {};
+const tagSlotRecipeCompoundVariants = [];
+const tagSlotRecipeSlotNames = [
+    [
+        "root",
+        "Tag__root"
+    ],
+    [
+        "wrapper",
+        "Tag__wrapper"
+    ],
+    [
+        "closeButton",
+        "Tag__closeButton"
+    ]
+];
+const tagSlotRecipeSlotFns = /* @__PURE__ */ tagSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, tagSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(tagSlotRecipeCompoundVariants, slotName))]);
+const tagSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(tagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const tagSlotRecipeVariantKeys = [
+    "interactable",
+    "showCloseButton"
+];
+const getVariantProps = (variants) => ({ ...tagSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.tagSlotRecipe = Object.assign(tagSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'tagSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: tagSlotRecipeVariantKeys,
+    variantMap: {
+        "interactable": [
+            "true",
+            "false"
+        ],
+        "showCloseButton": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, tagSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/cjs/styled-system/recipes/text-box-slot-recipe.d.ts

@@ -0,0 +1,44 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextBoxSlotRecipeVariant {
+  /**
+ * @default "medium"
+ */
+size: "small" | "medium" | "large"
+/**
+ * @default false
+ */
+disabled: boolean
+/**
+ * @default false
+ */
+invalid: boolean
+}
+
+type TextBoxSlotRecipeVariantMap = {
+  [key in keyof TextBoxSlotRecipeVariant]: Array<TextBoxSlotRecipeVariant[key]>
+}
+
+type TextBoxSlotRecipeSlot = "root" | "prefix" | "input" | "clearButton" | "suffix"
+
+export type TextBoxSlotRecipeVariantProps = {
+  [key in keyof TextBoxSlotRecipeVariant]?: ConditionalValue<TextBoxSlotRecipeVariant[key]> | undefined
+}
+
+export interface TextBoxSlotRecipeRecipe {
+  __slot: TextBoxSlotRecipeSlot
+  __type: TextBoxSlotRecipeVariantProps
+  (props?: TextBoxSlotRecipeVariantProps): Pretty<Record<TextBoxSlotRecipeSlot, string>>
+  raw: (props?: TextBoxSlotRecipeVariantProps) => TextBoxSlotRecipeVariantProps
+  variantMap: TextBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof TextBoxSlotRecipeVariant>
+  splitVariantProps<Props extends TextBoxSlotRecipeVariantProps>(props: Props): [TextBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TextBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: TextBoxSlotRecipeVariantProps) => TextBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI TextBox component.
+ */
+export declare const textBoxSlotRecipe: TextBoxSlotRecipeRecipe

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textBoxSlotRecipe = void 0;
+const helpers_js_1 = require("../helpers.js");
+const create_recipe_js_1 = require("./create-recipe.js");
+const textBoxSlotRecipeDefaultVariants = {
+    "size": "medium",
+    "disabled": false,
+    "invalid": false
+};
+const textBoxSlotRecipeCompoundVariants = [];
+const textBoxSlotRecipeSlotNames = [
+    [
+        "root",
+        "TextBox__root"
+    ],
+    [
+        "prefix",
+        "TextBox__prefix"
+    ],
+    [
+        "input",
+        "TextBox__input"
+    ],
+    [
+        "clearButton",
+        "TextBox__clearButton"
+    ],
+    [
+        "suffix",
+        "TextBox__suffix"
+    ]
+];
+const textBoxSlotRecipeSlotFns = /* @__PURE__ */ textBoxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, (0, create_recipe_js_1.createRecipe)(slotKey, textBoxSlotRecipeDefaultVariants, (0, helpers_js_1.getSlotCompoundVariant)(textBoxSlotRecipeCompoundVariants, slotName))]);
+const textBoxSlotRecipeFn = (0, helpers_js_1.memo)((props = {}) => {
+    return Object.fromEntries(textBoxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const textBoxSlotRecipeVariantKeys = [
+    "size",
+    "disabled",
+    "invalid"
+];
+const getVariantProps = (variants) => ({ ...textBoxSlotRecipeDefaultVariants, ...(0, helpers_js_1.compact)(variants) });
+exports.textBoxSlotRecipe = Object.assign(textBoxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'textBoxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: textBoxSlotRecipeVariantKeys,
+    variantMap: {
+        "size": [
+            "small",
+            "medium",
+            "large"
+        ],
+        "disabled": [
+            "true",
+            "false"
+        ],
+        "invalid": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return (0, helpers_js_1.splitProps)(props, textBoxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});