@fluentui/react-jsx-runtime 9.0.8 → 9.0.9

package/CHANGELOG.json

@@ -2,7 +2,22 @@
   "name": "@fluentui/react-jsx-runtime",
   "entries": [
     {
-      "date": "Thu, 14 Sep 2023 16:40:23 GMT",
+      "date": "Wed, 20 Sep 2023 14:13:57 GMT",
+      "tag": "@fluentui/react-jsx-runtime_v9.0.9",
+      "version": "9.0.9",
+      "comments": {
+        "patch": [
+          {
+            "author": "bernardo.sunderhus@gmail.com",
+            "package": "@fluentui/react-jsx-runtime",
+            "commit": "cd66e978f89f12e267759a194971ac2ebe46edef",
+            "comment": "fix: static children problem on render function"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 14 Sep 2023 16:44:47 GMT",
       "tag": "@fluentui/react-jsx-runtime_v9.0.8",
       "version": "9.0.8",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Change Log - @fluentui/react-jsx-runtime
 
-This log was last generated on Thu, 14 Sep 2023 16:40:23 GMT and should not be manually modified.
+This log was last generated on Wed, 20 Sep 2023 14:13:57 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.0.9](https://github.com/microsoft/fluentui/tree/@fluentui/react-jsx-runtime_v9.0.9)
+
+Wed, 20 Sep 2023 14:13:57 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-jsx-runtime_v9.0.8..@fluentui/react-jsx-runtime_v9.0.9)
+
+### Patches
+
+- fix: static children problem on render function ([PR #29162](https://github.com/microsoft/fluentui/pull/29162) by bernardo.sunderhus@gmail.com)
+
 ## [9.0.8](https://github.com/microsoft/fluentui/tree/@fluentui/react-jsx-runtime_v9.0.8)
 
-Thu, 14 Sep 2023 16:40:23 GMT 
+Thu, 14 Sep 2023 16:44:47 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-jsx-runtime_v9.0.7..@fluentui/react-jsx-runtime_v9.0.8)
 
 ### Patches

package/lib/jsx/createJSX.js

@@ -1,33 +1,15 @@
-import * as React from 'react';
 import { isSlot } from '@fluentui/react-utilities';
-import { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';
+import * as React from 'react';
 import { createCompatSlotComponent } from '../utils/createCompatSlotComponent';
-/**
- * @internal
- */ export const createJSX = (runtime)=>{
-    const jsxFromSlotComponent = (type, overrideProps, key, source, self)=>{
-        const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);
-        const props = {
-            ...slotProps,
-            ...overrideProps
-        };
-        if (renderFunction) {
-            return runtime(React.Fragment, {
-                children: renderFunction(elementType, props)
-            }, key, source, self);
-        }
-        return runtime(elementType, props, key, source, self);
-    };
-    return (type, overrideProps, key, source, self)=>{
+export const createJSX = (runtime, slotRuntime)=>(type, overrideProps, key, source, self)=>{
         // TODO:
         // this is for backwards compatibility with getSlotsNext
         // it should be removed once getSlotsNext is obsolete
         if (isSlot(overrideProps)) {
-            return jsxFromSlotComponent(createCompatSlotComponent(type, overrideProps), null, key, source, self);
+            return slotRuntime(createCompatSlotComponent(type, overrideProps), null, key, source, self);
         }
         if (isSlot(type)) {
-            return jsxFromSlotComponent(type, overrideProps, key, source, self);
+            return slotRuntime(type, overrideProps, key, source, self);
         }
-        return runtime(type, overrideProps, key, source, self);
+        return runtime(type, overrideProps, key);
     };
-};

package/lib/jsx/createJSX.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createJSX.ts"],"sourcesContent":["import * as React from 'react';\nimport { isSlot, type SlotComponentType, type UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport type { JSXRuntime } from '../utils/types';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\n\n/**\n * @internal\n */\nexport const createJSX = (runtime: JSXRuntime) => {\n  const jsxFromSlotComponent = <Props extends UnknownSlotProps>(\n    type: SlotComponentType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> => {\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n    const props: Props = { ...slotProps, ...overrideProps };\n\n    if (renderFunction) {\n      return runtime(\n        React.Fragment,\n        {\n          children: renderFunction(elementType, props),\n        },\n        key,\n        source,\n        self,\n      ) as React.ReactElement<Props>;\n    }\n    return runtime(elementType, props, key, source, self);\n  };\n\n  return <Props extends {}>(\n    type: React.ElementType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> => {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot<Props>(overrideProps)) {\n      return jsxFromSlotComponent(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n    }\n    if (isSlot<Props>(type)) {\n      return jsxFromSlotComponent(type, overrideProps, key, source, self);\n    }\n    return runtime(type, overrideProps, key, source, self);\n  };\n};\n"],"names":["React","isSlot","getMetadataFromSlotComponent","createCompatSlotComponent","createJSX","runtime","jsxFromSlotComponent","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","Fragment","children"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,MAAM,QAAuD,4BAA4B;AAClG,SAASC,4BAA4B,QAAQ,wCAAwC;AAErF,SAASC,yBAAyB,QAAQ,qCAAqC;AAE/E;;CAEC,GACD,OAAO,MAAMC,YAAY,CAACC;IACxB,MAAMC,uBAAuB,CAC3BC,MACAC,eACAC,KACAC,QACAC;QAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGb,6BAA6BK;QAEvF,MAAMO,QAAe;YAAE,GAAGC,SAAS;YAAE,GAAGP,aAAa;QAAC;QAEtD,IAAIK,gBAAgB;YAClB,OAAOR,QACLL,MAAMgB,QAAQ,EACd;gBACEC,UAAUJ,eAAeD,aAAaE;YACxC,GACAL,KACAC,QACAC;QAEJ;QACA,OAAON,QAAQO,aAAaE,OAAOL,KAAKC,QAAQC;IAClD;IAEA,OAAO,CACLJ,MACAC,eACAC,KACAC,QACAC;QAEA,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIV,OAAcO,gBAAgB;YAChC,OAAOF,qBAAqBH,0BAA0BI,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QACjG;QACA,IAAIV,OAAcM,OAAO;YACvB,OAAOD,qBAAqBC,MAAMC,eAAeC,KAAKC,QAAQC;QAChE;QACA,OAAON,QAAQE,MAAMC,eAAeC,KAAKC,QAAQC;IACnD;AACF,EAAE"}
+{"version":3,"sources":["createJSX.ts"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nimport { JSXRuntime, JSXSlotRuntime } from '../utils/types';\n\nexport const createJSX =\n  (runtime: JSXRuntime, slotRuntime: JSXSlotRuntime) =>\n  <Props extends {}>(\n    type: React.ElementType<Props>,\n    overrideProps: Props | null,\n    key?: React.Key,\n    source?: unknown,\n    self?: unknown,\n  ): React.ReactElement<Props> => {\n    // TODO:\n    // this is for backwards compatibility with getSlotsNext\n    // it should be removed once getSlotsNext is obsolete\n    if (isSlot<Props>(overrideProps)) {\n      return slotRuntime<Props>(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n    }\n    if (isSlot<Props>(type)) {\n      return slotRuntime(type, overrideProps, key, source, self);\n    }\n    return runtime(type, overrideProps, key);\n  };\n"],"names":["isSlot","React","createCompatSlotComponent","createJSX","runtime","slotRuntime","type","overrideProps","key","source","self"],"mappings":"AAAA,SAASA,MAAM,QAAQ,4BAA4B;AACnD,YAAYC,WAAW,QAAQ;AAC/B,SAASC,yBAAyB,QAAQ,qCAAqC;AAG/E,OAAO,MAAMC,YACX,CAACC,SAAqBC,cACtB,CACEC,MACAC,eACAC,KACAC,QACAC;QAEA,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIV,OAAcO,gBAAgB;YAChC,OAAOF,YAAmBH,0BAA0BI,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC/F;QACA,IAAIV,OAAcM,OAAO;YACvB,OAAOD,YAAYC,MAAMC,eAAeC,KAAKC,QAAQC;QACvD;QACA,OAAON,QAAQE,MAAMC,eAAeC;IACtC,EAAE"}

package/lib/jsx/jsxDEVSlot.js

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';
+import { DevRuntime } from '../utils/DevRuntime';
+export const jsxDEVSlot = (type, overrideProps, key, source, self)=>{
+    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        // if runtime is static
+        if (source === true) {
+            return DevRuntime.jsxDEV(React.Fragment, {
+                children: renderFunction(elementType, {
+                    ...props,
+                    /**
+             * If the runtime is static then children is an array and this array won't be keyed.
+             * Then we should wrap children by a static fragment
+             * as there's no way to know if renderFunction will render statically or dynamically
+             */ children: DevRuntime.jsxDEV(React.Fragment, {
+                        children: props.children
+                    }, undefined, true, self)
+                })
+            }, key, false, self);
+        }
+        // if runtime is dynamic (source = false) things are simpler
+        return DevRuntime.jsxDEV(React.Fragment, {
+            children: renderFunction(elementType, props)
+        }, key, source, self);
+    }
+    return DevRuntime.jsxDEV(elementType, props, key, source, self);
+};

package/lib/jsx/jsxDEVSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxDEVSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\n\nexport const jsxDEVSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    // if runtime is static\n    if (source === true) {\n      return DevRuntime.jsxDEV(\n        React.Fragment,\n        {\n          children: renderFunction(elementType, {\n            ...props,\n            /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */\n            children: DevRuntime.jsxDEV(React.Fragment, { children: props.children }, undefined, true, self),\n          }),\n        },\n        key,\n        false, // by marking source as false we're declaring that this render is dynamic\n        self,\n      ) as React.ReactElement<Props>;\n    }\n    // if runtime is dynamic (source = false) things are simpler\n    return DevRuntime.jsxDEV(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n      source,\n      self,\n    ) as React.ReactElement<Props>;\n  }\n  return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["React","getMetadataFromSlotComponent","DevRuntime","jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","jsxDEV","Fragment","children","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,UAAU,QAAQ,sBAAsB;AAEjD,OAAO,MAAMC,aAAa,CACxBC,MACAC,eACAC,KACAC,QACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGX,6BAA6BG;IAEvF,MAAMO,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGP,aAAa;IAAC;IAEtD,IAAIK,gBAAgB;QAClB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACnB,OAAOL,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;gBACEC,UAAUL,eAAeD,aAAa;oBACpC,GAAGE,KAAK;oBACR;;;;aAIC,GACDI,UAAUb,WAAWW,MAAM,CAACb,MAAMc,QAAQ,EAAE;wBAAEC,UAAUJ,MAAMI,QAAQ;oBAAC,GAAGC,WAAW,MAAMR;gBAC7F;YACF,GACAF,KACA,OACAE;QAEJ;QACA,4DAA4D;QAC5D,OAAON,WAAWW,MAAM,CACtBb,MAAMc,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CL,KACAC,QACAC;IAEJ;IACA,OAAON,WAAWW,MAAM,CAACJ,aAAaE,OAAOL,KAAKC,QAAQC;AAC5D,EAAE"}

package/lib/jsx/jsxSlot.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';
+import { Runtime } from '../utils/Runtime';
+export const jsxSlot = (type, overrideProps, key)=>{
+    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        return Runtime.jsx(React.Fragment, {
+            children: renderFunction(elementType, props)
+        }, key);
+    }
+    return Runtime.jsx(elementType, props, key);
+};

package/lib/jsx/jsxSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    return Runtime.jsx(\n      React.Fragment,\n      { children: renderFunction(elementType, props) },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsx(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,UAAU,CACrBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YAAEC,UAAUL,eAAeD,aAAaE;QAAO,GAC/CH;IAEJ;IACA,OAAOJ,QAAQS,GAAG,CAACJ,aAAaE,OAAOH;AACzC,EAAE"}

package/lib/jsx/jsxsSlot.js

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';
+import { Runtime } from '../utils/Runtime';
+export const jsxsSlot = (type, overrideProps, key)=>{
+    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        /**
+     * In static runtime then children is an array and this array won't be keyed.
+     * We should wrap children by a static fragment
+     * as there's no way to know if renderFunction will render statically or dynamically
+     */ return Runtime.jsx(React.Fragment, {
+            children: renderFunction(elementType, {
+                ...props,
+                children: Runtime.jsxs(React.Fragment, {
+                    children: props.children
+                }, undefined)
+            })
+        }, key);
+    }
+    return Runtime.jsxs(elementType, props, key);
+};

package/lib/jsx/jsxsSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxsSlot.ts"],"sourcesContent":["import * as React from 'react';\nimport { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\n\nexport const jsxsSlot = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n): React.ReactElement<Props> => {\n  const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n\n  const props: Props = { ...slotProps, ...overrideProps };\n\n  if (renderFunction) {\n    /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */\n    return Runtime.jsx(\n      React.Fragment,\n      {\n        children: renderFunction(elementType, {\n          ...props,\n          children: Runtime.jsxs(React.Fragment, { children: props.children }, undefined),\n        }),\n      },\n      key,\n    ) as React.ReactElement<Props>;\n  }\n  return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["React","getMetadataFromSlotComponent","Runtime","jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","jsx","Fragment","children","jsxs","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,4BAA4B,QAAQ,wCAAwC;AACrF,SAASC,OAAO,QAAQ,mBAAmB;AAE3C,OAAO,MAAMC,WAAW,CACtBC,MACAC,eACAC;IAEA,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGT,6BAA6BG;IAEvF,MAAMK,QAAe;QAAE,GAAGC,SAAS;QAAE,GAAGL,aAAa;IAAC;IAEtD,IAAIG,gBAAgB;QAClB;;;;KAIC,GACD,OAAON,QAAQS,GAAG,CAChBX,MAAMY,QAAQ,EACd;YACEC,UAAUL,eAAeD,aAAa;gBACpC,GAAGE,KAAK;gBACRI,UAAUX,QAAQY,IAAI,CAACd,MAAMY,QAAQ,EAAE;oBAAEC,UAAUJ,MAAMI,QAAQ;gBAAC,GAAGE;YACvE;QACF,GACAT;IAEJ;IACA,OAAOJ,QAAQY,IAAI,CAACP,aAAaE,OAAOH;AAC1C,EAAE"}

package/lib/jsx-dev-runtime.js

@@ -1,4 +1,5 @@
-import { DevRuntime } from './utils/DevRuntime';
 import { createJSX } from './jsx/createJSX';
+import { jsxDEVSlot } from './jsx/jsxDEVSlot';
+import { DevRuntime } from './utils/DevRuntime';
 export { Fragment } from 'react';
-export const jsxDEV = createJSX(DevRuntime.jsxDEV);
+export const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);

package/lib/jsx-dev-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-dev-runtime.ts"],"sourcesContent":["import { DevRuntime } from './utils/DevRuntime';\nimport { createJSX } from './jsx/createJSX';\n\nexport { Fragment } from 'react';\n\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV);\n"],"names":["DevRuntime","createJSX","Fragment","jsxDEV"],"mappings":"AAAA,SAASA,UAAU,QAAQ,qBAAqB;AAChD,SAASC,SAAS,QAAQ,kBAAkB;AAE5C,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,SAASF,UAAUD,WAAWG,MAAM,EAAE"}
+{"version":3,"sources":["jsx-dev-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\n\nexport { Fragment } from 'react';\n\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["createJSX","jsxDEVSlot","DevRuntime","Fragment","jsxDEV"],"mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,UAAU,QAAQ,mBAAmB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,SAASJ,UAAUE,WAAWE,MAAM,EAAEH,YAAY"}

package/lib/jsx-runtime.js

@@ -1,5 +1,7 @@
-import { Runtime } from './utils/Runtime';
 import { createJSX } from './jsx/createJSX';
+import { jsxSlot } from './jsx/jsxSlot';
+import { jsxsSlot } from './jsx/jsxsSlot';
+import { Runtime } from './utils/Runtime';
 export { Fragment } from 'react';
-export const jsx = createJSX(Runtime.jsx);
-export const jsxs = createJSX(Runtime.jsxs);
+export const jsx = createJSX(Runtime.jsx, jsxSlot);
+export const jsxs = createJSX(Runtime.jsxs, jsxsSlot);

package/lib/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-runtime.ts"],"sourcesContent":["import { Runtime } from './utils/Runtime';\nimport { createJSX } from './jsx/createJSX';\n\nexport { Fragment } from 'react';\n\nexport const jsx = createJSX(Runtime.jsx);\nexport const jsxs = createJSX(Runtime.jsxs);\n"],"names":["Runtime","createJSX","Fragment","jsx","jsxs"],"mappings":"AAAA,SAASA,OAAO,QAAQ,kBAAkB;AAC1C,SAASC,SAAS,QAAQ,kBAAkB;AAE5C,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,MAAMF,UAAUD,QAAQG,GAAG,EAAE;AAC1C,OAAO,MAAMC,OAAOH,UAAUD,QAAQI,IAAI,EAAE"}
+{"version":3,"sources":["jsx-runtime.ts"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\n\nexport { Fragment } from 'react';\n\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["createJSX","jsxSlot","jsxsSlot","Runtime","Fragment","jsx","jsxs"],"mappings":"AAAA,SAASA,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,OAAO,QAAQ,gBAAgB;AACxC,SAASC,QAAQ,QAAQ,iBAAiB;AAC1C,SAASC,OAAO,QAAQ,kBAAkB;AAE1C,SAASC,QAAQ,QAAQ,QAAQ;AAEjC,OAAO,MAAMC,MAAML,UAAUG,QAAQE,GAAG,EAAEJ,SAAS;AACnD,OAAO,MAAMK,OAAON,UAAUG,QAAQG,IAAI,EAAEJ,UAAU"}

package/lib/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["import type * as React from 'react';\n\nexport type JSXRuntime = <P extends {}>(\n  type: React.ElementType<P>,\n  props: P | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<P>;\n"],"names":[],"mappings":"AAAA,WAQ2B"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { SlotComponentType, UnknownSlotProps } from '@fluentui/react-utilities';\n\nexport type JSXRuntime = <P extends {}>(\n  type: React.ElementType<P>,\n  props: P | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<P>;\n\nexport type JSXSlotRuntime = <Props extends UnknownSlotProps>(\n  type: SlotComponentType<Props>,\n  overrideProps: Props | null,\n  key?: React.Key,\n  source?: unknown,\n  self?: unknown,\n) => React.ReactElement<Props>;\n"],"names":[],"mappings":"AAAA,WAiB+B"}

package/lib-commonjs/jsx/createJSX.js

@@ -9,34 +9,18 @@ Object.defineProperty(exports, "createJSX", {
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _reactutilities = require("@fluentui/react-utilities");
-const _getMetadataFromSlotComponent = require("../utils/getMetadataFromSlotComponent");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _createCompatSlotComponent = require("../utils/createCompatSlotComponent");
-const createJSX = (runtime)=>{
-    const jsxFromSlotComponent = (type, overrideProps, key, source, self)=>{
-        const { elementType, renderFunction, props: slotProps } = (0, _getMetadataFromSlotComponent.getMetadataFromSlotComponent)(type);
-        const props = {
-            ...slotProps,
-            ...overrideProps
-        };
-        if (renderFunction) {
-            return runtime(_react.Fragment, {
-                children: renderFunction(elementType, props)
-            }, key, source, self);
-        }
-        return runtime(elementType, props, key, source, self);
-    };
-    return (type, overrideProps, key, source, self)=>{
+const createJSX = (runtime, slotRuntime)=>(type, overrideProps, key, source, self)=>{
         // TODO:
         // this is for backwards compatibility with getSlotsNext
         // it should be removed once getSlotsNext is obsolete
         if ((0, _reactutilities.isSlot)(overrideProps)) {
-            return jsxFromSlotComponent((0, _createCompatSlotComponent.createCompatSlotComponent)(type, overrideProps), null, key, source, self);
+            return slotRuntime((0, _createCompatSlotComponent.createCompatSlotComponent)(type, overrideProps), null, key, source, self);
         }
         if ((0, _reactutilities.isSlot)(type)) {
-            return jsxFromSlotComponent(type, overrideProps, key, source, self);
+            return slotRuntime(type, overrideProps, key, source, self);
         }
-        return runtime(type, overrideProps, key, source, self);
+        return runtime(type, overrideProps, key);
     };
-};

package/lib-commonjs/jsx/createJSX.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createJSX.js"],"sourcesContent":["import * as React from 'react';\nimport { isSlot } from '@fluentui/react-utilities';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\n/**\n * @internal\n */ export const createJSX = (runtime)=>{\n    const jsxFromSlotComponent = (type, overrideProps, key, source, self)=>{\n        const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n        const props = {\n            ...slotProps,\n            ...overrideProps\n        };\n        if (renderFunction) {\n            return runtime(React.Fragment, {\n                children: renderFunction(elementType, props)\n            }, key, source, self);\n        }\n        return runtime(elementType, props, key, source, self);\n    };\n    return (type, overrideProps, key, source, self)=>{\n        // TODO:\n        // this is for backwards compatibility with getSlotsNext\n        // it should be removed once getSlotsNext is obsolete\n        if (isSlot(overrideProps)) {\n            return jsxFromSlotComponent(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n        }\n        if (isSlot(type)) {\n            return jsxFromSlotComponent(type, overrideProps, key, source, self);\n        }\n        return runtime(type, overrideProps, key, source, self);\n    };\n};\n"],"names":["createJSX","runtime","jsxFromSlotComponent","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","React","Fragment","children","isSlot","createCompatSlotComponent"],"mappings":";;;;+BAMiBA;;;eAAAA;;;;iEANM;gCACA;8CACsB;2CACH;AAG/B,MAAMA,YAAY,CAACC;IAC1B,MAAMC,uBAAuB,CAACC,MAAMC,eAAeC,KAAKC,QAAQC;QAC5D,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACT;QACvF,MAAMO,QAAQ;YACV,GAAGC,SAAS;YACZ,GAAGP,aAAa;QACpB;QACA,IAAIK,gBAAgB;YAChB,OAAOR,QAAQY,OAAMC,QAAQ,EAAE;gBAC3BC,UAAUN,eAAeD,aAAaE;YAC1C,GAAGL,KAAKC,QAAQC;QACpB;QACA,OAAON,QAAQO,aAAaE,OAAOL,KAAKC,QAAQC;IACpD;IACA,OAAO,CAACJ,MAAMC,eAAeC,KAAKC,QAAQC;QACtC,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIS,IAAAA,sBAAM,EAACZ,gBAAgB;YACvB,OAAOF,qBAAqBe,IAAAA,oDAAyB,EAACd,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QACnG;QACA,IAAIS,IAAAA,sBAAM,EAACb,OAAO;YACd,OAAOD,qBAAqBC,MAAMC,eAAeC,KAAKC,QAAQC;QAClE;QACA,OAAON,QAAQE,MAAMC,eAAeC,KAAKC,QAAQC;IACrD;AACJ"}
+{"version":3,"sources":["createJSX.js"],"sourcesContent":["import { isSlot } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createCompatSlotComponent } from '../utils/createCompatSlotComponent';\nexport const createJSX = (runtime, slotRuntime)=>(type, overrideProps, key, source, self)=>{\n        // TODO:\n        // this is for backwards compatibility with getSlotsNext\n        // it should be removed once getSlotsNext is obsolete\n        if (isSlot(overrideProps)) {\n            return slotRuntime(createCompatSlotComponent(type, overrideProps), null, key, source, self);\n        }\n        if (isSlot(type)) {\n            return slotRuntime(type, overrideProps, key, source, self);\n        }\n        return runtime(type, overrideProps, key);\n    };\n"],"names":["createJSX","runtime","slotRuntime","type","overrideProps","key","source","self","isSlot","createCompatSlotComponent"],"mappings":";;;;+BAGaA;;;eAAAA;;;;gCAHU;iEACA;2CACmB;AACnC,MAAMA,YAAY,CAACC,SAASC,cAAc,CAACC,MAAMC,eAAeC,KAAKC,QAAQC;QAC5E,QAAQ;QACR,wDAAwD;QACxD,qDAAqD;QACrD,IAAIC,IAAAA,sBAAM,EAACJ,gBAAgB;YACvB,OAAOF,YAAYO,IAAAA,oDAAyB,EAACN,MAAMC,gBAAgB,MAAMC,KAAKC,QAAQC;QAC1F;QACA,IAAIC,IAAAA,sBAAM,EAACL,OAAO;YACd,OAAOD,YAAYC,MAAMC,eAAeC,KAAKC,QAAQC;QACzD;QACA,OAAON,QAAQE,MAAMC,eAAeC;IACxC"}

package/lib-commonjs/jsx/jsxDEVSlot.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "jsxDEVSlot", {
+    enumerable: true,
+    get: function() {
+        return jsxDEVSlot;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _getMetadataFromSlotComponent = require("../utils/getMetadataFromSlotComponent");
+const _DevRuntime = require("../utils/DevRuntime");
+const jsxDEVSlot = (type, overrideProps, key, source, self)=>{
+    const { elementType, renderFunction, props: slotProps } = (0, _getMetadataFromSlotComponent.getMetadataFromSlotComponent)(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        // if runtime is static
+        if (source === true) {
+            return _DevRuntime.DevRuntime.jsxDEV(_react.Fragment, {
+                children: renderFunction(elementType, {
+                    ...props,
+                    /**
+             * If the runtime is static then children is an array and this array won't be keyed.
+             * Then we should wrap children by a static fragment
+             * as there's no way to know if renderFunction will render statically or dynamically
+             */ children: _DevRuntime.DevRuntime.jsxDEV(_react.Fragment, {
+                        children: props.children
+                    }, undefined, true, self)
+                })
+            }, key, false, self);
+        }
+        // if runtime is dynamic (source = false) things are simpler
+        return _DevRuntime.DevRuntime.jsxDEV(_react.Fragment, {
+            children: renderFunction(elementType, props)
+        }, key, source, self);
+    }
+    return _DevRuntime.DevRuntime.jsxDEV(elementType, props, key, source, self);
+};

package/lib-commonjs/jsx/jsxDEVSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxDEVSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { DevRuntime } from '../utils/DevRuntime';\nexport const jsxDEVSlot = (type, overrideProps, key, source, self)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        // if runtime is static\n        if (source === true) {\n            return DevRuntime.jsxDEV(React.Fragment, {\n                children: renderFunction(elementType, {\n                    ...props,\n                    /**\n             * If the runtime is static then children is an array and this array won't be keyed.\n             * Then we should wrap children by a static fragment\n             * as there's no way to know if renderFunction will render statically or dynamically\n             */ children: DevRuntime.jsxDEV(React.Fragment, {\n                        children: props.children\n                    }, undefined, true, self)\n                })\n            }, key, false, self);\n        }\n        // if runtime is dynamic (source = false) things are simpler\n        return DevRuntime.jsxDEV(React.Fragment, {\n            children: renderFunction(elementType, props)\n        }, key, source, self);\n    }\n    return DevRuntime.jsxDEV(elementType, props, key, source, self);\n};\n"],"names":["jsxDEVSlot","type","overrideProps","key","source","self","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","DevRuntime","jsxDEV","React","Fragment","children","undefined"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;4BAClB;AACpB,MAAMA,aAAa,CAACC,MAAMC,eAAeC,KAAKC,QAAQC;IACzD,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACT;IACvF,MAAMO,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGP,aAAa;IACpB;IACA,IAAIK,gBAAgB;QAChB,uBAAuB;QACvB,IAAIH,WAAW,MAAM;YACjB,OAAOO,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;gBACrCC,UAAUR,eAAeD,aAAa;oBAClC,GAAGE,KAAK;oBACR;;;;aAIP,GAAGO,UAAUJ,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;wBACpCC,UAAUP,MAAMO,QAAQ;oBAC5B,GAAGC,WAAW,MAAMX;gBACxB;YACJ,GAAGF,KAAK,OAAOE;QACnB;QACA,4DAA4D;QAC5D,OAAOM,sBAAU,CAACC,MAAM,CAACC,OAAMC,QAAQ,EAAE;YACrCC,UAAUR,eAAeD,aAAaE;QAC1C,GAAGL,KAAKC,QAAQC;IACpB;IACA,OAAOM,sBAAU,CAACC,MAAM,CAACN,aAAaE,OAAOL,KAAKC,QAAQC;AAC9D"}

package/lib-commonjs/jsx/jsxSlot.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "jsxSlot", {
+    enumerable: true,
+    get: function() {
+        return jsxSlot;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _getMetadataFromSlotComponent = require("../utils/getMetadataFromSlotComponent");
+const _Runtime = require("../utils/Runtime");
+const jsxSlot = (type, overrideProps, key)=>{
+    const { elementType, renderFunction, props: slotProps } = (0, _getMetadataFromSlotComponent.getMetadataFromSlotComponent)(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        return _Runtime.Runtime.jsx(_react.Fragment, {
+            children: renderFunction(elementType, props)
+        }, key);
+    }
+    return _Runtime.Runtime.jsx(elementType, props, key);
+};

package/lib-commonjs/jsx/jsxSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\nexport const jsxSlot = (type, overrideProps, key)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        return Runtime.jsx(React.Fragment, {\n            children: renderFunction(elementType, props)\n        }, key);\n    }\n    return Runtime.jsx(elementType, props, key);\n};\n"],"names":["jsxSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;yBACrB;AACjB,MAAMA,UAAU,CAACC,MAAMC,eAAeC;IACzC,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACP;IACvF,MAAMK,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGL,aAAa;IACpB;IACA,IAAIG,gBAAgB;QAChB,OAAOI,gBAAO,CAACC,GAAG,CAACC,OAAMC,QAAQ,EAAE;YAC/BC,UAAUR,eAAeD,aAAaE;QAC1C,GAAGH;IACP;IACA,OAAOM,gBAAO,CAACC,GAAG,CAACN,aAAaE,OAAOH;AAC3C"}

package/lib-commonjs/jsx/jsxsSlot.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "jsxsSlot", {
+    enumerable: true,
+    get: function() {
+        return jsxsSlot;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _getMetadataFromSlotComponent = require("../utils/getMetadataFromSlotComponent");
+const _Runtime = require("../utils/Runtime");
+const jsxsSlot = (type, overrideProps, key)=>{
+    const { elementType, renderFunction, props: slotProps } = (0, _getMetadataFromSlotComponent.getMetadataFromSlotComponent)(type);
+    const props = {
+        ...slotProps,
+        ...overrideProps
+    };
+    if (renderFunction) {
+        /**
+     * In static runtime then children is an array and this array won't be keyed.
+     * We should wrap children by a static fragment
+     * as there's no way to know if renderFunction will render statically or dynamically
+     */ return _Runtime.Runtime.jsx(_react.Fragment, {
+            children: renderFunction(elementType, {
+                ...props,
+                children: _Runtime.Runtime.jsxs(_react.Fragment, {
+                    children: props.children
+                }, undefined)
+            })
+        }, key);
+    }
+    return _Runtime.Runtime.jsxs(elementType, props, key);
+};

package/lib-commonjs/jsx/jsxsSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jsxsSlot.js"],"sourcesContent":["import * as React from 'react';\nimport { getMetadataFromSlotComponent } from '../utils/getMetadataFromSlotComponent';\nimport { Runtime } from '../utils/Runtime';\nexport const jsxsSlot = (type, overrideProps, key)=>{\n    const { elementType, renderFunction, props: slotProps } = getMetadataFromSlotComponent(type);\n    const props = {\n        ...slotProps,\n        ...overrideProps\n    };\n    if (renderFunction) {\n        /**\n     * In static runtime then children is an array and this array won't be keyed.\n     * We should wrap children by a static fragment\n     * as there's no way to know if renderFunction will render statically or dynamically\n     */ return Runtime.jsx(React.Fragment, {\n            children: renderFunction(elementType, {\n                ...props,\n                children: Runtime.jsxs(React.Fragment, {\n                    children: props.children\n                }, undefined)\n            })\n        }, key);\n    }\n    return Runtime.jsxs(elementType, props, key);\n};\n"],"names":["jsxsSlot","type","overrideProps","key","elementType","renderFunction","props","slotProps","getMetadataFromSlotComponent","Runtime","jsx","React","Fragment","children","jsxs","undefined"],"mappings":";;;;+BAGaA;;;eAAAA;;;;iEAHU;8CACsB;yBACrB;AACjB,MAAMA,WAAW,CAACC,MAAMC,eAAeC;IAC1C,MAAM,EAAEC,WAAW,EAAEC,cAAc,EAAEC,OAAOC,SAAS,EAAE,GAAGC,IAAAA,0DAA4B,EAACP;IACvF,MAAMK,QAAQ;QACV,GAAGC,SAAS;QACZ,GAAGL,aAAa;IACpB;IACA,IAAIG,gBAAgB;QAChB;;;;KAIH,GAAG,OAAOI,gBAAO,CAACC,GAAG,CAACC,OAAMC,QAAQ,EAAE;YAC/BC,UAAUR,eAAeD,aAAa;gBAClC,GAAGE,KAAK;gBACRO,UAAUJ,gBAAO,CAACK,IAAI,CAACH,OAAMC,QAAQ,EAAE;oBACnCC,UAAUP,MAAMO,QAAQ;gBAC5B,GAAGE;YACP;QACJ,GAAGZ;IACP;IACA,OAAOM,gBAAO,CAACK,IAAI,CAACV,aAAaE,OAAOH;AAC5C"}

package/lib-commonjs/jsx-dev-runtime.js

@@ -16,7 +16,8 @@ _export(exports, {
         return jsxDEV;
     }
 });
-const _DevRuntime = require("./utils/DevRuntime");
 const _createJSX = require("./jsx/createJSX");
+const _jsxDEVSlot = require("./jsx/jsxDEVSlot");
+const _DevRuntime = require("./utils/DevRuntime");
 const _react = require("react");
-const jsxDEV = (0, _createJSX.createJSX)(_DevRuntime.DevRuntime.jsxDEV);
+const jsxDEV = (0, _createJSX.createJSX)(_DevRuntime.DevRuntime.jsxDEV, _jsxDEVSlot.jsxDEVSlot);

package/lib-commonjs/jsx-dev-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-dev-runtime.js"],"sourcesContent":["import { DevRuntime } from './utils/DevRuntime';\nimport { createJSX } from './jsx/createJSX';\nexport { Fragment } from 'react';\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV);\n"],"names":["Fragment","jsxDEV","createJSX","DevRuntime"],"mappings":";;;;;;;;;;;IAESA,QAAQ;eAARA,eAAQ;;IACJC,MAAM;eAANA;;;4BAHc;2BACD;uBACD;AAClB,MAAMA,SAASC,IAAAA,oBAAS,EAACC,sBAAU,CAACF,MAAM"}
+{"version":3,"sources":["jsx-dev-runtime.js"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxDEVSlot } from './jsx/jsxDEVSlot';\nimport { DevRuntime } from './utils/DevRuntime';\nexport { Fragment } from 'react';\nexport const jsxDEV = createJSX(DevRuntime.jsxDEV, jsxDEVSlot);\n"],"names":["Fragment","jsxDEV","createJSX","DevRuntime","jsxDEVSlot"],"mappings":";;;;;;;;;;;IAGSA,QAAQ;eAARA,eAAQ;;IACJC,MAAM;eAANA;;;2BAJa;4BACC;4BACA;uBACF;AAClB,MAAMA,SAASC,IAAAA,oBAAS,EAACC,sBAAU,CAACF,MAAM,EAAEG,sBAAU"}

package/lib-commonjs/jsx-runtime.js

@@ -19,8 +19,10 @@ _export(exports, {
         return jsxs;
     }
 });
-const _Runtime = require("./utils/Runtime");
 const _createJSX = require("./jsx/createJSX");
+const _jsxSlot = require("./jsx/jsxSlot");
+const _jsxsSlot = require("./jsx/jsxsSlot");
+const _Runtime = require("./utils/Runtime");
 const _react = require("react");
-const jsx = (0, _createJSX.createJSX)(_Runtime.Runtime.jsx);
-const jsxs = (0, _createJSX.createJSX)(_Runtime.Runtime.jsxs);
+const jsx = (0, _createJSX.createJSX)(_Runtime.Runtime.jsx, _jsxSlot.jsxSlot);
+const jsxs = (0, _createJSX.createJSX)(_Runtime.Runtime.jsxs, _jsxsSlot.jsxsSlot);

package/lib-commonjs/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jsx-runtime.js"],"sourcesContent":["import { Runtime } from './utils/Runtime';\nimport { createJSX } from './jsx/createJSX';\nexport { Fragment } from 'react';\nexport const jsx = createJSX(Runtime.jsx);\nexport const jsxs = createJSX(Runtime.jsxs);\n"],"names":["Fragment","jsx","jsxs","createJSX","Runtime"],"mappings":";;;;;;;;;;;IAESA,QAAQ;eAARA,eAAQ;;IACJC,GAAG;eAAHA;;IACAC,IAAI;eAAJA;;;yBAJW;2BACE;uBACD;AAClB,MAAMD,MAAME,IAAAA,oBAAS,EAACC,gBAAO,CAACH,GAAG;AACjC,MAAMC,OAAOC,IAAAA,oBAAS,EAACC,gBAAO,CAACF,IAAI"}
+{"version":3,"sources":["jsx-runtime.js"],"sourcesContent":["import { createJSX } from './jsx/createJSX';\nimport { jsxSlot } from './jsx/jsxSlot';\nimport { jsxsSlot } from './jsx/jsxsSlot';\nimport { Runtime } from './utils/Runtime';\nexport { Fragment } from 'react';\nexport const jsx = createJSX(Runtime.jsx, jsxSlot);\nexport const jsxs = createJSX(Runtime.jsxs, jsxsSlot);\n"],"names":["Fragment","jsx","jsxs","createJSX","Runtime","jsxSlot","jsxsSlot"],"mappings":";;;;;;;;;;;IAISA,QAAQ;eAARA,eAAQ;;IACJC,GAAG;eAAHA;;IACAC,IAAI;eAAJA;;;2BANa;yBACF;0BACC;yBACD;uBACC;AAClB,MAAMD,MAAME,IAAAA,oBAAS,EAACC,gBAAO,CAACH,GAAG,EAAEI,gBAAO;AAC1C,MAAMH,OAAOC,IAAAA,oBAAS,EAACC,gBAAO,CAACF,IAAI,EAAEI,kBAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-jsx-runtime",
-  "version": "9.0.8",
+  "version": "9.0.9",
   "description": "Custom JSX runtime for @fluentui/react-components",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",