@mekari/pixel3-styled-system 0.0.1 → 0.0.2

package/recipes/banner-slot-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BannerSlotRecipeVariant {
+  variant: "info" | "success" | "danger" | "warning"
+}
+
+type BannerSlotRecipeVariantMap = {
+  [key in keyof BannerSlotRecipeVariant]: Array<BannerSlotRecipeVariant[key]>
+}
+
+export type BannerSlotRecipeVariantProps = {
+  [key in keyof BannerSlotRecipeVariant]?: ConditionalValue<BannerSlotRecipeVariant[key]> | undefined
+}
+
+export interface BannerSlotRecipeRecipe {
+  __type: BannerSlotRecipeVariantProps
+  (props?: BannerSlotRecipeVariantProps): Pretty<Record<"root" | "body", string>>
+  raw: (props?: BannerSlotRecipeVariantProps) => BannerSlotRecipeVariantProps
+  variantMap: BannerSlotRecipeVariantMap
+  variantKeys: Array<keyof BannerSlotRecipeVariant>
+  splitVariantProps<Props extends BannerSlotRecipeVariantProps>(props: Props): [BannerSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BannerSlotRecipeVariantProps>>]
+}
+
+
+export declare const bannerSlotRecipe: BannerSlotRecipeRecipe

package/recipes/banner-slot-recipe.mjs

@@ -0,0 +1,45 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const bannerSlotRecipeDefaultVariants = {
+  "variant": "info"
+}
+const bannerSlotRecipeCompoundVariants = []
+
+const bannerSlotRecipeSlotNames = [
+  [
+    "root",
+    "banner__root"
+  ],
+  [
+    "body",
+    "banner__body"
+  ]
+]
+const bannerSlotRecipeSlotFns = /* @__PURE__ */ bannerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, bannerSlotRecipeDefaultVariants, getSlotCompoundVariant(bannerSlotRecipeCompoundVariants, slotName))])
+
+const bannerSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(bannerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const bannerSlotRecipeVariantKeys = [
+  "variant"
+]
+
+export const bannerSlotRecipe = /* @__PURE__ */ Object.assign(bannerSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'bannerSlotRecipe',
+  raw: (props) => props,
+  variantKeys: bannerSlotRecipeVariantKeys,
+  variantMap: {
+  "variant": [
+    "info",
+    "success",
+    "danger",
+    "warning"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, bannerSlotRecipeVariantKeys)
+  },
+})

package/recipes/banner-title-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BannerTitleRecipeVariant {
+  
+}
+
+type BannerTitleRecipeVariantMap = {
+  [key in keyof BannerTitleRecipeVariant]: Array<BannerTitleRecipeVariant[key]>
+}
+
+export type BannerTitleRecipeVariantProps = {
+  [key in keyof BannerTitleRecipeVariant]?: ConditionalValue<BannerTitleRecipeVariant[key]> | undefined
+}
+
+export interface BannerTitleRecipeRecipe {
+  __type: BannerTitleRecipeVariantProps
+  (props?: BannerTitleRecipeVariantProps): string
+  raw: (props?: BannerTitleRecipeVariantProps) => BannerTitleRecipeVariantProps
+  variantMap: BannerTitleRecipeVariantMap
+  variantKeys: Array<keyof BannerTitleRecipeVariant>
+  splitVariantProps<Props extends BannerTitleRecipeVariantProps>(props: Props): [BannerTitleRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof BannerTitleRecipeVariantProps>>]
+}
+
+
+export declare const bannerTitleRecipe: BannerTitleRecipeRecipe

package/recipes/banner-title-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const bannerTitleRecipeFn = /* @__PURE__ */ createRecipe('banner-title', {}, [])
+
+const bannerTitleRecipeVariantMap = {}
+
+const bannerTitleRecipeVariantKeys = Object.keys(bannerTitleRecipeVariantMap)
+
+export const bannerTitleRecipe = /* @__PURE__ */ Object.assign(bannerTitleRecipeFn, {
+  __recipe__: true,
+  __name__: 'bannerTitleRecipe',
+  raw: (props) => props,
+  variantKeys: bannerTitleRecipeVariantKeys,
+  variantMap: bannerTitleRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, bannerTitleRecipeVariantKeys)
+  },
+})

package/recipes/dropzone-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DropzoneRecipeVariant {
+  
+}
+
+type DropzoneRecipeVariantMap = {
+  [key in keyof DropzoneRecipeVariant]: Array<DropzoneRecipeVariant[key]>
+}
+
+export type DropzoneRecipeVariantProps = {
+  [key in keyof DropzoneRecipeVariant]?: ConditionalValue<DropzoneRecipeVariant[key]> | undefined
+}
+
+export interface DropzoneRecipeRecipe {
+  __type: DropzoneRecipeVariantProps
+  (props?: DropzoneRecipeVariantProps): Pretty<Record<"root" | "wrapper", string>>
+  raw: (props?: DropzoneRecipeVariantProps) => DropzoneRecipeVariantProps
+  variantMap: DropzoneRecipeVariantMap
+  variantKeys: Array<keyof DropzoneRecipeVariant>
+  splitVariantProps<Props extends DropzoneRecipeVariantProps>(props: Props): [DropzoneRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropzoneRecipeVariantProps>>]
+}
+
+
+export declare const dropzoneRecipe: DropzoneRecipeRecipe

package/recipes/dropzone-recipe.mjs

@@ -0,0 +1,34 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dropzoneRecipeDefaultVariants = {}
+const dropzoneRecipeCompoundVariants = []
+
+const dropzoneRecipeSlotNames = [
+  [
+    "root",
+    "dropzone__root"
+  ],
+  [
+    "wrapper",
+    "dropzone__wrapper"
+  ]
+]
+const dropzoneRecipeSlotFns = /* @__PURE__ */ dropzoneRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropzoneRecipeDefaultVariants, getSlotCompoundVariant(dropzoneRecipeCompoundVariants, slotName))])
+
+const dropzoneRecipeFn = (props = {}) => {
+  return Object.fromEntries(dropzoneRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dropzoneRecipeVariantKeys = []
+
+export const dropzoneRecipe = /* @__PURE__ */ Object.assign(dropzoneRecipeFn, {
+  __recipe__: false,
+  __name__: 'dropzoneRecipe',
+  raw: (props) => props,
+  variantKeys: dropzoneRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dropzoneRecipeVariantKeys)
+  },
+})

package/recipes/dropzone-slot-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DropzoneSlotRecipeVariant {
+  
+}
+
+type DropzoneSlotRecipeVariantMap = {
+  [key in keyof DropzoneSlotRecipeVariant]: Array<DropzoneSlotRecipeVariant[key]>
+}
+
+export type DropzoneSlotRecipeVariantProps = {
+  [key in keyof DropzoneSlotRecipeVariant]?: ConditionalValue<DropzoneSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropzoneSlotRecipeRecipe {
+  __type: DropzoneSlotRecipeVariantProps
+  (props?: DropzoneSlotRecipeVariantProps): Pretty<Record<"root" | "wrapper" | "box" | "logoBox" | "productBox" | "avatarBox" | "overlayWrapper" | "overlay" | "preview" | "overlayPreview" | "clearButton", string>>
+  raw: (props?: DropzoneSlotRecipeVariantProps) => DropzoneSlotRecipeVariantProps
+  variantMap: DropzoneSlotRecipeVariantMap
+  variantKeys: Array<keyof DropzoneSlotRecipeVariant>
+  splitVariantProps<Props extends DropzoneSlotRecipeVariantProps>(props: Props): [DropzoneSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropzoneSlotRecipeVariantProps>>]
+}
+
+
+export declare const dropzoneSlotRecipe: DropzoneSlotRecipeRecipe

package/recipes/dropzone-slot-recipe.mjs

@@ -0,0 +1,70 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const dropzoneSlotRecipeDefaultVariants = {}
+const dropzoneSlotRecipeCompoundVariants = []
+
+const dropzoneSlotRecipeSlotNames = [
+  [
+    "root",
+    "dropzone__root"
+  ],
+  [
+    "wrapper",
+    "dropzone__wrapper"
+  ],
+  [
+    "box",
+    "dropzone__box"
+  ],
+  [
+    "logoBox",
+    "dropzone__logoBox"
+  ],
+  [
+    "productBox",
+    "dropzone__productBox"
+  ],
+  [
+    "avatarBox",
+    "dropzone__avatarBox"
+  ],
+  [
+    "overlayWrapper",
+    "dropzone__overlayWrapper"
+  ],
+  [
+    "overlay",
+    "dropzone__overlay"
+  ],
+  [
+    "preview",
+    "dropzone__preview"
+  ],
+  [
+    "overlayPreview",
+    "dropzone__overlayPreview"
+  ],
+  [
+    "clearButton",
+    "dropzone__clearButton"
+  ]
+]
+const dropzoneSlotRecipeSlotFns = /* @__PURE__ */ dropzoneSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropzoneSlotRecipeDefaultVariants, getSlotCompoundVariant(dropzoneSlotRecipeCompoundVariants, slotName))])
+
+const dropzoneSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(dropzoneSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const dropzoneSlotRecipeVariantKeys = []
+
+export const dropzoneSlotRecipe = /* @__PURE__ */ Object.assign(dropzoneSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'dropzoneSlotRecipe',
+  raw: (props) => props,
+  variantKeys: dropzoneSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, dropzoneSlotRecipeVariantKeys)
+  },
+})

package/recipes/index.d.ts

@@ -16,6 +16,10 @@ export * from './selected-border-recipe';
 export * from './table-recipe';
 export * from './table-container-recipe';
 export * from './divider-recipe';
+export * from './banner-title-recipe';
+export * from './banner-description-recipe';
+export * from './banner-link-recipe';
+export * from './banner-close-button-recipe';
 export * from './accordion';
 export * from './checkbox-slot-recipe';
 export * from './radio-slot-recipe';
@@ -30,4 +34,10 @@ export * from './avatar-slot-recipe';
 export * from './avatar-group-slot-recipe';
 export * from './select-slot-recipe';
 export * from './form-control-slot-recipe';
-export * from './input-tag-slot-recipe';
+export * from './input-tag-slot-recipe';
+export * from './modal-slot-recipe';
+export * from './upload-slot-recipe';
+export * from './upload-list-slot-recipe';
+export * from './dropzone-slot-recipe';
+export * from './banner-slot-recipe';
+export * from './banner-icon-slot-recipe';

package/recipes/index.mjs

@@ -15,6 +15,10 @@ export * from './selected-border-recipe.mjs';
 export * from './table-recipe.mjs';
 export * from './table-container-recipe.mjs';
 export * from './divider-recipe.mjs';
+export * from './banner-title-recipe.mjs';
+export * from './banner-description-recipe.mjs';
+export * from './banner-link-recipe.mjs';
+export * from './banner-close-button-recipe.mjs';
 export * from './accordion.mjs';
 export * from './checkbox-slot-recipe.mjs';
 export * from './radio-slot-recipe.mjs';
@@ -29,4 +33,10 @@ export * from './avatar-slot-recipe.mjs';
 export * from './avatar-group-slot-recipe.mjs';
 export * from './select-slot-recipe.mjs';
 export * from './form-control-slot-recipe.mjs';
-export * from './input-tag-slot-recipe.mjs';
+export * from './input-tag-slot-recipe.mjs';
+export * from './modal-slot-recipe.mjs';
+export * from './upload-slot-recipe.mjs';
+export * from './upload-list-slot-recipe.mjs';
+export * from './dropzone-slot-recipe.mjs';
+export * from './banner-slot-recipe.mjs';
+export * from './banner-icon-slot-recipe.mjs';

package/recipes/modal-slot-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ModalSlotRecipeVariant {
+  full: boolean
+}
+
+type ModalSlotRecipeVariantMap = {
+  [key in keyof ModalSlotRecipeVariant]: Array<ModalSlotRecipeVariant[key]>
+}
+
+export type ModalSlotRecipeVariantProps = {
+  [key in keyof ModalSlotRecipeVariant]?: ConditionalValue<ModalSlotRecipeVariant[key]> | undefined
+}
+
+export interface ModalSlotRecipeRecipe {
+  __type: ModalSlotRecipeVariantProps
+  (props?: ModalSlotRecipeVariantProps): Pretty<Record<"root" | "rootChild" | "body" | "contentRoot" | "contentChild" | "header" | "footer" | "body" | "overlay" | "closeButton", string>>
+  raw: (props?: ModalSlotRecipeVariantProps) => ModalSlotRecipeVariantProps
+  variantMap: ModalSlotRecipeVariantMap
+  variantKeys: Array<keyof ModalSlotRecipeVariant>
+  splitVariantProps<Props extends ModalSlotRecipeVariantProps>(props: Props): [ModalSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ModalSlotRecipeVariantProps>>]
+}
+
+/** The styles for the Modal component */
+export declare const modalSlotRecipe: ModalSlotRecipeRecipe

package/recipes/modal-slot-recipe.mjs

@@ -0,0 +1,75 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const modalSlotRecipeDefaultVariants = {
+  "full": false
+}
+const modalSlotRecipeCompoundVariants = []
+
+const modalSlotRecipeSlotNames = [
+  [
+    "root",
+    "modal__root"
+  ],
+  [
+    "rootChild",
+    "modal__rootChild"
+  ],
+  [
+    "body",
+    "modal__body"
+  ],
+  [
+    "contentRoot",
+    "modal__contentRoot"
+  ],
+  [
+    "contentChild",
+    "modal__contentChild"
+  ],
+  [
+    "header",
+    "modal__header"
+  ],
+  [
+    "footer",
+    "modal__footer"
+  ],
+  [
+    "body",
+    "modal__body"
+  ],
+  [
+    "overlay",
+    "modal__overlay"
+  ],
+  [
+    "closeButton",
+    "modal__closeButton"
+  ]
+]
+const modalSlotRecipeSlotFns = /* @__PURE__ */ modalSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, modalSlotRecipeDefaultVariants, getSlotCompoundVariant(modalSlotRecipeCompoundVariants, slotName))])
+
+const modalSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(modalSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const modalSlotRecipeVariantKeys = [
+  "full"
+]
+
+export const modalSlotRecipe = /* @__PURE__ */ Object.assign(modalSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'modalSlotRecipe',
+  raw: (props) => props,
+  variantKeys: modalSlotRecipeVariantKeys,
+  variantMap: {
+  "full": [
+    "true",
+    "false"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, modalSlotRecipeVariantKeys)
+  },
+})

package/recipes/tag-slot-recipe.mjs

@@ -6,11 +6,19 @@ const tagSlotRecipeDefaultVariants = {
   "variant": "gray"
 }
 const tagSlotRecipeCompoundVariants = [
+  {
+    "variant": "gray",
+    "css": {
+      "close": {
+        "background": "linear-gradient(270deg, #EDF0F2 75%, rgba(237, 240, 242, 0) 111.54%)"
+      }
+    }
+  },
   {
     "variant": "red",
     "css": {
       "close": {
-        "background": "linear-gradient(270deg, #FDECEE 75%, rgba(237, 240, 242, 0) 111.54%)!"
+        "background": "linear-gradient(270deg, #FDECEE 75%, rgba(237, 240, 242, 0) 111.54%)"
       }
     }
   },

package/recipes/upload-list-slot-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface UploadListSlotRecipeVariant {
+  
+}
+
+type UploadListSlotRecipeVariantMap = {
+  [key in keyof UploadListSlotRecipeVariant]: Array<UploadListSlotRecipeVariant[key]>
+}
+
+export type UploadListSlotRecipeVariantProps = {
+  [key in keyof UploadListSlotRecipeVariant]?: ConditionalValue<UploadListSlotRecipeVariant[key]> | undefined
+}
+
+export interface UploadListSlotRecipeRecipe {
+  __type: UploadListSlotRecipeVariantProps
+  (props?: UploadListSlotRecipeVariantProps): Pretty<Record<"root" | "titleWrapper" | "actionWrapper", string>>
+  raw: (props?: UploadListSlotRecipeVariantProps) => UploadListSlotRecipeVariantProps
+  variantMap: UploadListSlotRecipeVariantMap
+  variantKeys: Array<keyof UploadListSlotRecipeVariant>
+  splitVariantProps<Props extends UploadListSlotRecipeVariantProps>(props: Props): [UploadListSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof UploadListSlotRecipeVariantProps>>]
+}
+
+
+export declare const uploadListSlotRecipe: UploadListSlotRecipeRecipe

package/recipes/upload-list-slot-recipe.mjs

@@ -0,0 +1,38 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const uploadListSlotRecipeDefaultVariants = {}
+const uploadListSlotRecipeCompoundVariants = []
+
+const uploadListSlotRecipeSlotNames = [
+  [
+    "root",
+    "upload-list__root"
+  ],
+  [
+    "titleWrapper",
+    "upload-list__titleWrapper"
+  ],
+  [
+    "actionWrapper",
+    "upload-list__actionWrapper"
+  ]
+]
+const uploadListSlotRecipeSlotFns = /* @__PURE__ */ uploadListSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, uploadListSlotRecipeDefaultVariants, getSlotCompoundVariant(uploadListSlotRecipeCompoundVariants, slotName))])
+
+const uploadListSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(uploadListSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const uploadListSlotRecipeVariantKeys = []
+
+export const uploadListSlotRecipe = /* @__PURE__ */ Object.assign(uploadListSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'uploadListSlotRecipe',
+  raw: (props) => props,
+  variantKeys: uploadListSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, uploadListSlotRecipeVariantKeys)
+  },
+})

package/recipes/upload-slot-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface UploadSlotRecipeVariant {
+  
+}
+
+type UploadSlotRecipeVariantMap = {
+  [key in keyof UploadSlotRecipeVariant]: Array<UploadSlotRecipeVariant[key]>
+}
+
+export type UploadSlotRecipeVariantProps = {
+  [key in keyof UploadSlotRecipeVariant]?: ConditionalValue<UploadSlotRecipeVariant[key]> | undefined
+}
+
+export interface UploadSlotRecipeRecipe {
+  __type: UploadSlotRecipeVariantProps
+  (props?: UploadSlotRecipeVariantProps): Pretty<Record<"root" | "resetButton", string>>
+  raw: (props?: UploadSlotRecipeVariantProps) => UploadSlotRecipeVariantProps
+  variantMap: UploadSlotRecipeVariantMap
+  variantKeys: Array<keyof UploadSlotRecipeVariant>
+  splitVariantProps<Props extends UploadSlotRecipeVariantProps>(props: Props): [UploadSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof UploadSlotRecipeVariantProps>>]
+}
+
+
+export declare const uploadSlotRecipe: UploadSlotRecipeRecipe

package/recipes/upload-slot-recipe.mjs

@@ -0,0 +1,34 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const uploadSlotRecipeDefaultVariants = {}
+const uploadSlotRecipeCompoundVariants = []
+
+const uploadSlotRecipeSlotNames = [
+  [
+    "root",
+    "upload__root"
+  ],
+  [
+    "resetButton",
+    "upload__resetButton"
+  ]
+]
+const uploadSlotRecipeSlotFns = /* @__PURE__ */ uploadSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, uploadSlotRecipeDefaultVariants, getSlotCompoundVariant(uploadSlotRecipeCompoundVariants, slotName))])
+
+const uploadSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(uploadSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const uploadSlotRecipeVariantKeys = []
+
+export const uploadSlotRecipe = /* @__PURE__ */ Object.assign(uploadSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'uploadSlotRecipe',
+  raw: (props) => props,
+  variantKeys: uploadSlotRecipeVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, uploadSlotRecipeVariantKeys)
+  },
+})

package/tokens/index.css

@@ -142,6 +142,22 @@
   --mp-sizes-7\.5: 1.875rem;
   --mp-sizes-9\.5: 2.375rem;
   --mp-sizes-full: 100%;
+  --mp-sizes-3xs: 14rem;
+  --mp-sizes-2xs: 16rem;
+  --mp-sizes-xs: 20rem;
+  --mp-sizes-2xl: 42rem;
+  --mp-sizes-3xl: 48rem;
+  --mp-sizes-4xl: 56rem;
+  --mp-sizes-5xl: 64rem;
+  --mp-sizes-6xl: 72rem;
+  --mp-sizes-sm: 24rem;
+  --mp-sizes-md: 28rem;
+  --mp-sizes-lg: 32rem;
+  --mp-sizes-xl: 36rem;
+  --mp-sizes-containers-sm: 640px;
+  --mp-sizes-containers-md: 768px;
+  --mp-sizes-containers-lg: 1024px;
+  --mp-sizes-containers-xl: 1280px;
   --mp-sizes-breakpoint-sm: 22.5em;
   --mp-sizes-breakpoint-md: 48em;
   --mp-sizes-breakpoint-lg: 64em;