@doist/reactist 28.7.2 → 28.7.3

package/lib/tooltip/tooltip.js

@@ -1,2 +1,68 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),t=require("@ariakit/react"),o=require("../box/box.js"),r=require("./tooltip.module.css.js");function i(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(o){if("default"!==o){var r=Object.getOwnPropertyDescriptor(e,o);Object.defineProperty(t,o,r.get?r:{enumerable:!0,get:function(){return e[o]}})}})),t.default=e,t}var n=i(e);const l=n.createContext({showTimeout:500,hideTimeout:100}),u=n.forwardRef(({children:e,content:i,position:u="top",gapSize:a=3,withArrow:s=!1,showTimeout:d,hideTimeout:c,exceptionallySetClassName:m},p)=>{const{showTimeout:f,hideTimeout:h}=n.useContext(l),T=t.useTooltipStore({placement:u,showTimeout:d??f,hideTimeout:c??h});n.useImperativeHandle(p,()=>T,[T]);const w=T.useState("open"),b=n.Children.only(e);if(!b)return b;if("string"==typeof b.ref)throw new Error("Tooltip: String refs cannot be used as they cannot be forwarded");return n.createElement(n.Fragment,null,n.createElement(t.TooltipAnchor,{render:b,store:T,ref:b.ref}),w&&i?n.createElement(t.Tooltip,{store:T,gutter:a,render:n.createElement(o.Box,{className:[r.default.tooltip,m],background:"toast",borderRadius:"standard",paddingX:"small",paddingY:"xsmall",maxWidth:"medium",width:"fitContent",overflow:"hidden",textAlign:"center"})},s?n.createElement(t.TooltipArrow,null):null,"function"==typeof i?i():i):null)});u.displayName="Tooltip",exports.Tooltip=u,exports.TooltipProvider=function({showTimeout:e=500,hideTimeout:t=100,children:o}){const r=n.useMemo(()=>({showTimeout:e,hideTimeout:t}),[e,t]);return n.createElement(l.Provider,{value:r},o)};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var react = require('@ariakit/react');
+var box = require('../box/box.js');
+var tooltip_module = require('./tooltip.module.css.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var defaultShowTimeout = 500;
+var defaultHideTimeout = 100;
+var TooltipContext = React__namespace.createContext({
+    showTimeout: defaultShowTimeout,
+    hideTimeout: defaultHideTimeout
+});
+function TooltipProvider(_a) {
+    var _b = _a.showTimeout, showTimeout = _b === void 0 ? defaultShowTimeout : _b, _c = _a.hideTimeout, hideTimeout = _c === void 0 ? defaultHideTimeout : _c, children = _a.children;
+    var value = React__namespace.useMemo(function () { return ({ showTimeout: showTimeout, hideTimeout: hideTimeout }); }, [showTimeout, hideTimeout]);
+    return React__namespace.createElement(TooltipContext.Provider, { value: value }, children);
+}
+var Tooltip = React__namespace.forwardRef(function (_a, ref) {
+    var children = _a.children, content = _a.content, _b = _a.position, position = _b === void 0 ? 'top' : _b, _c = _a.gapSize, gapSize = _c === void 0 ? 3 : _c, _d = _a.withArrow, withArrow = _d === void 0 ? false : _d, showTimeout = _a.showTimeout, hideTimeout = _a.hideTimeout, exceptionallySetClassName = _a.exceptionallySetClassName;
+    var _e = React__namespace.useContext(TooltipContext), globalShowTimeout = _e.showTimeout, globalHideTimeout = _e.hideTimeout;
+    var tooltip = react.useTooltipStore({
+        placement: position,
+        showTimeout: showTimeout !== null && showTimeout !== void 0 ? showTimeout : globalShowTimeout,
+        hideTimeout: hideTimeout !== null && hideTimeout !== void 0 ? hideTimeout : globalHideTimeout
+    });
+    React__namespace.useImperativeHandle(ref, function () { return tooltip; }, [tooltip]);
+    var isOpen = tooltip.useState('open');
+    var child = React__namespace.Children.only(children);
+    if (!child) {
+        return child;
+    }
+    if (typeof child.ref === 'string') {
+        throw new Error('Tooltip: String refs cannot be used as they cannot be forwarded');
+    }
+    return (React__namespace.createElement(React__namespace.Fragment, null,
+        React__namespace.createElement(react.TooltipAnchor, { render: child, store: tooltip, ref: child.ref }),
+        isOpen && content ? (React__namespace.createElement(react.Tooltip, { store: tooltip, gutter: gapSize, render: React__namespace.createElement(box.Box, { className: [tooltip_module["default"].tooltip, exceptionallySetClassName], background: "toast", borderRadius: "standard", paddingX: "small", paddingY: "xsmall", maxWidth: "medium", width: "fitContent", overflow: "hidden", textAlign: "center" }) },
+            withArrow ? React__namespace.createElement(react.TooltipArrow, null) : null,
+            typeof content === 'function' ? content() : content)) : null));
+});
+Tooltip.displayName = 'Tooltip';
+
+exports.Tooltip = Tooltip;
+exports.TooltipProvider = TooltipProvider;
 //# sourceMappingURL=tooltip.js.map

package/lib/tooltip/tooltip.js.map

@@ -1 +1 @@
-{"version":3,"file":"tooltip.js","sources":["../../src/tooltip/tooltip.tsx"],"sourcesContent":["import * as React from 'react'\n\nimport {\n    useTooltipStore,\n    Tooltip as AriakitTooltip,\n    TooltipAnchor,\n    TooltipArrow,\n} from '@ariakit/react'\nimport { Box } from '../box'\n\nimport type { TooltipStoreState, TooltipStore } from '@ariakit/react'\n\nimport styles from './tooltip.module.css'\nimport type { ObfuscatedClassName } from '../utils/common-types'\n\nconst defaultShowTimeout = 500\nconst defaultHideTimeout = 100\n\ntype TooltipContextState = {\n    showTimeout: number\n    hideTimeout: number\n}\n\nconst TooltipContext = React.createContext<TooltipContextState>({\n    showTimeout: defaultShowTimeout,\n    hideTimeout: defaultHideTimeout,\n})\n\nfunction TooltipProvider({\n    showTimeout = defaultShowTimeout,\n    hideTimeout = defaultHideTimeout,\n    children,\n}: React.PropsWithChildren<{\n    showTimeout?: number\n    hideTimeout?: number\n}>) {\n    const value = React.useMemo(() => ({ showTimeout, hideTimeout }), [showTimeout, hideTimeout])\n    return <TooltipContext.Provider value={value}>{children}</TooltipContext.Provider>\n}\n\ninterface TooltipProps extends ObfuscatedClassName {\n    /**\n     * The element that triggers the tooltip. Generally a button or link.\n     *\n     * It should be an interactive element accessible both via mouse and keyboard interactions.\n     */\n    children: React.ReactNode\n\n    /**\n     * The content to show in the tooltip.\n     *\n     * It can be rich content provided via React elements, or string content. It should not include\n     * interactive elements inside it. This includes links or buttons.\n     *\n     * You can provide a function instead of the content itself. In this case, the function should\n     * return the desired content. This is useful if the content is expensive to generate. It can\n     * also be useful if the content dynamically changes often, so every time you trigger the\n     * tooltip the content may have changed (e.g. if you show a ticking time clock in the tooltip).\n     *\n     * The trigger element will be associated to this content via `aria-describedby`. This means\n     * that the tooltip content will be read by assistive technologies such as screen readers. It\n     * will likely read this content right after reading the trigger element label.\n     */\n    content: React.ReactNode | (() => React.ReactNode)\n\n    /**\n     * How to place the tooltip relative to its trigger element.\n     *\n     * The possible values are \"top\", \"bottom\", \"left\", \"right\". Additionally, any of these values\n     * can be combined with `-start` or `-end` for even more control. For instance `top-start` will\n     * place the tooltip at the top, but with the start (e.g. left) side of the toolip and the\n     * trigger aligned. If neither `-start` or `-end` are provided, the tooltip is centered along\n     * the vertical or horizontal axis with the trigger.\n     *\n     * The position is enforced whenever possible, but tooltips can appear in different positions\n     * if the specified one would make the tooltip intersect with the viewport edges.\n     *\n     * @default 'top'\n     */\n    position?: TooltipStoreState['placement']\n\n    /**\n     * The separation (in pixels) between the trigger element and the tooltip.\n     * @default 3\n     */\n    gapSize?: number\n\n    /**\n     * Whether to show an arrow-like element attached to the tooltip, and pointing towards the\n     * trigger element.\n     * @default false\n     */\n    withArrow?: boolean\n\n    /**\n     * The amount of time in milliseconds to wait before showing the tooltip\n     * Use `<TooltipContext.Provider>` to set a global value for all tooltips\n     * @default 500\n     */\n    showTimeout?: number\n\n    /**\n     * The amount of time in milliseconds to wait before hiding the tooltip\n     * Use `<TooltipContext.Provider>` to set a global value for all tooltips\n     * @default 100\n     */\n    hideTimeout?: number\n}\n\nconst Tooltip = React.forwardRef<TooltipStore, TooltipProps>(\n    (\n        {\n            children,\n            content,\n            position = 'top',\n            gapSize = 3,\n            withArrow = false,\n            showTimeout,\n            hideTimeout,\n            exceptionallySetClassName,\n        },\n        ref,\n    ) => {\n        const { showTimeout: globalShowTimeout, hideTimeout: globalHideTimeout } = React.useContext(\n            TooltipContext,\n        )\n\n        const tooltip = useTooltipStore({\n            placement: position,\n            showTimeout: showTimeout ?? globalShowTimeout,\n            hideTimeout: hideTimeout ?? globalHideTimeout,\n        })\n\n        React.useImperativeHandle(ref, () => tooltip, [tooltip])\n\n        const isOpen = tooltip.useState('open')\n\n        const child = React.Children.only(\n            children as React.FunctionComponentElement<JSX.IntrinsicElements['div']> | null,\n        )\n\n        if (!child) {\n            return child\n        }\n\n        if (typeof child.ref === 'string') {\n            throw new Error('Tooltip: String refs cannot be used as they cannot be forwarded')\n        }\n\n        return (\n            <>\n                <TooltipAnchor render={child} store={tooltip} ref={child.ref} />\n                {isOpen && content ? (\n                    <AriakitTooltip\n                        store={tooltip}\n                        gutter={gapSize}\n                        render={\n                            <Box\n                                className={[styles.tooltip, exceptionallySetClassName]}\n                                background=\"toast\"\n                                borderRadius=\"standard\"\n                                paddingX=\"small\"\n                                paddingY=\"xsmall\"\n                                maxWidth=\"medium\"\n                                width=\"fitContent\"\n                                overflow=\"hidden\"\n                                textAlign=\"center\"\n                            />\n                        }\n                    >\n                        {withArrow ? <TooltipArrow /> : null}\n                        {typeof content === 'function' ? content() : content}\n                    </AriakitTooltip>\n                ) : null}\n            </>\n        )\n    },\n)\n\nTooltip.displayName = 'Tooltip'\n\nexport type { TooltipProps }\nexport { Tooltip, TooltipProvider }\n"],"names":["TooltipContext","React","createContext","showTimeout","hideTimeout","Tooltip","forwardRef","children","content","position","gapSize","withArrow","exceptionallySetClassName","ref","globalShowTimeout","globalHideTimeout","useContext","tooltip","useTooltipStore","placement","useImperativeHandle","isOpen","useState","child","Children","only","Error","createElement","Fragment","TooltipAnchor","render","store","AriakitTooltip","gutter","Box","className","styles","background","borderRadius","paddingX","paddingY","maxWidth","width","overflow","textAlign","TooltipArrow","displayName","value","useMemo","Provider"],"mappings":"kdAeA,MAQMA,EAAiBC,EAAMC,cAAmC,CAC5DC,YATuB,IAUvBC,YATuB,MA6FrBC,EAAUJ,EAAMK,WAClB,EAEQC,SAAAA,EACAC,QAAAA,EACAC,SAAAA,EAAW,MACXC,QAAAA,EAAU,EACVC,UAAAA,GAAY,EACZR,YAAAA,EACAC,YAAAA,EACAQ,0BAAAA,GAEJC,KAEA,MAAQV,YAAaW,EAAmBV,YAAaW,GAAsBd,EAAMe,WAC7EhB,GAGEiB,EAAUC,EAAAA,gBAAgB,CAC5BC,UAAWV,EACXN,YAAaA,GAAeW,EAC5BV,YAAaA,GAAeW,IAGhCd,EAAMmB,oBAAoBP,EAAK,IAAMI,EAAS,CAACA,IAE/C,MAAMI,EAASJ,EAAQK,SAAS,QAE1BC,EAAQtB,EAAMuB,SAASC,KACzBlB,GAGJ,IAAKgB,EACD,OAAOA,EAGX,GAAyB,iBAAdA,EAAMV,IACb,MAAM,IAAIa,MAAM,mEAGpB,OACIzB,EAAA0B,cAAA1B,EAAA2B,SAAA,KACI3B,EAAA0B,cAACE,gBAAa,CAACC,OAAQP,EAAOQ,MAAOd,EAASJ,IAAKU,EAAMV,MACxDQ,GAAUb,EACPP,EAAC0B,cAAAK,EAAAA,QACG,CAAAD,MAAOd,EACPgB,OAAQvB,EACRoB,OACI7B,EAAA0B,cAACO,MAAG,CACAC,UAAW,CAACC,EAAAA,QAAOnB,QAASL,GAC5ByB,WAAW,QACXC,aAAa,WACbC,SAAS,QACTC,SAAS,SACTC,SAAS,SACTC,MAAM,aACNC,SAAS,SACTC,UAAU,YAIjBjC,EAAYV,EAAA0B,cAACkB,EAADA,aAAgB,MAAG,KACZ,mBAAZrC,EAAyBA,IAAYA,GAEjD,QAMpBH,EAAQyC,YAAc,oDAvJtB,UAAyB3C,YACrBA,EAduB,IAaFC,YAErBA,EAduB,IAYFG,SAGrBA,IAKA,MAAMwC,EAAQ9C,EAAM+C,QAAQ,KAAO,CAAE7C,YAAAA,EAAaC,YAAAA,IAAgB,CAACD,EAAaC,IAChF,OAAOH,EAAA0B,cAAC3B,EAAeiD,SAAQ,CAACF,MAAOA,GAAQxC"}
+{"version":3,"file":"tooltip.js","sources":["../../src/tooltip/tooltip.tsx"],"sourcesContent":[null],"names":["React","useTooltipStore","TooltipAnchor","AriakitTooltip","Box","styles","TooltipArrow"],"mappings":"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"}

package/lib/tooltip/tooltip.module.css.js

@@ -1,2 +1,8 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.default={tooltip:"_487c82cd"};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var modules_95f1407a = {"tooltip":"_487c82cd"};
+
+exports["default"] = modules_95f1407a;
 //# sourceMappingURL=tooltip.module.css.js.map

package/lib/tooltip/tooltip.module.css.js.map

@@ -1 +1 @@
-{"version":3,"file":"tooltip.module.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"tooltip.module.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/lib/utils/common-helpers.d.ts

@@ -1,2 +1,2 @@
-export declare function generateElementId(prefix: string): string;
-export declare function useId(providedId?: string): string;
+export declare function generateElementId(prefix: string): string;
+export declare function useId(providedId?: string): string;

package/lib/utils/common-helpers.js

@@ -1,2 +1,45 @@
-"use strict";function e(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,t}Object.defineProperty(exports,"__esModule",{value:!0});var t=e(require("react"));let r=0;function n(e){return`${e}-${r++}`}exports.generateElementId=n,exports.useId=function(e){const r=t.useRef(e??null);return r.current||(r.current=n("element")),r.current};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var uid = 0;
+function uniqueId() {
+    return uid++;
+}
+function generateElementId(prefix) {
+    var num = uniqueId();
+    return "".concat(prefix, "-").concat(num);
+}
+function useId(providedId) {
+    var ref = React__namespace.useRef(providedId !== null && providedId !== void 0 ? providedId : null);
+    if (!ref.current) {
+        ref.current = generateElementId('element');
+    }
+    return ref.current;
+}
+
+exports.generateElementId = generateElementId;
+exports.useId = useId;
 //# sourceMappingURL=common-helpers.js.map

package/lib/utils/common-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"common-helpers.js","sources":["../../src/utils/common-helpers.ts"],"sourcesContent":["import * as React from 'react'\n\nlet uid = 0\nfunction uniqueId() {\n    return uid++\n}\n\nexport function generateElementId(prefix: string): string {\n    const num = uniqueId()\n    return `${prefix}-${num}`\n}\n\nexport function useId(providedId?: string): string {\n    const ref = React.useRef<string | null>(providedId ?? null)\n    if (!ref.current) {\n        ref.current = generateElementId('element')\n    }\n    return ref.current\n}\n"],"names":["uid","generateElementId","prefix","providedId","ref","React","useRef","current"],"mappings":"8WAEA,IAAIA,EAAM,EAKJ,SAAUC,EAAkBC,GAE9B,MAAU,GAAAA,KALHF,gDAQL,SAAgBG,GAClB,MAAMC,EAAMC,EAAMC,OAAsBH,GAAc,MAItD,OAHKC,EAAIG,UACLH,EAAIG,QAAUN,EAAkB,YAE7BG,EAAIG"}
+{"version":3,"file":"common-helpers.js","sources":["../../src/utils/common-helpers.ts"],"sourcesContent":[null],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAI,GAAG,GAAG,CAAC,CAAA;AACX,SAAS,QAAQ,GAAA;IACb,OAAO,GAAG,EAAE,CAAA;AAChB,CAAC;AAEK,SAAU,iBAAiB,CAAC,MAAc,EAAA;AAC5C,IAAA,IAAM,GAAG,GAAG,QAAQ,EAAE,CAAA;AACtB,IAAA,OAAO,EAAG,CAAA,MAAA,CAAA,MAAM,EAAI,GAAA,CAAA,CAAA,MAAA,CAAA,GAAG,CAAE,CAAA;AAC7B,CAAC;AAEK,SAAU,KAAK,CAAC,UAAmB,EAAA;AACrC,IAAA,IAAM,GAAG,GAAGA,gBAAK,CAAC,MAAM,CAAgB,UAAU,KAAV,IAAA,IAAA,UAAU,KAAV,KAAA,CAAA,GAAA,UAAU,GAAI,IAAI,CAAC,CAAA;AAC3D,IAAA,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE;AACd,QAAA,GAAG,CAAC,OAAO,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAA;AAC7C,KAAA;IACD,OAAO,GAAG,CAAC,OAAO,CAAA;AACtB;;;;;"}

package/lib/utils/common-types.d.ts

@@ -1,42 +1,42 @@
-import type classNames from 'classnames';
-import type { HTMLAttributes } from 'react';
-export type Space = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';
-export type SpaceWithNegatives = Space | '-xsmall' | '-small' | '-medium' | '-large' | '-xlarge' | '-xxlarge';
-export type Tone = 'normal' | 'secondary' | 'danger' | 'positive';
-export type AlertTone = 'info' | 'positive' | 'caution' | 'critical';
-export type DividerWeight = 'primary' | 'secondary' | 'tertiary' | 'none';
-type ClassValue = Parameters<typeof classNames>[number];
-export type WithEnhancedClassName<T = unknown> = T extends HTMLElement ? Omit<HTMLAttributes<T>, 'className'> & {
-    className?: ClassValue;
-} : T extends {
-    className?: unknown;
-} ? Omit<T, 'className'> & {
-    className?: ClassValue;
-} : T & {
-    className?: ClassValue;
-};
-export interface OpenInNewTab {
-    openInNewTab?: boolean;
-    target?: never;
-    rel?: never;
-}
-export type ObfuscatedClassName = {
-    /**
-     * Used internally to set the `className` prop of the main container element for this component.
-     *
-     * Aside from the different name, the prop behaves the same as the native `className`. The only
-     * reason for the name change is to discourage applying custom CSS to the design system
-     * components, which are supposed to _eventually_ provide all the styling features we may need.
-     *
-     * This prop is meant to be used only in certain circumstances, when you really need a escape
-     * hatch to apply custom styles to a component. Before reaching for this feature, try harder to
-     * see if you can solve your needs with what the design system provides.
-     *
-     * For instance, instead of applying layout-related styles to a non-layout component, consider
-     * wrapping it inside a layout component.
-     *
-     * @see PolymorphicComponent
-     */
-    exceptionallySetClassName?: string;
-};
-export {};
+import type classNames from 'classnames';
+import type { HTMLAttributes } from 'react';
+export type Space = 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'xxlarge';
+export type SpaceWithNegatives = Space | '-xsmall' | '-small' | '-medium' | '-large' | '-xlarge' | '-xxlarge';
+export type Tone = 'normal' | 'secondary' | 'danger' | 'positive';
+export type AlertTone = 'info' | 'positive' | 'caution' | 'critical';
+export type DividerWeight = 'primary' | 'secondary' | 'tertiary' | 'none';
+type ClassValue = Parameters<typeof classNames>[number];
+export type WithEnhancedClassName<T = unknown> = T extends HTMLElement ? Omit<HTMLAttributes<T>, 'className'> & {
+    className?: ClassValue;
+} : T extends {
+    className?: unknown;
+} ? Omit<T, 'className'> & {
+    className?: ClassValue;
+} : T & {
+    className?: ClassValue;
+};
+export interface OpenInNewTab {
+    openInNewTab?: boolean;
+    target?: never;
+    rel?: never;
+}
+export type ObfuscatedClassName = {
+    /**
+     * Used internally to set the `className` prop of the main container element for this component.
+     *
+     * Aside from the different name, the prop behaves the same as the native `className`. The only
+     * reason for the name change is to discourage applying custom CSS to the design system
+     * components, which are supposed to _eventually_ provide all the styling features we may need.
+     *
+     * This prop is meant to be used only in certain circumstances, when you really need a escape
+     * hatch to apply custom styles to a component. Before reaching for this feature, try harder to
+     * see if you can solve your needs with what the design system provides.
+     *
+     * For instance, instead of applying layout-related styles to a non-layout component, consider
+     * wrapping it inside a layout component.
+     *
+     * @see PolymorphicComponent
+     */
+    exceptionallySetClassName?: string;
+};
+export {};

package/lib/utils/polymorphism.d.ts

@@ -1,135 +1,135 @@
-import * as React from 'react';
-import type { ObfuscatedClassName } from './common-types';
-type Merge<P1, P2> = Omit<P1, keyof P2> & P2;
-type EmptyObject = {
-    [K in any]: never;
-};
-type ObfuscateClassNameMode = 'keepClassName' | 'obfuscateClassName' | 'omitClassName';
-/**
- * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`
- * prop instead.
- *
- * This can be customized via the second generic parameter, as there are cases where it may be
- * needed to omit this behaviour and keep the `className`. You can also instruct it to remove the
- * `className` prop while not replacing it with the `exceptionallySetClassName` one.
- *
- * @see ObfuscatedClassName['exceptionallySetClassName'] for details about this prop
- * @see PolymorphicComponent for details about this feature
- */
-type WithObfuscatedClassName<Props, ShouldObfuscateClassName extends ObfuscateClassNameMode> = 'className' extends keyof Props ? ShouldObfuscateClassName extends 'obfuscateClassName' ? Omit<Props, 'className'> & ObfuscatedClassName : ShouldObfuscateClassName extends 'omitClassName' ? Omit<Props, 'className'> : ShouldObfuscateClassName extends 'keepClassName' ? Props : never : Props;
-type PolymorphicProp<ComponentType extends React.ElementType> = {
-    /**
-     * Used to instruct this component what React element to render as. It can be both a string
-     * representing a HTML tag name, or a React component.
-     *
-     * When using this prop, the component you apply it to will also recognize in its props types
-     * all the props from the component or HTML element you are rendering it as.
-     *
-     * Some uses for this feature:
-     *
-     * - Using some of our layout components, while at the same time being able to set them to use
-     *   semantic HTML elements needed for accessibility purposes (e.g. `nav`, `main`, etc).
-     * - Using a design system link component, but have it internally use a client-side router link
-     *   implemented via a React component (e.g. react-router's `Link`).
-     *
-     * Keep in mind that not all compositions of this kind may work well, especially when composing
-     * with another React component and not with a HTML tag name. In particular, if the components
-     * being composed have opposing concerns of clashing features (e.g. they have contradicting
-     * styles applied to them) things may not go well. In those cases prefer to nest them instead.
-     *
-     * @see PolymorphicComponent
-     */
-    as?: ComponentType;
-};
-/**
- * Given a component or element type, and a set of additional props, this builds the entire set of
- * props for a polymorphic component.
- *
- * It does three things:
- *
- * 1. it merges the element type props with the `OwnProps`
- * 2. it adds the `as` prop to allow for polymorphism to happen
- * 3. it optionally obfuscates or omits the className prop if present
- *
- * @see PolymorphicProp
- * @see WithObfuscatedClassName
- */
-type PolymorphicComponentProps<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode> = Merge<WithObfuscatedClassName<React.ComponentProps<ComponentType>, ShouldObfuscateClassName>, OwnProps & PolymorphicProp<ComponentType>>;
-type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
-type ElementByTag<TagName extends keyof ElementTagNameMap> = ElementTagNameMap[TagName];
-type ElementByTagOrAny<ComponentType extends React.ElementType> = ComponentType extends keyof ElementTagNameMap ? ElementByTag<ComponentType> : any;
-/**
- * The function passed to React.forwardRef, but typed in a way that's prepared for polymorphism via
- * the `as` prop. It also allows to specify if the `className` prop should be obfuscated or omitted.
- *
- * @see PolymorphicComponentProps
- * @see WithObfuscatedClassName
- */
-interface ForwardRefFunction<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode> {
-    (props: PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>, ref: ((instance: ElementByTagOrAny<ComponentType> | null) => void) | React.MutableRefObject<ElementByTagOrAny<ComponentType> | null> | null): React.ReactElement | null;
-    displayName?: string;
-}
-/**
- * A component that can customize the React element type that it renders (a.k.a. a polymorphic
- * component). This is achieved by passing a prop `as={ElementType}` or `as="html-tag-name"`.
- *
- * It transparently takes care of forwarding refs, and properly sets the ref type depending on the
- * element type.
- *
- * ## Recognizing props based on the polymorphic type
- *
- * The `ComponentType` argument sets the default type for the `as` prop. Whatever the `as` prop
- * component or HTML element is, the type system will automatically allow you to pass props that are
- * not explicitly defined by you, but that are recognized as valid props to be passed to the
- * component you are rendering.
- *
- * For instance, see the following example:
- *
- * ```jsx
- * <Box as="label" htmlFor="field-id">Hello</Box>
- * ```
- *
- * The `htmlFor` prop is exclusive to label elements. If you omit the `as="label"` prop, the type
- * system will consider the `htmlFor` prop to be an error. The same happens if you pass a value of
- * an incorrect type to such prop. For instance, the example below will issue a type error:
- *
- * ```jsx
- * <Box as="label" htmlFor={123}>Hello</Box>
- * ```
- *
- * ## Omitting or obfuscating the `className` prop
- *
- * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`
- * prop instead.
- *
- * This is to discourage customizing design system components via custom styling, while still
- * leaving the door open to do it as an escape hatch when the design system still has shortcomings
- * with respect to the product designs we want to achieve.
- *
- * The cumbersome name also serves the purpose of aiding in easily searching for the places in the
- * code where this escape hatch was needed, in order to identify areas where the design system
- * components need to improve to better match our needs.
- *
- * This behaviour can be customized via an optional second generic argument that allows to disable
- * this feature, or to omit the `className` altogether without replacing it with the obfuscated prop
- * name.
- *
- * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)
- */
-interface PolymorphicComponent<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'> {
-    <TT extends React.ElementType = ComponentType>(props: PolymorphicComponentProps<TT, OwnProps, ShouldObfuscateClassName>): React.ReactElement | null;
-    readonly $$typeof: symbol;
-    defaultProps?: Partial<PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>>;
-    propTypes?: React.WeakValidationMap<PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>>;
-    displayName?: string;
-}
-/**
- * A wrapper to use React.forwardRef with polymorphic components in a type-safe manner. This is a
- * convenience over merely using React.forwardRef directly, and then manually forcing the resulting
- * value to be typed using `as PolymorphicComponent<…>`.
- *
- * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)
- */
-declare function polymorphicComponent<ComponentType extends React.ElementType = 'div', OwnProps = EmptyObject, ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'>(render: ForwardRefFunction<ComponentType, OwnProps, ShouldObfuscateClassName>): PolymorphicComponent<ComponentType, OwnProps, ShouldObfuscateClassName>;
-export type { PolymorphicComponent };
-export { polymorphicComponent };
+import * as React from 'react';
+import type { ObfuscatedClassName } from './common-types';
+type Merge<P1, P2> = Omit<P1, keyof P2> & P2;
+type EmptyObject = {
+    [K in any]: never;
+};
+type ObfuscateClassNameMode = 'keepClassName' | 'obfuscateClassName' | 'omitClassName';
+/**
+ * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`
+ * prop instead.
+ *
+ * This can be customized via the second generic parameter, as there are cases where it may be
+ * needed to omit this behaviour and keep the `className`. You can also instruct it to remove the
+ * `className` prop while not replacing it with the `exceptionallySetClassName` one.
+ *
+ * @see ObfuscatedClassName['exceptionallySetClassName'] for details about this prop
+ * @see PolymorphicComponent for details about this feature
+ */
+type WithObfuscatedClassName<Props, ShouldObfuscateClassName extends ObfuscateClassNameMode> = 'className' extends keyof Props ? ShouldObfuscateClassName extends 'obfuscateClassName' ? Omit<Props, 'className'> & ObfuscatedClassName : ShouldObfuscateClassName extends 'omitClassName' ? Omit<Props, 'className'> : ShouldObfuscateClassName extends 'keepClassName' ? Props : never : Props;
+type PolymorphicProp<ComponentType extends React.ElementType> = {
+    /**
+     * Used to instruct this component what React element to render as. It can be both a string
+     * representing a HTML tag name, or a React component.
+     *
+     * When using this prop, the component you apply it to will also recognize in its props types
+     * all the props from the component or HTML element you are rendering it as.
+     *
+     * Some uses for this feature:
+     *
+     * - Using some of our layout components, while at the same time being able to set them to use
+     *   semantic HTML elements needed for accessibility purposes (e.g. `nav`, `main`, etc).
+     * - Using a design system link component, but have it internally use a client-side router link
+     *   implemented via a React component (e.g. react-router's `Link`).
+     *
+     * Keep in mind that not all compositions of this kind may work well, especially when composing
+     * with another React component and not with a HTML tag name. In particular, if the components
+     * being composed have opposing concerns of clashing features (e.g. they have contradicting
+     * styles applied to them) things may not go well. In those cases prefer to nest them instead.
+     *
+     * @see PolymorphicComponent
+     */
+    as?: ComponentType;
+};
+/**
+ * Given a component or element type, and a set of additional props, this builds the entire set of
+ * props for a polymorphic component.
+ *
+ * It does three things:
+ *
+ * 1. it merges the element type props with the `OwnProps`
+ * 2. it adds the `as` prop to allow for polymorphism to happen
+ * 3. it optionally obfuscates or omits the className prop if present
+ *
+ * @see PolymorphicProp
+ * @see WithObfuscatedClassName
+ */
+type PolymorphicComponentProps<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode> = Merge<WithObfuscatedClassName<React.ComponentProps<ComponentType>, ShouldObfuscateClassName>, OwnProps & PolymorphicProp<ComponentType>>;
+type ElementTagNameMap = HTMLElementTagNameMap & Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>;
+type ElementByTag<TagName extends keyof ElementTagNameMap> = ElementTagNameMap[TagName];
+type ElementByTagOrAny<ComponentType extends React.ElementType> = ComponentType extends keyof ElementTagNameMap ? ElementByTag<ComponentType> : any;
+/**
+ * The function passed to React.forwardRef, but typed in a way that's prepared for polymorphism via
+ * the `as` prop. It also allows to specify if the `className` prop should be obfuscated or omitted.
+ *
+ * @see PolymorphicComponentProps
+ * @see WithObfuscatedClassName
+ */
+interface ForwardRefFunction<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode> {
+    (props: PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>, ref: ((instance: ElementByTagOrAny<ComponentType> | null) => void) | React.MutableRefObject<ElementByTagOrAny<ComponentType> | null> | null): React.ReactElement | null;
+    displayName?: string;
+}
+/**
+ * A component that can customize the React element type that it renders (a.k.a. a polymorphic
+ * component). This is achieved by passing a prop `as={ElementType}` or `as="html-tag-name"`.
+ *
+ * It transparently takes care of forwarding refs, and properly sets the ref type depending on the
+ * element type.
+ *
+ * ## Recognizing props based on the polymorphic type
+ *
+ * The `ComponentType` argument sets the default type for the `as` prop. Whatever the `as` prop
+ * component or HTML element is, the type system will automatically allow you to pass props that are
+ * not explicitly defined by you, but that are recognized as valid props to be passed to the
+ * component you are rendering.
+ *
+ * For instance, see the following example:
+ *
+ * ```jsx
+ * <Box as="label" htmlFor="field-id">Hello</Box>
+ * ```
+ *
+ * The `htmlFor` prop is exclusive to label elements. If you omit the `as="label"` prop, the type
+ * system will consider the `htmlFor` prop to be an error. The same happens if you pass a value of
+ * an incorrect type to such prop. For instance, the example below will issue a type error:
+ *
+ * ```jsx
+ * <Box as="label" htmlFor={123}>Hello</Box>
+ * ```
+ *
+ * ## Omitting or obfuscating the `className` prop
+ *
+ * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`
+ * prop instead.
+ *
+ * This is to discourage customizing design system components via custom styling, while still
+ * leaving the door open to do it as an escape hatch when the design system still has shortcomings
+ * with respect to the product designs we want to achieve.
+ *
+ * The cumbersome name also serves the purpose of aiding in easily searching for the places in the
+ * code where this escape hatch was needed, in order to identify areas where the design system
+ * components need to improve to better match our needs.
+ *
+ * This behaviour can be customized via an optional second generic argument that allows to disable
+ * this feature, or to omit the `className` altogether without replacing it with the obfuscated prop
+ * name.
+ *
+ * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)
+ */
+interface PolymorphicComponent<ComponentType extends React.ElementType, OwnProps, ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'> {
+    <TT extends React.ElementType = ComponentType>(props: PolymorphicComponentProps<TT, OwnProps, ShouldObfuscateClassName>): React.ReactElement | null;
+    readonly $$typeof: symbol;
+    defaultProps?: Partial<PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>>;
+    propTypes?: React.WeakValidationMap<PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>>;
+    displayName?: string;
+}
+/**
+ * A wrapper to use React.forwardRef with polymorphic components in a type-safe manner. This is a
+ * convenience over merely using React.forwardRef directly, and then manually forcing the resulting
+ * value to be typed using `as PolymorphicComponent<…>`.
+ *
+ * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)
+ */
+declare function polymorphicComponent<ComponentType extends React.ElementType = 'div', OwnProps = EmptyObject, ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'>(render: ForwardRefFunction<ComponentType, OwnProps, ShouldObfuscateClassName>): PolymorphicComponent<ComponentType, OwnProps, ShouldObfuscateClassName>;
+export type { PolymorphicComponent };
+export { polymorphicComponent };

package/lib/utils/polymorphism.js

@@ -1,2 +1,40 @@
-"use strict";function e(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,r}Object.defineProperty(exports,"__esModule",{value:!0});var r=e(require("react"));exports.polymorphicComponent=function(e){return r.forwardRef(e)};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * A wrapper to use React.forwardRef with polymorphic components in a type-safe manner. This is a
+ * convenience over merely using React.forwardRef directly, and then manually forcing the resulting
+ * value to be typed using `as PolymorphicComponent<…>`.
+ *
+ * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)
+ */
+function polymorphicComponent(render) {
+    return React__namespace.forwardRef(render);
+}
+
+exports.polymorphicComponent = polymorphicComponent;
 //# sourceMappingURL=polymorphism.js.map

package/lib/utils/polymorphism.js.map

@@ -1 +1 @@
-{"version":3,"file":"polymorphism.js","sources":["../../src/utils/polymorphism.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport * as React from 'react'\nimport type { ObfuscatedClassName } from './common-types'\n\ntype Merge<P1, P2> = Omit<P1, keyof P2> & P2\n\ntype EmptyObject = {\n    [K in any]: never\n}\n\ntype ObfuscateClassNameMode = 'keepClassName' | 'obfuscateClassName' | 'omitClassName'\n\n/**\n * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`\n * prop instead.\n *\n * This can be customized via the second generic parameter, as there are cases where it may be\n * needed to omit this behaviour and keep the `className`. You can also instruct it to remove the\n * `className` prop while not replacing it with the `exceptionallySetClassName` one.\n *\n * @see ObfuscatedClassName['exceptionallySetClassName'] for details about this prop\n * @see PolymorphicComponent for details about this feature\n */\ntype WithObfuscatedClassName<\n    Props,\n    ShouldObfuscateClassName extends ObfuscateClassNameMode\n> = 'className' extends keyof Props\n    ? ShouldObfuscateClassName extends 'obfuscateClassName'\n        ? Omit<Props, 'className'> & ObfuscatedClassName\n        : ShouldObfuscateClassName extends 'omitClassName'\n        ? Omit<Props, 'className'>\n        : ShouldObfuscateClassName extends 'keepClassName'\n        ? Props\n        : never\n    : Props\n\ntype PolymorphicProp<ComponentType extends React.ElementType> = {\n    /**\n     * Used to instruct this component what React element to render as. It can be both a string\n     * representing a HTML tag name, or a React component.\n     *\n     * When using this prop, the component you apply it to will also recognize in its props types\n     * all the props from the component or HTML element you are rendering it as.\n     *\n     * Some uses for this feature:\n     *\n     * - Using some of our layout components, while at the same time being able to set them to use\n     *   semantic HTML elements needed for accessibility purposes (e.g. `nav`, `main`, etc).\n     * - Using a design system link component, but have it internally use a client-side router link\n     *   implemented via a React component (e.g. react-router's `Link`).\n     *\n     * Keep in mind that not all compositions of this kind may work well, especially when composing\n     * with another React component and not with a HTML tag name. In particular, if the components\n     * being composed have opposing concerns of clashing features (e.g. they have contradicting\n     * styles applied to them) things may not go well. In those cases prefer to nest them instead.\n     *\n     * @see PolymorphicComponent\n     */\n    as?: ComponentType\n}\n\n/**\n * Given a component or element type, and a set of additional props, this builds the entire set of\n * props for a polymorphic component.\n *\n * It does three things:\n *\n * 1. it merges the element type props with the `OwnProps`\n * 2. it adds the `as` prop to allow for polymorphism to happen\n * 3. it optionally obfuscates or omits the className prop if present\n *\n * @see PolymorphicProp\n * @see WithObfuscatedClassName\n */\ntype PolymorphicComponentProps<\n    ComponentType extends React.ElementType,\n    OwnProps,\n    ShouldObfuscateClassName extends ObfuscateClassNameMode\n> = Merge<\n    WithObfuscatedClassName<React.ComponentProps<ComponentType>, ShouldObfuscateClassName>,\n    OwnProps & PolymorphicProp<ComponentType>\n>\n\ntype ElementTagNameMap = HTMLElementTagNameMap &\n    Pick<SVGElementTagNameMap, Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>>\n\ntype ElementByTag<TagName extends keyof ElementTagNameMap> = ElementTagNameMap[TagName]\n\ntype ElementByTagOrAny<\n    ComponentType extends React.ElementType\n> = ComponentType extends keyof ElementTagNameMap ? ElementByTag<ComponentType> : any\n\n/**\n * The function passed to React.forwardRef, but typed in a way that's prepared for polymorphism via\n * the `as` prop. It also allows to specify if the `className` prop should be obfuscated or omitted.\n *\n * @see PolymorphicComponentProps\n * @see WithObfuscatedClassName\n */\ninterface ForwardRefFunction<\n    ComponentType extends React.ElementType,\n    OwnProps,\n    ShouldObfuscateClassName extends ObfuscateClassNameMode\n> {\n    (\n        props: PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>,\n        ref:\n            | ((instance: ElementByTagOrAny<ComponentType> | null) => void)\n            | React.MutableRefObject<ElementByTagOrAny<ComponentType> | null>\n            | null,\n    ): React.ReactElement | null\n    displayName?: string\n}\n\n/**\n * A component that can customize the React element type that it renders (a.k.a. a polymorphic\n * component). This is achieved by passing a prop `as={ElementType}` or `as=\"html-tag-name\"`.\n *\n * It transparently takes care of forwarding refs, and properly sets the ref type depending on the\n * element type.\n *\n * ## Recognizing props based on the polymorphic type\n *\n * The `ComponentType` argument sets the default type for the `as` prop. Whatever the `as` prop\n * component or HTML element is, the type system will automatically allow you to pass props that are\n * not explicitly defined by you, but that are recognized as valid props to be passed to the\n * component you are rendering.\n *\n * For instance, see the following example:\n *\n * ```jsx\n * <Box as=\"label\" htmlFor=\"field-id\">Hello</Box>\n * ```\n *\n * The `htmlFor` prop is exclusive to label elements. If you omit the `as=\"label\"` prop, the type\n * system will consider the `htmlFor` prop to be an error. The same happens if you pass a value of\n * an incorrect type to such prop. For instance, the example below will issue a type error:\n *\n * ```jsx\n * <Box as=\"label\" htmlFor={123}>Hello</Box>\n * ```\n *\n * ## Omitting or obfuscating the `className` prop\n *\n * If a set of props include the `className` prop, we replace it with a `exceptionallySetClassName`\n * prop instead.\n *\n * This is to discourage customizing design system components via custom styling, while still\n * leaving the door open to do it as an escape hatch when the design system still has shortcomings\n * with respect to the product designs we want to achieve.\n *\n * The cumbersome name also serves the purpose of aiding in easily searching for the places in the\n * code where this escape hatch was needed, in order to identify areas where the design system\n * components need to improve to better match our needs.\n *\n * This behaviour can be customized via an optional second generic argument that allows to disable\n * this feature, or to omit the `className` altogether without replacing it with the obfuscated prop\n * name.\n *\n * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)\n */\ninterface PolymorphicComponent<\n    ComponentType extends React.ElementType,\n    OwnProps,\n    ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'\n> {\n    <TT extends React.ElementType = ComponentType>(\n        props: PolymorphicComponentProps<TT, OwnProps, ShouldObfuscateClassName>,\n    ): React.ReactElement | null\n    readonly $$typeof: symbol\n    defaultProps?: Partial<\n        PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>\n    >\n    propTypes?: React.WeakValidationMap<\n        PolymorphicComponentProps<ComponentType, OwnProps, ShouldObfuscateClassName>\n    >\n    displayName?: string\n}\n\n/**\n * A wrapper to use React.forwardRef with polymorphic components in a type-safe manner. This is a\n * convenience over merely using React.forwardRef directly, and then manually forcing the resulting\n * value to be typed using `as PolymorphicComponent<…>`.\n *\n * @deprecated Use Ariakit's composition instead (https://ariakit.org/guide/composition)\n */\nfunction polymorphicComponent<\n    ComponentType extends React.ElementType = 'div',\n    OwnProps = EmptyObject,\n    ShouldObfuscateClassName extends ObfuscateClassNameMode = 'obfuscateClassName'\n>(render: ForwardRefFunction<ComponentType, OwnProps, ShouldObfuscateClassName>) {\n    return React.forwardRef(render) as PolymorphicComponent<\n        ComponentType,\n        OwnProps,\n        ShouldObfuscateClassName\n    >\n}\n\nexport type { PolymorphicComponent }\nexport { polymorphicComponent }\n"],"names":["render","React","forwardRef"],"mappings":"2YA2LA,SAIEA,GACE,OAAOC,EAAMC,WAAWF"}
+{"version":3,"file":"polymorphism.js","sources":["../../src/utils/polymorphism.ts"],"sourcesContent":[null],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAoLA;;;;;;AAMG;AACH,SAAS,oBAAoB,CAI3B,MAA6E,EAAA;AAC3E,IAAA,OAAOA,gBAAK,CAAC,UAAU,CAAC,MAAM,CAI7B,CAAA;AACL;;;;"}