@burtson-labs/ui 0.13.1 → 0.14.0

package/dist/primitives/vendor/radix/react-primitive/primitive.d.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+declare module 'react' {
+    interface CSSProperties {
+        [varName: `--radix-${string}`]: string | number | undefined | null;
+    }
+}
+declare const NODES: readonly ["a", "button", "div", "form", "h2", "h3", "img", "input", "label", "li", "nav", "ol", "p", "select", "span", "svg", "ul"];
+type Primitives = {
+    [E in (typeof NODES)[number]]: PrimitiveForwardRefComponent<E>;
+};
+type PrimitivePropsWithRef<E extends React.ElementType> = React.ComponentPropsWithRef<E> & {
+    asChild?: boolean;
+};
+interface PrimitiveForwardRefComponent<E extends React.ElementType> extends React.ForwardRefExoticComponent<PrimitivePropsWithRef<E>> {
+}
+declare const Primitive: Primitives;
+/**
+ * Flush custom event dispatch
+ * https://github.com/radix-ui/primitives/pull/1378
+ *
+ * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.
+ *
+ * Internally, React prioritises events in the following order:
+ *  - discrete
+ *  - continuous
+ *  - default
+ *
+ * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350
+ *
+ * `discrete` is an  important distinction as updates within these events are applied immediately.
+ * React however, is not able to infer the priority of custom event types due to how they are detected internally.
+ * Because of this, it's possible for updates from custom events to be unexpectedly batched when
+ * dispatched by another `discrete` event.
+ *
+ * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.
+ * This utility should be used when dispatching a custom event from within another `discrete` event, this utility
+ * is not necessary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.
+ * For example:
+ *
+ * dispatching a known click 👎
+ * target.dispatchEvent(new Event(‘click’))
+ *
+ * dispatching a custom type within a non-discrete event 👎
+ * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}
+ *
+ * dispatching a custom type within a `discrete` event 👍
+ * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}
+ *
+ * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use
+ * this utility with them. This is because it's possible for those handlers to be called implicitly during render
+ * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.
+ */
+declare function dispatchDiscreteCustomEvent<E extends CustomEvent>(target: E['target'], event: E): void;
+declare const Root: Primitives;
+export { Primitive, Root, dispatchDiscreteCustomEvent, };
+export type { PrimitivePropsWithRef };

package/dist/primitives/vendor/radix/react-primitive/primitive.js

@@ -0,0 +1,84 @@
+"use client";
+import { createSlot } from "../react-slot/slot.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import * as ReactDOM from "react-dom";
+//#region src/primitives/vendor/radix/react-primitive/primitive.tsx
+/* @__NO_SIDE_EFFECTS__ */ var Primitive = [
+	"a",
+	"button",
+	"div",
+	"form",
+	"h2",
+	"h3",
+	"img",
+	"input",
+	"label",
+	"li",
+	"nav",
+	"ol",
+	"p",
+	"select",
+	"span",
+	"svg",
+	"ul"
+].reduce((primitive, node) => {
+	const Slot = /* @__PURE__ */ createSlot(`Primitive.${node}`);
+	const Node = React.forwardRef((props, forwardedRef) => {
+		const { asChild, ...primitiveProps } = props;
+		const Comp = asChild ? Slot : node;
+		if (typeof window !== "undefined") window[Symbol.for("radix-ui")] = true;
+		return /* @__PURE__ */ jsx(Comp, {
+			...primitiveProps,
+			ref: forwardedRef
+		});
+	});
+	Node.displayName = `Primitive.${node}`;
+	return {
+		...primitive,
+		[node]: Node
+	};
+}, {});
+/**
+* Flush custom event dispatch
+* https://github.com/radix-ui/primitives/pull/1378
+*
+* React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.
+*
+* Internally, React prioritises events in the following order:
+*  - discrete
+*  - continuous
+*  - default
+*
+* https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350
+*
+* `discrete` is an  important distinction as updates within these events are applied immediately.
+* React however, is not able to infer the priority of custom event types due to how they are detected internally.
+* Because of this, it's possible for updates from custom events to be unexpectedly batched when
+* dispatched by another `discrete` event.
+*
+* In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.
+* This utility should be used when dispatching a custom event from within another `discrete` event, this utility
+* is not necessary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.
+* For example:
+*
+* dispatching a known click 👎
+* target.dispatchEvent(new Event(‘click’))
+*
+* dispatching a custom type within a non-discrete event 👎
+* onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}
+*
+* dispatching a custom type within a `discrete` event 👍
+* onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}
+*
+* Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use
+* this utility with them. This is because it's possible for those handlers to be called implicitly during render
+* e.g. when focus is within a component as it is unmounted, or when managing focus on mount.
+*/
+function dispatchDiscreteCustomEvent(target, event) {
+	if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));
+}
+//#endregion
+export { Primitive, dispatchDiscreteCustomEvent };
+
+//# sourceMappingURL=primitive.js.map

package/dist/primitives/vendor/radix/react-primitive/primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-primitive/primitive.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { createSlot } from '../react-slot';\n\ndeclare module 'react' {\n  interface CSSProperties {\n    [varName: `--radix-${string}`]: string | number | undefined | null;\n  }\n}\n\nconst NODES = [\n  'a',\n  'button',\n  'div',\n  'form',\n  'h2',\n  'h3',\n  'img',\n  'input',\n  'label',\n  'li',\n  'nav',\n  'ol',\n  'p',\n  'select',\n  'span',\n  'svg',\n  'ul',\n] as const;\n\ntype Primitives = { [E in (typeof NODES)[number]]: PrimitiveForwardRefComponent<E> };\ntype PrimitivePropsWithRef<E extends React.ElementType> = React.ComponentPropsWithRef<E> & {\n  asChild?: boolean;\n};\n\ninterface PrimitiveForwardRefComponent<\n  E extends React.ElementType,\n> extends React.ForwardRefExoticComponent<PrimitivePropsWithRef<E>> {}\n\n/* -------------------------------------------------------------------------------------------------\n * Primitive\n * -----------------------------------------------------------------------------------------------*/\n\n/* @__NO_SIDE_EFFECTS__ */ const Primitive = NODES.reduce((primitive, node) => {\n  const Slot = createSlot(`Primitive.${node}`);\n  const Node = React.forwardRef((props: PrimitivePropsWithRef<typeof node>, forwardedRef: any) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp: any = asChild ? Slot : node;\n\n    if (typeof window !== 'undefined') {\n      (window as any)[Symbol.for('radix-ui')] = true;\n    }\n\n    return <Comp {...primitiveProps} ref={forwardedRef} />;\n  });\n\n  Node.displayName = `Primitive.${node}`;\n\n  return { ...primitive, [node]: Node };\n}, {} as Primitives);\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Flush custom event dispatch\n * https://github.com/radix-ui/primitives/pull/1378\n *\n * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.\n *\n * Internally, React prioritises events in the following order:\n *  - discrete\n *  - continuous\n *  - default\n *\n * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L294-L350\n *\n * `discrete` is an  important distinction as updates within these events are applied immediately.\n * React however, is not able to infer the priority of custom event types due to how they are detected internally.\n * Because of this, it's possible for updates from custom events to be unexpectedly batched when\n * dispatched by another `discrete` event.\n *\n * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.\n * This utility should be used when dispatching a custom event from within another `discrete` event, this utility\n * is not necessary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.\n * For example:\n *\n * dispatching a known click 👎\n * target.dispatchEvent(new Event(‘click’))\n *\n * dispatching a custom type within a non-discrete event 👎\n * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}\n *\n * dispatching a custom type within a `discrete` event 👍\n * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}\n *\n * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use\n * this utility with them. This is because it's possible for those handlers to be called implicitly during render\n * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.\n */\n\nfunction dispatchDiscreteCustomEvent<E extends CustomEvent>(target: E['target'], event: E) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Primitive;\n\nexport {\n  Primitive,\n  //\n  Root,\n  //\n  dispatchDiscreteCustomEvent,\n};\nexport type { PrimitivePropsWithRef };\n"],"mappings":";;;;;;2BA6C2B,IAAM,YAAY;CAhC3C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AAgB2C,CAAA,CAAM,QAAQ,WAAW,SAAS;CAC7E,MAAM,OAAO,2BAAW,aAAa,MAAM;CAC3C,MAAM,OAAO,MAAM,YAAY,OAA2C,iBAAsB;EAC9F,MAAM,EAAE,SAAS,GAAG,mBAAmB;EACvC,MAAM,OAAY,UAAU,OAAO;EAEnC,IAAI,OAAO,WAAW,aACpB,OAAgB,OAAO,IAAI,UAAU,KAAK;EAG5C,OAAO,oBAAC,MAAD;GAAM,GAAI;GAAgB,KAAK;EAAe,CAAA;CACvD,CAAC;CAED,KAAK,cAAc,aAAa;CAEhC,OAAO;EAAE,GAAG;GAAY,OAAO;CAAK;AACtC,GAAG,CAAC,CAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CnB,SAAS,4BAAmD,QAAqB,OAAU;CACzF,IAAI,QAAQ,SAAS,gBAAgB,OAAO,cAAc,KAAK,CAAC;AAClE"}

package/dist/primitives/vendor/radix/react-progress/index.d.ts

@@ -0,0 +1,2 @@
+export { createProgressScope, Progress, ProgressIndicator, Root, Indicator, } from './progress';
+export type { ProgressProps, ProgressIndicatorProps } from './progress';

package/dist/primitives/vendor/radix/react-progress/progress.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+declare const createProgressScope: import("../react-context").CreateScope;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface ProgressProps extends PrimitiveDivProps {
+    value?: number | null | undefined;
+    max?: number;
+    getValueLabel?(value: number, max: number): string;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+interface ProgressIndicatorProps extends PrimitiveDivProps {
+}
+declare const ProgressIndicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+declare const Indicator: React.ForwardRefExoticComponent<ProgressIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+export { createProgressScope, Progress, ProgressIndicator, Root, Indicator, };
+export type { ProgressProps, ProgressIndicatorProps };

package/dist/primitives/vendor/radix/react-progress/progress.js

@@ -0,0 +1,79 @@
+"use client";
+import { createContextScope } from "../react-context/create-context.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-progress/progress.tsx
+var PROGRESS_NAME = "Progress";
+var DEFAULT_MAX = 100;
+var [createProgressContext, createProgressScope] = createContextScope(PROGRESS_NAME);
+var [ProgressProvider, useProgressContext] = createProgressContext(PROGRESS_NAME);
+var Progress = /* @__PURE__ */ React.forwardRef(function Progress(props, forwardedRef) {
+	const { __scopeProgress, value: valueProp = null, max: maxProp, getValueLabel = defaultGetValueLabel, ...progressProps } = props;
+	if ((maxProp || maxProp === 0) && !isValidMaxNumber(maxProp)) console.error(getInvalidMaxError(`${maxProp}`, "Progress"));
+	const max = isValidMaxNumber(maxProp) ? maxProp : DEFAULT_MAX;
+	if (valueProp !== null && !isValidValueNumber(valueProp, max)) console.error(getInvalidValueError(`${valueProp}`, "Progress"));
+	const value = isValidValueNumber(valueProp, max) ? valueProp : null;
+	const valueLabel = isNumber(value) ? getValueLabel(value, max) : void 0;
+	return /* @__PURE__ */ jsx(ProgressProvider, {
+		scope: __scopeProgress,
+		value,
+		max,
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			"aria-valuemax": max,
+			"aria-valuemin": 0,
+			"aria-valuenow": isNumber(value) ? value : void 0,
+			"aria-valuetext": valueLabel,
+			role: "progressbar",
+			"data-state": getProgressState(value, max),
+			"data-value": value ?? void 0,
+			"data-max": max,
+			...progressProps,
+			ref: forwardedRef
+		})
+	});
+});
+var INDICATOR_NAME = "ProgressIndicator";
+var ProgressIndicator = /* @__PURE__ */ React.forwardRef(function ProgressIndicator(props, forwardedRef) {
+	const { __scopeProgress, ...indicatorProps } = props;
+	const context = useProgressContext(INDICATOR_NAME, __scopeProgress);
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		"data-state": getProgressState(context.value, context.max),
+		"data-value": context.value ?? void 0,
+		"data-max": context.max,
+		...indicatorProps,
+		ref: forwardedRef
+	});
+});
+function defaultGetValueLabel(value, max) {
+	return `${Math.round(value / max * 100)}%`;
+}
+function getProgressState(value, maxValue) {
+	return value == null ? "indeterminate" : value === maxValue ? "complete" : "loading";
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isValidMaxNumber(max) {
+	return isNumber(max) && !isNaN(max) && max > 0;
+}
+function isValidValueNumber(value, max) {
+	return isNumber(value) && !isNaN(value) && value <= max && value >= 0;
+}
+function getInvalidMaxError(propValue, componentName) {
+	return `Invalid prop \`max\` of value \`${propValue}\` supplied to \`${componentName}\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_MAX}\`.`;
+}
+function getInvalidValueError(propValue, componentName) {
+	return `Invalid prop \`value\` of value \`${propValue}\` supplied to \`${componentName}\`. The \`value\` prop must be:
+  - a positive number
+  - less than the value passed to \`max\` (or ${DEFAULT_MAX} if no \`max\` prop is set)
+  - \`null\` or \`undefined\` if the progress is indeterminate.
+
+Defaulting to \`null\`.`;
+}
+var Root = Progress;
+var Indicator = ProgressIndicator;
+//#endregion
+export { Indicator, Progress, ProgressIndicator, Root };
+
+//# sourceMappingURL=progress.js.map

package/dist/primitives/vendor/radix/react-progress/progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-progress/progress.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { createContextScope } from '../react-context';\nimport { Primitive } from '../react-primitive';\n\nimport type { Scope } from '../react-context';\n\n/* -------------------------------------------------------------------------------------------------\n * Progress\n * -----------------------------------------------------------------------------------------------*/\n\nconst PROGRESS_NAME = 'Progress';\nconst DEFAULT_MAX = 100;\n\ntype ScopedProps<P> = P & { __scopeProgress?: Scope };\nconst [createProgressContext, createProgressScope] = createContextScope(PROGRESS_NAME);\n\ntype ProgressState = 'indeterminate' | 'complete' | 'loading';\ntype ProgressContextValue = { value: number | null; max: number };\nconst [ProgressProvider, useProgressContext] =\n  createProgressContext<ProgressContextValue>(PROGRESS_NAME);\n\ntype ProgressElement = React.ComponentRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface ProgressProps extends PrimitiveDivProps {\n  value?: number | null | undefined;\n  max?: number;\n  getValueLabel?(value: number, max: number): string;\n}\n\nconst Progress = /* @__PURE__ */ React.forwardRef<ProgressElement, ProgressProps>(\n  // blank line to reduce diff noise\n  function Progress(props: ScopedProps<ProgressProps>, forwardedRef) {\n    const {\n      __scopeProgress,\n      value: valueProp = null,\n      max: maxProp,\n      getValueLabel = defaultGetValueLabel,\n      ...progressProps\n    } = props;\n\n    if ((maxProp || maxProp === 0) && !isValidMaxNumber(maxProp)) {\n      console.error(getInvalidMaxError(`${maxProp}`, 'Progress'));\n    }\n\n    const max = isValidMaxNumber(maxProp) ? maxProp : DEFAULT_MAX;\n\n    if (valueProp !== null && !isValidValueNumber(valueProp, max)) {\n      console.error(getInvalidValueError(`${valueProp}`, 'Progress'));\n    }\n\n    const value = isValidValueNumber(valueProp, max) ? valueProp : null;\n    const valueLabel = isNumber(value) ? getValueLabel(value, max) : undefined;\n\n    return (\n      <ProgressProvider scope={__scopeProgress} value={value} max={max}>\n        <Primitive.div\n          aria-valuemax={max}\n          aria-valuemin={0}\n          aria-valuenow={isNumber(value) ? value : undefined}\n          aria-valuetext={valueLabel}\n          role=\"progressbar\"\n          data-state={getProgressState(value, max)}\n          data-value={value ?? undefined}\n          data-max={max}\n          {...progressProps}\n          ref={forwardedRef}\n        />\n      </ProgressProvider>\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * ProgressIndicator\n * -----------------------------------------------------------------------------------------------*/\n\nconst INDICATOR_NAME = 'ProgressIndicator';\n\ntype ProgressIndicatorElement = React.ComponentRef<typeof Primitive.div>;\ninterface ProgressIndicatorProps extends PrimitiveDivProps {}\n\nconst ProgressIndicator = /* @__PURE__ */ React.forwardRef<\n  ProgressIndicatorElement,\n  ProgressIndicatorProps\n>(\n  // blank line to reduce diff noise\n  function ProgressIndicator(props: ScopedProps<ProgressIndicatorProps>, forwardedRef) {\n    const { __scopeProgress, ...indicatorProps } = props;\n    const context = useProgressContext(INDICATOR_NAME, __scopeProgress);\n    return (\n      <Primitive.div\n        data-state={getProgressState(context.value, context.max)}\n        data-value={context.value ?? undefined}\n        data-max={context.max}\n        {...indicatorProps}\n        ref={forwardedRef}\n      />\n    );\n  },\n);\n\n/* ---------------------------------------------------------------------------------------------- */\n\nfunction defaultGetValueLabel(value: number, max: number) {\n  return `${Math.round((value / max) * 100)}%`;\n}\n\nfunction getProgressState(value: number | undefined | null, maxValue: number): ProgressState {\n  return value == null ? 'indeterminate' : value === maxValue ? 'complete' : 'loading';\n}\n\nfunction isNumber(value: any): value is number {\n  return typeof value === 'number';\n}\n\nfunction isValidMaxNumber(max: any): max is number {\n  // oxfmt-ignore\n  return (\n    isNumber(max) &&\n    !isNaN(max) &&\n    max > 0\n  );\n}\n\nfunction isValidValueNumber(value: any, max: number): value is number {\n  // oxfmt-ignore\n  return (\n    isNumber(value) &&\n    !isNaN(value) &&\n    value <= max &&\n    value >= 0\n  );\n}\n\n// Split this out for clearer readability of the error message.\nfunction getInvalidMaxError(propValue: string, componentName: string) {\n  return `Invalid prop \\`max\\` of value \\`${propValue}\\` supplied to \\`${componentName}\\`. Only numbers greater than 0 are valid max values. Defaulting to \\`${DEFAULT_MAX}\\`.`;\n}\n\nfunction getInvalidValueError(propValue: string, componentName: string) {\n  return `Invalid prop \\`value\\` of value \\`${propValue}\\` supplied to \\`${componentName}\\`. The \\`value\\` prop must be:\n  - a positive number\n  - less than the value passed to \\`max\\` (or ${DEFAULT_MAX} if no \\`max\\` prop is set)\n  - \\`null\\` or \\`undefined\\` if the progress is indeterminate.\n\nDefaulting to \\`null\\`.`;\n}\n\nconst Root = Progress;\nconst Indicator = ProgressIndicator;\n\nexport {\n  createProgressScope,\n  //\n  Progress,\n  ProgressIndicator,\n  //\n  Root,\n  Indicator,\n};\nexport type { ProgressProps, ProgressIndicatorProps };\n"],"mappings":";;;;;;AAYA,IAAM,gBAAgB;AACtB,IAAM,cAAc;AAGpB,IAAM,CAAC,uBAAuB,uBAAuB,mBAAmB,aAAa;AAIrF,IAAM,CAAC,kBAAkB,sBACvB,sBAA4C,aAAa;AAU3D,IAAM,WAA2B,sBAAM,WAErC,SAAS,SAAS,OAAmC,cAAc;CACjE,MAAM,EACJ,iBACA,OAAO,YAAY,MACnB,KAAK,SACL,gBAAgB,sBAChB,GAAG,kBACD;CAEJ,KAAK,WAAW,YAAY,MAAM,CAAC,iBAAiB,OAAO,GACzD,QAAQ,MAAM,mBAAmB,GAAG,WAAW,UAAU,CAAC;CAG5D,MAAM,MAAM,iBAAiB,OAAO,IAAI,UAAU;CAElD,IAAI,cAAc,QAAQ,CAAC,mBAAmB,WAAW,GAAG,GAC1D,QAAQ,MAAM,qBAAqB,GAAG,aAAa,UAAU,CAAC;CAGhE,MAAM,QAAQ,mBAAmB,WAAW,GAAG,IAAI,YAAY;CAC/D,MAAM,aAAa,SAAS,KAAK,IAAI,cAAc,OAAO,GAAG,IAAI,KAAA;CAEjE,OACE,oBAAC,kBAAD;EAAkB,OAAO;EAAwB;EAAY;EAC3D,UAAA,oBAAC,UAAU,KAAX;GACE,iBAAe;GACf,iBAAe;GACf,iBAAe,SAAS,KAAK,IAAI,QAAQ,KAAA;GACzC,kBAAgB;GAChB,MAAK;GACL,cAAY,iBAAiB,OAAO,GAAG;GACvC,cAAY,SAAS,KAAA;GACrB,YAAU;GACV,GAAI;GACJ,KAAK;EACN,CAAA;CACe,CAAA;AAEtB,CACF;AAMA,IAAM,iBAAiB;AAKvB,IAAM,oBAAoC,sBAAM,WAK9C,SAAS,kBAAkB,OAA4C,cAAc;CACnF,MAAM,EAAE,iBAAiB,GAAG,mBAAmB;CAC/C,MAAM,UAAU,mBAAmB,gBAAgB,eAAe;CAClE,OACE,oBAAC,UAAU,KAAX;EACE,cAAY,iBAAiB,QAAQ,OAAO,QAAQ,GAAG;EACvD,cAAY,QAAQ,SAAS,KAAA;EAC7B,YAAU,QAAQ;EAClB,GAAI;EACJ,KAAK;CACN,CAAA;AAEL,CACF;AAIA,SAAS,qBAAqB,OAAe,KAAa;CACxD,OAAO,GAAG,KAAK,MAAO,QAAQ,MAAO,GAAG,EAAE;AAC5C;AAEA,SAAS,iBAAiB,OAAkC,UAAiC;CAC3F,OAAO,SAAS,OAAO,kBAAkB,UAAU,WAAW,aAAa;AAC7E;AAEA,SAAS,SAAS,OAA6B;CAC7C,OAAO,OAAO,UAAU;AAC1B;AAEA,SAAS,iBAAiB,KAAyB;CAEjD,OACE,SAAS,GAAG,KACZ,CAAC,MAAM,GAAG,KACV,MAAM;AAEV;AAEA,SAAS,mBAAmB,OAAY,KAA8B;CAEpE,OACE,SAAS,KAAK,KACd,CAAC,MAAM,KAAK,KACZ,SAAS,OACT,SAAS;AAEb;AAGA,SAAS,mBAAmB,WAAmB,eAAuB;CACpE,OAAO,mCAAmC,UAAU,mBAAmB,cAAc,wEAAwE,YAAY;AAC3K;AAEA,SAAS,qBAAqB,WAAmB,eAAuB;CACtE,OAAO,qCAAqC,UAAU,mBAAmB,cAAc;;gDAEzC,YAAY;;;;AAI5D;AAEA,IAAM,OAAO;AACb,IAAM,YAAY"}

package/dist/primitives/vendor/radix/react-radio-group/index.d.ts

@@ -0,0 +1,2 @@
+export { createRadioGroupScope, RadioGroup, RadioGroupItem, RadioGroupItemProvider as unstable_RadioGroupItemProvider, RadioGroupItemTrigger as unstable_RadioGroupItemTrigger, RadioGroupItemBubbleInput as unstable_RadioGroupItemBubbleInput, RadioGroupIndicator, Root, Item, ItemProvider as unstable_ItemProvider, ItemTrigger as unstable_ItemTrigger, ItemBubbleInput as unstable_ItemBubbleInput, Indicator, } from './radio-group';
+export type { RadioGroupProps, RadioGroupItemProps, RadioGroupItemProviderProps as unstable_RadioGroupItemProviderProps, RadioGroupItemTriggerProps as unstable_RadioGroupItemTriggerProps, RadioGroupItemBubbleInputProps as unstable_RadioGroupItemBubbleInputProps, RadioGroupIndicatorProps, } from './radio-group';

package/dist/primitives/vendor/radix/react-radio-group/radio-group.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+import * as RovingFocusGroup from '../react-roving-focus';
+import { type Radio, RadioTrigger, RadioBubbleInput, RadioIndicator } from './radio';
+import type { Scope } from '../react-context';
+type ScopedProps<P> = P & {
+    __scopeRadioGroup?: Scope;
+};
+declare const createRadioGroupScope: import("../react-context").CreateScope;
+type RadioGroupContextValue = {
+    name?: string;
+    form?: string;
+    required: boolean;
+    disabled: boolean;
+    value: string | null;
+    onValueChange(value: string): void;
+};
+type RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface RadioGroupProps extends PrimitiveDivProps {
+    name?: RadioGroupContextValue['name'];
+    form?: React.ComponentPropsWithoutRef<typeof Radio>['form'];
+    required?: React.ComponentPropsWithoutRef<typeof Radio>['required'];
+    disabled?: React.ComponentPropsWithoutRef<typeof Radio>['disabled'];
+    dir?: RovingFocusGroupProps['dir'];
+    orientation?: RovingFocusGroupProps['orientation'];
+    loop?: RovingFocusGroupProps['loop'];
+    defaultValue?: string;
+    value?: string | null;
+    onValueChange?: RadioGroupContextValue['onValueChange'];
+}
+declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProviderProps {
+    value: string;
+    disabled?: boolean;
+    children?: React.ReactNode;
+}
+declare function RadioGroupItemProvider(props: ScopedProps<RadioGroupItemProviderProps>): React.JSX.Element;
+interface RadioGroupItemTriggerProps extends React.ComponentPropsWithoutRef<typeof RadioTrigger> {
+}
+declare const RadioGroupItemTrigger: React.ForwardRefExoticComponent<RadioGroupItemTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type RadioProps = React.ComponentPropsWithoutRef<typeof Radio>;
+interface RadioGroupItemProps extends Omit<RadioProps, 'onCheck' | 'name'> {
+    value: string;
+}
+declare const RadioGroupItem: React.ForwardRefExoticComponent<RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+interface RadioGroupItemBubbleInputProps extends React.ComponentPropsWithoutRef<typeof RadioBubbleInput> {
+}
+declare const RadioGroupItemBubbleInput: React.ForwardRefExoticComponent<RadioGroupItemBubbleInputProps & React.RefAttributes<HTMLInputElement>>;
+type RadioIndicatorProps = React.ComponentPropsWithoutRef<typeof RadioIndicator>;
+interface RadioGroupIndicatorProps extends RadioIndicatorProps {
+}
+declare const RadioGroupIndicator: React.ForwardRefExoticComponent<RadioGroupIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+export { createRadioGroupScope, RadioGroup, RadioGroupItem, RadioGroupItemProvider, RadioGroupItemTrigger, RadioGroupItemBubbleInput, RadioGroupIndicator, RadioGroup as Root, RadioGroupItem as Item, RadioGroupItemProvider as ItemProvider, RadioGroupItemTrigger as ItemTrigger, RadioGroupItemBubbleInput as ItemBubbleInput, RadioGroupIndicator as Indicator, };
+export type { RadioGroupProps, RadioGroupItemProps, RadioGroupItemProviderProps, RadioGroupItemTriggerProps, RadioGroupItemBubbleInputProps, RadioGroupIndicatorProps, };

package/dist/primitives/vendor/radix/react-radio-group/radio-group.js

@@ -0,0 +1,173 @@
+"use client";
+import { createContextScope } from "../react-context/create-context.js";
+import { useComposedRefs } from "../react-compose-refs/compose-refs.js";
+import { composeEventHandlers } from "../primitive/primitive.js";
+import { useControllableState } from "../react-use-controllable-state/use-controllable-state.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import { useDirection } from "../react-direction/direction.js";
+import { Item, Root, createRovingFocusGroupScope } from "../react-roving-focus/roving-focus-group.js";
+import { RadioBubbleInput, RadioIndicator, RadioProvider, RadioTrigger, createRadioScope, useRadioContext } from "./radio.js";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-radio-group/radio-group.tsx
+var ARROW_KEYS = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowLeft",
+	"ArrowRight"
+];
+var RADIO_GROUP_NAME = "RadioGroup";
+var [createRadioGroupContext, createRadioGroupScope] = createContextScope(RADIO_GROUP_NAME, [createRovingFocusGroupScope, createRadioScope]);
+var useRovingFocusGroupScope = createRovingFocusGroupScope();
+var useRadioScope = createRadioScope();
+var [RadioGroupProvider, useRadioGroupContext] = createRadioGroupContext(RADIO_GROUP_NAME);
+var RadioGroup = /* @__PURE__ */ React.forwardRef(function RadioGroup(props, forwardedRef) {
+	const { __scopeRadioGroup, name, form, defaultValue, value: valueProp, required = false, disabled = false, orientation, dir, loop = true, onValueChange, ...groupProps } = props;
+	const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);
+	const direction = useDirection(dir);
+	const [value, setValue] = useControllableState({
+		prop: valueProp,
+		defaultProp: defaultValue ?? null,
+		onChange: onValueChange,
+		caller: RADIO_GROUP_NAME
+	});
+	const [control, setControl] = React.useState(null);
+	const composedRefs = useComposedRefs(forwardedRef, setControl);
+	const initialValueRef = React.useRef(value);
+	React.useEffect(() => {
+		const associatedForm = form ? control?.ownerDocument.getElementById(form) : control?.closest("form");
+		if (associatedForm instanceof HTMLFormElement) {
+			const reset = () => setValue(initialValueRef.current);
+			associatedForm.addEventListener("reset", reset);
+			return () => associatedForm.removeEventListener("reset", reset);
+		}
+	}, [
+		control,
+		form,
+		setValue
+	]);
+	return /* @__PURE__ */ jsx(RadioGroupProvider, {
+		scope: __scopeRadioGroup,
+		name,
+		form,
+		required,
+		disabled,
+		value,
+		onValueChange: setValue,
+		children: /* @__PURE__ */ jsx(Root, {
+			asChild: true,
+			...rovingFocusGroupScope,
+			orientation,
+			dir: direction,
+			loop,
+			children: /* @__PURE__ */ jsx(Primitive.div, {
+				role: "radiogroup",
+				"aria-required": required,
+				"aria-orientation": orientation,
+				"data-disabled": disabled ? "" : void 0,
+				dir: direction,
+				...groupProps,
+				ref: composedRefs
+			})
+		})
+	});
+});
+var ITEM_PROVIDER_NAME = "RadioGroupItemProvider";
+var ITEM_TRIGGER_NAME = "RadioGroupItemTrigger";
+function RadioGroupItemProvider(props) {
+	const { __scopeRadioGroup, value, disabled, children, internal_do_not_use_render } = props;
+	const context = useRadioGroupContext(ITEM_PROVIDER_NAME, __scopeRadioGroup);
+	const radioScope = useRadioScope(__scopeRadioGroup);
+	const isDisabled = context.disabled || disabled;
+	return /* @__PURE__ */ jsx(RadioProvider, {
+		...radioScope,
+		checked: context.value === value,
+		disabled: isDisabled,
+		required: context.required,
+		name: context.name,
+		form: context.form,
+		value,
+		onCheck: () => context.onValueChange(value),
+		internal_do_not_use_render,
+		children
+	});
+}
+var RadioGroupItemTrigger = /* @__PURE__ */ React.forwardRef(function RadioGroupItemTrigger(props, forwardedRef) {
+	const { __scopeRadioGroup, ...triggerProps } = props;
+	const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);
+	const radioScope = useRadioScope(__scopeRadioGroup);
+	const { checked, disabled } = useRadioContext(ITEM_TRIGGER_NAME, radioScope.__scopeRadio);
+	const ref = React.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, ref);
+	const isArrowKeyPressedRef = React.useRef(false);
+	React.useEffect(() => {
+		const handleKeyDown = (event) => {
+			if (ARROW_KEYS.includes(event.key)) isArrowKeyPressedRef.current = true;
+		};
+		const handleKeyUp = () => isArrowKeyPressedRef.current = false;
+		document.addEventListener("keydown", handleKeyDown);
+		document.addEventListener("keyup", handleKeyUp);
+		return () => {
+			document.removeEventListener("keydown", handleKeyDown);
+			document.removeEventListener("keyup", handleKeyUp);
+		};
+	}, []);
+	return /* @__PURE__ */ jsx(Item, {
+		asChild: true,
+		...rovingFocusGroupScope,
+		focusable: !disabled,
+		active: checked,
+		children: /* @__PURE__ */ jsx(RadioTrigger, {
+			...radioScope,
+			...triggerProps,
+			ref: composedRefs,
+			onKeyDown: composeEventHandlers(triggerProps.onKeyDown, (event) => {
+				if (event.key === "Enter") event.preventDefault();
+			}),
+			onFocus: composeEventHandlers(triggerProps.onFocus, () => {
+				/**
+				* Our `RovingFocusGroup` will focus the radio when navigating with
+				* arrow keys and we need to "check" it in that case. We click it to
+				* "check" it (instead of updating `context.value`) so that the radio
+				* change event fires.
+				*/
+				if (isArrowKeyPressedRef.current) ref.current?.click();
+			})
+		})
+	});
+});
+var RadioGroupItem = /* @__PURE__ */ React.forwardRef(function RadioGroupItem(props, forwardedRef) {
+	const { __scopeRadioGroup, value, disabled, ...itemProps } = props;
+	return /* @__PURE__ */ jsx(RadioGroupItemProvider, {
+		__scopeRadioGroup,
+		value,
+		disabled,
+		internal_do_not_use_render: ({ isFormControl }) => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(RadioGroupItemTrigger, {
+			...itemProps,
+			ref: forwardedRef,
+			__scopeRadioGroup
+		}), isFormControl && /* @__PURE__ */ jsx(RadioGroupItemBubbleInput, { __scopeRadioGroup })] })
+	});
+});
+var RadioGroupItemBubbleInput = /* @__PURE__ */ React.forwardRef(function RadioGroupItemBubbleInput(props, forwardedRef) {
+	const { __scopeRadioGroup, ...bubbleProps } = props;
+	const radioScope = useRadioScope(__scopeRadioGroup);
+	return /* @__PURE__ */ jsx(RadioBubbleInput, {
+		...radioScope,
+		...bubbleProps,
+		ref: forwardedRef
+	});
+});
+var RadioGroupIndicator = /* @__PURE__ */ React.forwardRef(function RadioGroupIndicator(props, forwardedRef) {
+	const { __scopeRadioGroup, ...indicatorProps } = props;
+	const radioScope = useRadioScope(__scopeRadioGroup);
+	return /* @__PURE__ */ jsx(RadioIndicator, {
+		...radioScope,
+		...indicatorProps,
+		ref: forwardedRef
+	});
+});
+//#endregion
+export { RadioGroupIndicator as Indicator, RadioGroupIndicator, RadioGroupItem as Item, RadioGroupItem, RadioGroupItemBubbleInput as ItemBubbleInput, RadioGroupItemBubbleInput, RadioGroupItemProvider as ItemProvider, RadioGroupItemProvider, RadioGroupItemTrigger as ItemTrigger, RadioGroupItemTrigger, RadioGroup, RadioGroup as Root };
+
+//# sourceMappingURL=radio-group.js.map

package/dist/primitives/vendor/radix/react-radio-group/radio-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radio-group.js","names":["RovingFocusGroup.Root","RovingFocusGroup.Item","_Fragment"],"sources":["../../../../../src/primitives/vendor/radix/react-radio-group/radio-group.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { composeEventHandlers } from '../primitive';\nimport { useComposedRefs } from '../react-compose-refs';\nimport { createContextScope } from '../react-context';\nimport { Primitive } from '../react-primitive';\nimport * as RovingFocusGroup from '../react-roving-focus';\nimport { createRovingFocusGroupScope } from '../react-roving-focus';\nimport { useControllableState } from '../react-use-controllable-state';\nimport { useDirection } from '../react-direction';\nimport {\n  type Radio,\n  RadioProvider,\n  RadioTrigger,\n  RadioBubbleInput,\n  RadioIndicator,\n  createRadioScope,\n  useRadioContext,\n} from './radio';\n\nimport type { Scope } from '../react-context';\n\nconst ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroup\n * -----------------------------------------------------------------------------------------------*/\nconst RADIO_GROUP_NAME = 'RadioGroup';\n\ntype ScopedProps<P> = P & { __scopeRadioGroup?: Scope };\nconst [createRadioGroupContext, createRadioGroupScope] = createContextScope(RADIO_GROUP_NAME, [\n  createRovingFocusGroupScope,\n  createRadioScope,\n]);\nconst useRovingFocusGroupScope = createRovingFocusGroupScope();\nconst useRadioScope = createRadioScope();\n\ntype RadioGroupContextValue = {\n  name?: string;\n  form?: string;\n  required: boolean;\n  disabled: boolean;\n  value: string | null;\n  onValueChange(value: string): void;\n};\n\nconst [RadioGroupProvider, useRadioGroupContext] =\n  createRadioGroupContext<RadioGroupContextValue>(RADIO_GROUP_NAME);\n\ntype RadioGroupElement = React.ComponentRef<typeof Primitive.div>;\ntype RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface RadioGroupProps extends PrimitiveDivProps {\n  name?: RadioGroupContextValue['name'];\n  form?: React.ComponentPropsWithoutRef<typeof Radio>['form'];\n  required?: React.ComponentPropsWithoutRef<typeof Radio>['required'];\n  disabled?: React.ComponentPropsWithoutRef<typeof Radio>['disabled'];\n  dir?: RovingFocusGroupProps['dir'];\n  orientation?: RovingFocusGroupProps['orientation'];\n  loop?: RovingFocusGroupProps['loop'];\n  defaultValue?: string;\n  value?: string | null;\n  onValueChange?: RadioGroupContextValue['onValueChange'];\n}\n\nconst RadioGroup = /* @__PURE__ */ React.forwardRef<RadioGroupElement, RadioGroupProps>(\n  function RadioGroup(props: ScopedProps<RadioGroupProps>, forwardedRef) {\n    const {\n      __scopeRadioGroup,\n      name,\n      form,\n      defaultValue,\n      value: valueProp,\n      required = false,\n      disabled = false,\n      orientation,\n      dir,\n      loop = true,\n      onValueChange,\n      ...groupProps\n    } = props;\n    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);\n    const direction = useDirection(dir);\n    const [value, setValue] = useControllableState({\n      prop: valueProp,\n      defaultProp: defaultValue ?? null,\n      onChange: onValueChange as (value: string | null) => void,\n      caller: RADIO_GROUP_NAME,\n    });\n    const [control, setControl] = React.useState<RadioGroupElement | null>(null);\n    const composedRefs = useComposedRefs(forwardedRef, setControl);\n\n    const initialValueRef = React.useRef(value);\n    React.useEffect(() => {\n      const associatedForm = form\n        ? control?.ownerDocument.getElementById(form)\n        : control?.closest('form');\n      if (associatedForm instanceof HTMLFormElement) {\n        const reset = () => setValue(initialValueRef.current);\n        associatedForm.addEventListener('reset', reset);\n        return () => associatedForm.removeEventListener('reset', reset);\n      }\n    }, [control, form, setValue]);\n\n    return (\n      <RadioGroupProvider\n        scope={__scopeRadioGroup}\n        name={name}\n        form={form}\n        required={required}\n        disabled={disabled}\n        value={value}\n        onValueChange={setValue}\n      >\n        <RovingFocusGroup.Root\n          asChild\n          {...rovingFocusGroupScope}\n          orientation={orientation}\n          dir={direction}\n          loop={loop}\n        >\n          <Primitive.div\n            role=\"radiogroup\"\n            aria-required={required}\n            aria-orientation={orientation}\n            data-disabled={disabled ? '' : undefined}\n            dir={direction}\n            {...groupProps}\n            ref={composedRefs}\n          />\n        </RovingFocusGroup.Root>\n      </RadioGroupProvider>\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupItemProvider\n * -----------------------------------------------------------------------------------------------*/\nconst ITEM_PROVIDER_NAME = 'RadioGroupItemProvider';\nconst ITEM_TRIGGER_NAME = 'RadioGroupItemTrigger';\n\ninterface RadioGroupItemProviderProps {\n  value: string;\n  disabled?: boolean;\n  children?: React.ReactNode;\n}\n\nfunction RadioGroupItemProvider(props: ScopedProps<RadioGroupItemProviderProps>) {\n  const {\n    __scopeRadioGroup,\n    value,\n    disabled,\n    children,\n    // @ts-expect-error\n    internal_do_not_use_render,\n  } = props;\n  const context = useRadioGroupContext(ITEM_PROVIDER_NAME, __scopeRadioGroup);\n  const radioScope = useRadioScope(__scopeRadioGroup);\n  const isDisabled = context.disabled || disabled;\n\n  return (\n    <RadioProvider\n      {...radioScope}\n      checked={context.value === value}\n      disabled={isDisabled}\n      required={context.required}\n      name={context.name}\n      form={context.form}\n      value={value}\n      onCheck={() => context.onValueChange(value)}\n      // @ts-expect-error\n      internal_do_not_use_render={internal_do_not_use_render}\n    >\n      {children}\n    </RadioProvider>\n  );\n}\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupItemTrigger\n * -----------------------------------------------------------------------------------------------*/\n\ntype RadioGroupItemTriggerElement = React.ComponentRef<typeof RadioTrigger>;\ninterface RadioGroupItemTriggerProps extends React.ComponentPropsWithoutRef<typeof RadioTrigger> {}\n\nconst RadioGroupItemTrigger = /* @__PURE__ */ React.forwardRef<\n  RadioGroupItemTriggerElement,\n  RadioGroupItemTriggerProps\n>(function RadioGroupItemTrigger(props: ScopedProps<RadioGroupItemTriggerProps>, forwardedRef) {\n  const { __scopeRadioGroup, ...triggerProps } = props;\n  const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);\n  const radioScope = useRadioScope(__scopeRadioGroup);\n  const { checked, disabled } = useRadioContext(ITEM_TRIGGER_NAME, radioScope.__scopeRadio);\n  const ref = React.useRef<RadioGroupItemTriggerElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  const isArrowKeyPressedRef = React.useRef(false);\n\n  React.useEffect(() => {\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (ARROW_KEYS.includes(event.key)) {\n        isArrowKeyPressedRef.current = true;\n      }\n    };\n    const handleKeyUp = () => (isArrowKeyPressedRef.current = false);\n    document.addEventListener('keydown', handleKeyDown);\n    document.addEventListener('keyup', handleKeyUp);\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n      document.removeEventListener('keyup', handleKeyUp);\n    };\n  }, []);\n\n  return (\n    <RovingFocusGroup.Item\n      asChild\n      {...rovingFocusGroupScope}\n      focusable={!disabled}\n      active={checked}\n    >\n      <RadioTrigger\n        {...radioScope}\n        {...triggerProps}\n        ref={composedRefs}\n        onKeyDown={composeEventHandlers(triggerProps.onKeyDown, (event) => {\n          // According to WAI ARIA, radio groups don't activate items on enter\n          // keypress\n          if (event.key === 'Enter') event.preventDefault();\n        })}\n        onFocus={composeEventHandlers(triggerProps.onFocus, () => {\n          /**\n           * Our `RovingFocusGroup` will focus the radio when navigating with\n           * arrow keys and we need to \"check\" it in that case. We click it to\n           * \"check\" it (instead of updating `context.value`) so that the radio\n           * change event fires.\n           */\n          if (isArrowKeyPressedRef.current) {\n            ref.current?.click();\n          }\n        })}\n      />\n    </RovingFocusGroup.Item>\n  );\n});\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupItem\n * -----------------------------------------------------------------------------------------------*/\n\ntype RadioGroupItemElement = React.ComponentRef<typeof Radio>;\ntype RadioProps = React.ComponentPropsWithoutRef<typeof Radio>;\ninterface RadioGroupItemProps extends Omit<RadioProps, 'onCheck' | 'name'> {\n  value: string;\n}\n\nconst RadioGroupItem = /* @__PURE__ */ React.forwardRef<RadioGroupItemElement, RadioGroupItemProps>(\n  function RadioGroupItem(props: ScopedProps<RadioGroupItemProps>, forwardedRef) {\n    const { __scopeRadioGroup, value, disabled, ...itemProps } = props;\n\n    return (\n      <RadioGroupItemProvider\n        __scopeRadioGroup={__scopeRadioGroup}\n        value={value}\n        disabled={disabled}\n        // @ts-expect-error\n        internal_do_not_use_render={({ isFormControl }: { isFormControl: boolean }) => (\n          <>\n            <RadioGroupItemTrigger\n              {...itemProps}\n              ref={forwardedRef}\n              // @ts-expect-error\n              __scopeRadioGroup={__scopeRadioGroup}\n            />\n            {isFormControl && (\n              <RadioGroupItemBubbleInput\n                // @ts-expect-error\n                __scopeRadioGroup={__scopeRadioGroup}\n              />\n            )}\n          </>\n        )}\n      />\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupItemBubbleInput\n * -----------------------------------------------------------------------------------------------*/\n\ntype RadioGroupItemBubbleInputElement = React.ComponentRef<typeof RadioBubbleInput>;\ninterface RadioGroupItemBubbleInputProps extends React.ComponentPropsWithoutRef<\n  typeof RadioBubbleInput\n> {}\n\nconst RadioGroupItemBubbleInput = /* @__PURE__ */ React.forwardRef<\n  RadioGroupItemBubbleInputElement,\n  RadioGroupItemBubbleInputProps\n>(function RadioGroupItemBubbleInput(\n  props: ScopedProps<RadioGroupItemBubbleInputProps>,\n  forwardedRef,\n) {\n  const { __scopeRadioGroup, ...bubbleProps } = props;\n  const radioScope = useRadioScope(__scopeRadioGroup);\n  return <RadioBubbleInput {...radioScope} {...bubbleProps} ref={forwardedRef} />;\n});\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupIndicator\n * -----------------------------------------------------------------------------------------------*/\n\ntype RadioGroupIndicatorElement = React.ComponentRef<typeof RadioIndicator>;\ntype RadioIndicatorProps = React.ComponentPropsWithoutRef<typeof RadioIndicator>;\ninterface RadioGroupIndicatorProps extends RadioIndicatorProps {}\n\nconst RadioGroupIndicator = /* @__PURE__ */ React.forwardRef<\n  RadioGroupIndicatorElement,\n  RadioGroupIndicatorProps\n>(\n  // blank line to reduce diff noise\n  function RadioGroupIndicator(props: ScopedProps<RadioGroupIndicatorProps>, forwardedRef) {\n    const { __scopeRadioGroup, ...indicatorProps } = props;\n    const radioScope = useRadioScope(__scopeRadioGroup);\n    return <RadioIndicator {...radioScope} {...indicatorProps} ref={forwardedRef} />;\n  },\n);\n\n/* ---------------------------------------------------------------------------------------------- */\n\nexport {\n  createRadioGroupScope,\n  //\n  RadioGroup,\n  RadioGroupItem,\n  RadioGroupItemProvider,\n  RadioGroupItemTrigger,\n  RadioGroupItemBubbleInput,\n  RadioGroupIndicator,\n  //\n  RadioGroup as Root,\n  RadioGroupItem as Item,\n  RadioGroupItemProvider as ItemProvider,\n  RadioGroupItemTrigger as ItemTrigger,\n  RadioGroupItemBubbleInput as ItemBubbleInput,\n  RadioGroupIndicator as Indicator,\n};\nexport type {\n  RadioGroupProps,\n  RadioGroupItemProps,\n  RadioGroupItemProviderProps,\n  RadioGroupItemTriggerProps,\n  RadioGroupItemBubbleInputProps,\n  RadioGroupIndicatorProps,\n};\n"],"mappings":"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"}

package/dist/primitives/vendor/radix/react-radio-group/radio.d.ts

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+import type { Scope } from '../react-context';
+type ScopedProps<P> = P & {
+    __scopeRadio?: Scope;
+};
+declare const createRadioScope: import("../react-context").CreateScope;
+type RadioContextValue = {
+    checked: boolean;
+    disabled: boolean | undefined;
+    required: boolean | undefined;
+    name: string | undefined;
+    form: string | undefined;
+    value: string | number | readonly string[];
+    control: HTMLButtonElement | null;
+    setControl: React.Dispatch<React.SetStateAction<HTMLButtonElement | null>>;
+    hasConsumerStoppedPropagationRef: React.RefObject<boolean>;
+    userInteractionCount: number;
+    onUserInteraction: () => void;
+    isFormControl: boolean;
+    bubbleInput: HTMLInputElement | null;
+    setBubbleInput: React.Dispatch<React.SetStateAction<HTMLInputElement | null>>;
+    onCheck(): void;
+};
+declare const useRadioContext: import("../react-context/create-context").UseScopedContext<RadioContextValue>;
+interface RadioProviderProps {
+    checked?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    name?: string;
+    form?: string;
+    value?: string | number | readonly string[];
+    onCheck?(): void;
+    children?: React.ReactNode;
+}
+declare function RadioProvider(props: ScopedProps<RadioProviderProps>): React.JSX.Element;
+interface RadioTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof Primitive.button>, keyof RadioProviderProps> {
+    children?: React.ReactNode;
+}
+declare const RadioTrigger: React.ForwardRefExoticComponent<RadioTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface RadioProps extends Omit<PrimitiveButtonProps, 'checked'> {
+    checked?: boolean;
+    required?: boolean;
+    onCheck?(): void;
+}
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLButtonElement>>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+export interface RadioIndicatorProps extends PrimitiveSpanProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with React animation libraries.
+     */
+    forceMount?: true;
+}
+declare const RadioIndicator: React.ForwardRefExoticComponent<RadioIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+type InputProps = React.ComponentPropsWithoutRef<typeof Primitive.input>;
+interface RadioBubbleInputProps extends Omit<InputProps, 'checked'> {
+}
+declare const RadioBubbleInput: React.ForwardRefExoticComponent<RadioBubbleInputProps & React.RefAttributes<HTMLInputElement>>;
+export { createRadioScope, useRadioContext, Radio, RadioProvider, RadioTrigger, RadioIndicator, RadioBubbleInput, };
+export type { RadioProps, RadioProviderProps, RadioTriggerProps, RadioBubbleInputProps };