@zag-js/radio-group 0.10.5 → 0.11.0

package/dist/index.d.mts

@@ -0,0 +1,136 @@
+import * as _zag_js_anatomy from '@zag-js/anatomy';
+import { RequiredBy, DirectionProperty, CommonProperties, Context, PropTypes, NormalizeProps } from '@zag-js/types';
+import * as _zag_js_core from '@zag-js/core';
+import { StateMachine } from '@zag-js/core';
+
+declare const anatomy: _zag_js_anatomy.AnatomyInstance<"root" | "label" | "radio" | "radioLabel" | "radioControl" | "radioInput" | "indicator">;
+
+type ElementIds = Partial<{
+    root: string;
+    label: string;
+    indicator: string;
+    radio(value: string): string;
+    radioLabel(value: string): string;
+    radioControl(value: string): string;
+    radioInput(value: string): string;
+}>;
+type PublicContext = DirectionProperty & CommonProperties & {
+    /**
+     * The ids of the elements in the radio. Useful for composition.
+     */
+    ids?: ElementIds;
+    /**
+     * The value of the checked radio
+     */
+    value: string | null;
+    /**
+     * The name of the input fields in the radio
+     * (Useful for form submission).
+     */
+    name?: string;
+    /**
+     * The associate form of the underlying input.
+     */
+    form?: string;
+    /**
+     * If `true`, the radio group will be disabled
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the radio group will be readonly
+     */
+    readOnly?: boolean;
+    /**
+     * Function called once a radio is checked
+     * @param value the value of the checked radio
+     */
+    onChange?(details: {
+        value: string;
+    }): void;
+    /**
+     * Orientation of the radio group
+     */
+    orientation?: "horizontal" | "vertical";
+};
+type PrivateContext = Context<{}>;
+type UserDefinedContext = RequiredBy<PublicContext, "id">;
+type ComputedContext = Readonly<{}>;
+type MachineContext = PublicContext & PrivateContext & ComputedContext;
+type MachineState = {
+    value: "idle";
+};
+type State = StateMachine.State<MachineContext, MachineState>;
+type Send = StateMachine.Send<StateMachine.AnyEventObject>;
+type RadioProps = {
+    value: string;
+    /**
+     * If `true`, the radio will be disabled
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the radio will be readonly
+     */
+    readOnly?: boolean;
+    /**
+     * If `true`, the radio is marked as invalid.
+     */
+    invalid?: boolean;
+};
+type InputProps = RadioProps & {
+    /**
+     * If `true` and `disabled` is passed, the radio will
+     * remain tabbable but not interactive
+     */
+    focusable?: boolean;
+    /**
+     * If `true`, the radio input is marked as required,
+     */
+    required?: boolean;
+};
+
+declare function connect<T extends PropTypes>(state: State, send: Send, normalize: NormalizeProps<T>): {
+    /**
+     * The current value of the radio group
+     */
+    value: string | null;
+    /**
+     * Function to set the value of the radio group
+     */
+    setValue(value: string): void;
+    /**
+     * Function to clear the value of the radio group
+     */
+    clearValue(): void;
+    /**
+     * Function to focus the radio group
+     */
+    focus: () => void;
+    /**
+     * Function to blur the currently focused radio input in the radio group
+     */
+    blur(): void;
+    /**
+     * Returns the state details of a radio input
+     */
+    getRadioState: <T_1 extends RadioProps>(props: T_1) => {
+        isInteractive: boolean;
+        isReadOnly: boolean | undefined;
+        isInvalid: boolean | undefined;
+        isDisabled: boolean | undefined;
+        isChecked: boolean;
+        isFocused: boolean;
+        isHovered: boolean;
+        isActive: boolean;
+    };
+    rootProps: T["element"];
+    labelProps: T["element"];
+    getRadioProps(props: RadioProps): T["label"];
+    getRadioLabelProps(props: RadioProps): T["element"];
+    getRadioControlProps(props: RadioProps): T["element"];
+    getRadioInputProps(props: InputProps): T["input"];
+    indicatorProps: T["element"];
+};
+
+declare function machine(userContext: UserDefinedContext): _zag_js_core.Machine<MachineContext, MachineState, _zag_js_core.StateMachine.AnyEventObject>;
+
+export { UserDefinedContext as Context, anatomy, connect, machine };

package/dist/index.d.ts

@@ -1,4 +1,136 @@
-export { anatomy } from "./radio-group.anatomy";
-export { connect } from "./radio-group.connect";
-export { machine } from "./radio-group.machine";
-export type { UserDefinedContext as Context } from "./radio-group.types";
+import * as _zag_js_anatomy from '@zag-js/anatomy';
+import { RequiredBy, DirectionProperty, CommonProperties, Context, PropTypes, NormalizeProps } from '@zag-js/types';
+import * as _zag_js_core from '@zag-js/core';
+import { StateMachine } from '@zag-js/core';
+
+declare const anatomy: _zag_js_anatomy.AnatomyInstance<"root" | "label" | "radio" | "radioLabel" | "radioControl" | "radioInput" | "indicator">;
+
+type ElementIds = Partial<{
+    root: string;
+    label: string;
+    indicator: string;
+    radio(value: string): string;
+    radioLabel(value: string): string;
+    radioControl(value: string): string;
+    radioInput(value: string): string;
+}>;
+type PublicContext = DirectionProperty & CommonProperties & {
+    /**
+     * The ids of the elements in the radio. Useful for composition.
+     */
+    ids?: ElementIds;
+    /**
+     * The value of the checked radio
+     */
+    value: string | null;
+    /**
+     * The name of the input fields in the radio
+     * (Useful for form submission).
+     */
+    name?: string;
+    /**
+     * The associate form of the underlying input.
+     */
+    form?: string;
+    /**
+     * If `true`, the radio group will be disabled
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the radio group will be readonly
+     */
+    readOnly?: boolean;
+    /**
+     * Function called once a radio is checked
+     * @param value the value of the checked radio
+     */
+    onChange?(details: {
+        value: string;
+    }): void;
+    /**
+     * Orientation of the radio group
+     */
+    orientation?: "horizontal" | "vertical";
+};
+type PrivateContext = Context<{}>;
+type UserDefinedContext = RequiredBy<PublicContext, "id">;
+type ComputedContext = Readonly<{}>;
+type MachineContext = PublicContext & PrivateContext & ComputedContext;
+type MachineState = {
+    value: "idle";
+};
+type State = StateMachine.State<MachineContext, MachineState>;
+type Send = StateMachine.Send<StateMachine.AnyEventObject>;
+type RadioProps = {
+    value: string;
+    /**
+     * If `true`, the radio will be disabled
+     */
+    disabled?: boolean;
+    /**
+     * If `true`, the radio will be readonly
+     */
+    readOnly?: boolean;
+    /**
+     * If `true`, the radio is marked as invalid.
+     */
+    invalid?: boolean;
+};
+type InputProps = RadioProps & {
+    /**
+     * If `true` and `disabled` is passed, the radio will
+     * remain tabbable but not interactive
+     */
+    focusable?: boolean;
+    /**
+     * If `true`, the radio input is marked as required,
+     */
+    required?: boolean;
+};
+
+declare function connect<T extends PropTypes>(state: State, send: Send, normalize: NormalizeProps<T>): {
+    /**
+     * The current value of the radio group
+     */
+    value: string | null;
+    /**
+     * Function to set the value of the radio group
+     */
+    setValue(value: string): void;
+    /**
+     * Function to clear the value of the radio group
+     */
+    clearValue(): void;
+    /**
+     * Function to focus the radio group
+     */
+    focus: () => void;
+    /**
+     * Function to blur the currently focused radio input in the radio group
+     */
+    blur(): void;
+    /**
+     * Returns the state details of a radio input
+     */
+    getRadioState: <T_1 extends RadioProps>(props: T_1) => {
+        isInteractive: boolean;
+        isReadOnly: boolean | undefined;
+        isInvalid: boolean | undefined;
+        isDisabled: boolean | undefined;
+        isChecked: boolean;
+        isFocused: boolean;
+        isHovered: boolean;
+        isActive: boolean;
+    };
+    rootProps: T["element"];
+    labelProps: T["element"];
+    getRadioProps(props: RadioProps): T["label"];
+    getRadioLabelProps(props: RadioProps): T["element"];
+    getRadioControlProps(props: RadioProps): T["element"];
+    getRadioInputProps(props: InputProps): T["input"];
+    indicatorProps: T["element"];
+};
+
+declare function machine(userContext: UserDefinedContext): _zag_js_core.Machine<MachineContext, MachineState, _zag_js_core.StateMachine.AnyEventObject>;
+
+export { UserDefinedContext as Context, anatomy, connect, machine };

package/dist/index.js

@@ -1,13 +1,424 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  anatomy: () => anatomy,
+  connect: () => connect,
+  machine: () => machine
+});
+module.exports = __toCommonJS(src_exports);
 
-const radioGroup_anatomy = require('./radio-group.anatomy.js');
-const radioGroup_connect = require('./radio-group.connect.js');
-const radioGroup_machine = require('./radio-group.machine.js');
+// src/radio-group.anatomy.ts
+var import_anatomy = require("@zag-js/anatomy");
+var anatomy = (0, import_anatomy.createAnatomy)("radio-group").parts(
+  "root",
+  "label",
+  "radio",
+  "radioLabel",
+  "radioControl",
+  "radioInput",
+  "indicator"
+);
+var parts = anatomy.build();
 
+// src/radio-group.connect.ts
+var import_dom_query2 = require("@zag-js/dom-query");
+var import_visually_hidden = require("@zag-js/visually-hidden");
 
+// src/radio-group.dom.ts
+var import_dom_query = require("@zag-js/dom-query");
+var dom = (0, import_dom_query.createScope)({
+  getRootId: (ctx) => ctx.ids?.root ?? `radio-group:${ctx.id}`,
+  getLabelId: (ctx) => ctx.ids?.label ?? `radio-group:${ctx.id}:label`,
+  getRadioId: (ctx, value) => ctx.ids?.radio?.(value) ?? `radio-group:${ctx.id}:radio:${value}`,
+  getRadioInputId: (ctx, value) => ctx.ids?.radioInput?.(value) ?? `radio-group:${ctx.id}:radio:input:${value}`,
+  getRadioControlId: (ctx, value) => ctx.ids?.radioControl?.(value) ?? `radio-group:${ctx.id}:radio:control:${value}`,
+  getRadioLabelId: (ctx, value) => ctx.ids?.radioLabel?.(value) ?? `radio-group:${ctx.id}:radio:label:${value}`,
+  getIndicatorId: (ctx) => ctx.ids?.indicator ?? `tabs:${ctx.id}:indicator`,
+  getRootEl: (ctx) => dom.getById(ctx, dom.getRootId(ctx)),
+  getRadioInputEl: (ctx, value) => dom.getById(ctx, dom.getRadioInputId(ctx, value)),
+  getIndicatorEl: (ctx) => dom.getById(ctx, dom.getIndicatorId(ctx)),
+  getFirstEnabledInputEl: (ctx) => dom.getRootEl(ctx)?.querySelector("input:not(:disabled)"),
+  getFirstEnabledAndCheckedInputEl: (ctx) => dom.getRootEl(ctx)?.querySelector("input:not(:disabled):checked"),
+  getInputEls: (ctx) => {
+    const ownerId = CSS.escape(dom.getRootId(ctx));
+    const selector = `input[type=radio][data-ownedby='${ownerId}']:not([disabled])`;
+    return (0, import_dom_query.queryAll)(dom.getRootEl(ctx), selector);
+  },
+  getActiveRadioEl: (ctx) => {
+    if (!ctx.value)
+      return;
+    return dom.getById(ctx, dom.getRadioId(ctx, ctx.value));
+  },
+  getOffsetRect: (el) => {
+    return {
+      left: el?.offsetLeft ?? 0,
+      top: el?.offsetTop ?? 0,
+      width: el?.offsetWidth ?? 0,
+      height: el?.offsetHeight ?? 0
+    };
+  },
+  getRectById: (ctx, id) => {
+    const tab = dom.queryById(ctx, dom.getRadioId(ctx, id));
+    return dom.resolveRect(dom.getOffsetRect(tab));
+  },
+  resolveRect(rect) {
+    return {
+      width: `${rect.width}px`,
+      height: `${rect.height}px`,
+      left: `${rect.left}px`,
+      top: `${rect.top}px`
+    };
+  }
+});
 
-exports.anatomy = radioGroup_anatomy.anatomy;
-exports.connect = radioGroup_connect.connect;
-exports.machine = radioGroup_machine.machine;
+// src/radio-group.connect.ts
+function connect(state, send, normalize) {
+  const isGroupDisabled = state.context.disabled;
+  const isGroupReadOnly = state.context.readOnly;
+  function getRadioState(props) {
+    const radioState = {
+      isReadOnly: props.readOnly || isGroupReadOnly,
+      isInvalid: props.invalid,
+      isDisabled: props.disabled || isGroupDisabled,
+      isChecked: state.context.value === props.value,
+      isFocused: state.context.focusedId === props.value,
+      isHovered: state.context.hoveredId === props.value,
+      isActive: state.context.activeId === props.value
+    };
+    return {
+      ...radioState,
+      isInteractive: !(radioState.isReadOnly || radioState.isDisabled)
+    };
+  }
+  function getRadioDataAttrs(props) {
+    const radioState = getRadioState(props);
+    return {
+      "data-focus": (0, import_dom_query2.dataAttr)(radioState.isFocused),
+      "data-disabled": (0, import_dom_query2.dataAttr)(radioState.isDisabled),
+      "data-checked": (0, import_dom_query2.dataAttr)(radioState.isChecked),
+      "data-hover": (0, import_dom_query2.dataAttr)(radioState.isHovered),
+      "data-invalid": (0, import_dom_query2.dataAttr)(radioState.isInvalid),
+      "data-readonly": (0, import_dom_query2.dataAttr)(radioState.isReadOnly)
+    };
+  }
+  const focus = () => {
+    const firstEnabledAndCheckedInput = dom.getFirstEnabledAndCheckedInputEl(state.context);
+    if (firstEnabledAndCheckedInput) {
+      firstEnabledAndCheckedInput.focus();
+      return;
+    }
+    const firstEnabledInput = dom.getFirstEnabledInputEl(state.context);
+    firstEnabledInput?.focus();
+  };
+  return {
+    /**
+     * The current value of the radio group
+     */
+    value: state.context.value,
+    /**
+     * Function to set the value of the radio group
+     */
+    setValue(value) {
+      send({ type: "SET_VALUE", value, manual: true });
+    },
+    /**
+     * Function to clear the value of the radio group
+     */
+    clearValue() {
+      send({ type: "SET_VALUE", value: null, manual: true });
+    },
+    /**
+     * Function to focus the radio group
+     */
+    focus,
+    /**
+     * Function to blur the currently focused radio input in the radio group
+     */
+    blur() {
+      const focusedElement = dom.getActiveElement(state.context);
+      const inputEls = dom.getInputEls(state.context);
+      const radioInputIsFocused = inputEls.some((el) => el === focusedElement);
+      if (radioInputIsFocused)
+        focusedElement?.blur();
+    },
+    /**
+     * Returns the state details of a radio input
+     */
+    getRadioState,
+    rootProps: normalize.element({
+      ...parts.root.attrs,
+      role: "radiogroup",
+      id: dom.getRootId(state.context),
+      "aria-labelledby": dom.getLabelId(state.context),
+      "data-orientation": state.context.orientation,
+      "aria-orientation": state.context.orientation,
+      dir: state.context.dir
+    }),
+    labelProps: normalize.element({
+      ...parts.label.attrs,
+      id: dom.getLabelId(state.context),
+      onClick: focus
+    }),
+    getRadioProps(props) {
+      const rootState = getRadioState(props);
+      return normalize.label({
+        ...parts.radio.attrs,
+        id: dom.getRadioId(state.context, props.value),
+        htmlFor: dom.getRadioInputId(state.context, props.value),
+        ...getRadioDataAttrs(props),
+        onPointerMove() {
+          if (!rootState.isInteractive)
+            return;
+          send({ type: "SET_HOVERED", value: props.value, hovered: true });
+        },
+        onPointerLeave() {
+          if (!rootState.isInteractive)
+            return;
+          send({ type: "SET_HOVERED", value: null });
+        },
+        onPointerDown(event) {
+          if (!rootState.isInteractive)
+            return;
+          if (rootState.isFocused && event.pointerType === "mouse") {
+            event.preventDefault();
+          }
+          send({ type: "SET_ACTIVE", value: props.value, active: true });
+        },
+        onPointerUp() {
+          if (!rootState.isInteractive)
+            return;
+          send({ type: "SET_ACTIVE", value: null });
+        }
+      });
+    },
+    getRadioLabelProps(props) {
+      return normalize.element({
+        ...parts.radioLabel.attrs,
+        id: dom.getRadioLabelId(state.context, props.value),
+        ...getRadioDataAttrs(props)
+      });
+    },
+    getRadioControlProps(props) {
+      const controlState = getRadioState(props);
+      return normalize.element({
+        ...parts.radioControl.attrs,
+        id: dom.getRadioControlId(state.context, props.value),
+        "data-active": (0, import_dom_query2.dataAttr)(controlState.isActive),
+        "aria-hidden": true,
+        ...getRadioDataAttrs(props)
+      });
+    },
+    getRadioInputProps(props) {
+      const inputState = getRadioState(props);
+      const isRequired = props.required;
+      const trulyDisabled = inputState.isDisabled && !props.focusable;
+      return normalize.input({
+        ...parts.radioInput.attrs,
+        "data-ownedby": dom.getRootId(state.context),
+        id: dom.getRadioInputId(state.context, props.value),
+        type: "radio",
+        name: state.context.name || state.context.id,
+        form: state.context.form,
+        value: props.value,
+        onChange(event) {
+          if (inputState.isReadOnly || inputState.isDisabled) {
+            return;
+          }
+          if (event.target.checked) {
+            send({ type: "SET_VALUE", value: props.value });
+          }
+        },
+        onBlur() {
+          send({ type: "SET_FOCUSED", value: null });
+        },
+        onFocus() {
+          send({ type: "SET_FOCUSED", value: props.value, focused: true });
+        },
+        onKeyDown(event) {
+          if (event.key === " ") {
+            send({ type: "SET_ACTIVE", value: props.value, active: true });
+          }
+        },
+        onKeyUp(event) {
+          if (event.key === " ") {
+            send({ type: "SET_ACTIVE", value: null });
+          }
+        },
+        disabled: trulyDisabled,
+        required: isRequired,
+        defaultChecked: inputState.isChecked,
+        "data-disabled": (0, import_dom_query2.dataAttr)(inputState.isDisabled),
+        "aria-required": (0, import_dom_query2.ariaAttr)(isRequired),
+        "aria-invalid": (0, import_dom_query2.ariaAttr)(inputState.isInvalid),
+        readOnly: inputState.isReadOnly,
+        "data-readonly": (0, import_dom_query2.dataAttr)(inputState.isReadOnly),
+        "aria-disabled": (0, import_dom_query2.ariaAttr)(trulyDisabled),
+        "aria-checked": (0, import_dom_query2.ariaAttr)(inputState.isChecked),
+        style: import_visually_hidden.visuallyHiddenStyle
+      });
+    },
+    indicatorProps: normalize.element({
+      id: dom.getIndicatorId(state.context),
+      ...parts.indicator.attrs,
+      "data-orientation": state.context.orientation,
+      style: {
+        "--transition-duration": "150ms",
+        "--transition-property": "left, top, width, height",
+        position: "absolute",
+        willChange: "var(--transition-property)",
+        transitionProperty: "var(--transition-property)",
+        transitionDuration: state.context.canIndicatorTransition ? "var(--transition-duration)" : "0ms",
+        transitionTimingFunction: "var(--transition-timing-function)",
+        ...state.context.indicatorRect
+      }
+    })
+  };
+}
+
+// src/radio-group.machine.ts
+var import_core = require("@zag-js/core");
+var import_dom_query3 = require("@zag-js/dom-query");
+var import_element_rect = require("@zag-js/element-rect");
+var import_form_utils = require("@zag-js/form-utils");
+var import_utils = require("@zag-js/utils");
+function machine(userContext) {
+  const ctx = (0, import_utils.compact)(userContext);
+  return (0, import_core.createMachine)(
+    {
+      id: "radio",
+      initial: "idle",
+      context: {
+        value: null,
+        activeId: null,
+        focusedId: null,
+        hoveredId: null,
+        indicatorRect: {},
+        canIndicatorTransition: false,
+        ...ctx
+      },
+      entry: ["syncIndicatorRect"],
+      exit: ["cleanupObserver"],
+      activities: ["trackFormControlState"],
+      watch: {
+        value: [
+          "setIndicatorTransition",
+          // important to set this after `setIndicatorTransition`
+          "setPreviousValue",
+          "invokeOnChange",
+          "syncIndicatorRect",
+          "syncInputElements"
+        ]
+      },
+      on: {
+        SET_VALUE: {
+          actions: ["setValue"]
+        },
+        SET_HOVERED: {
+          actions: "setHovered"
+        },
+        SET_ACTIVE: {
+          actions: "setActive"
+        },
+        SET_FOCUSED: {
+          actions: "setFocused"
+        }
+      },
+      states: {
+        idle: {}
+      }
+    },
+    {
+      activities: {
+        trackFormControlState(ctx2, _evt, { send, initialContext }) {
+          return (0, import_form_utils.trackFormControl)(dom.getRootEl(ctx2), {
+            onFieldsetDisabled() {
+              ctx2.disabled = true;
+            },
+            onFormReset() {
+              send({ type: "SET_VALUE", value: initialContext.value });
+            }
+          });
+        }
+      },
+      actions: {
+        setValue(ctx2, evt) {
+          ctx2.value = evt.value;
+        },
+        setHovered(ctx2, evt) {
+          ctx2.hoveredId = evt.value;
+        },
+        setActive(ctx2, evt) {
+          ctx2.activeId = evt.value;
+        },
+        setFocused(ctx2, evt) {
+          ctx2.focusedId = evt.value;
+        },
+        invokeOnChange(ctx2, evt) {
+          ctx2.onChange?.({ value: evt.value });
+        },
+        syncInputElements(ctx2) {
+          const inputs = dom.getInputEls(ctx2);
+          inputs.forEach((input) => {
+            input.checked = input.value === ctx2.value;
+          });
+        },
+        setIndicatorTransition(ctx2) {
+          ctx2.canIndicatorTransition = (0, import_utils.isString)(ctx2.value);
+        },
+        cleanupObserver(ctx2) {
+          ctx2.indicatorCleanup?.();
+        },
+        syncIndicatorRect(ctx2) {
+          ctx2.indicatorCleanup?.();
+          if (!dom.getIndicatorEl(ctx2))
+            return;
+          const value = ctx2.value;
+          if (value == null) {
+            ctx2.indicatorRect = {};
+            return;
+          }
+          const radioEl = dom.getActiveRadioEl(ctx2);
+          if (!radioEl)
+            return;
+          ctx2.indicatorCleanup = (0, import_element_rect.trackElementRect)(radioEl, {
+            getRect(el) {
+              return dom.getOffsetRect(el);
+            },
+            onChange(rect) {
+              ctx2.indicatorRect = dom.resolveRect(rect);
+              (0, import_dom_query3.nextTick)(() => {
+                ctx2.canIndicatorTransition = false;
+              });
+            }
+          });
+        }
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  anatomy,
+  connect,
+  machine
+});
+//# sourceMappingURL=index.js.map