@zag-js/radio-group 0.1.6 → 0.1.7

package/dist/radio-group.machine.js

@@ -0,0 +1,317 @@
+"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);
+
+// src/radio-group.machine.ts
+var radio_group_machine_exports = {};
+__export(radio_group_machine_exports, {
+  machine: () => machine
+});
+module.exports = __toCommonJS(radio_group_machine_exports);
+var import_core = require("@zag-js/core");
+
+// ../../utilities/core/src/guard.ts
+var isArray = (v) => Array.isArray(v);
+var isObject = (v) => !(v == null || typeof v !== "object" || isArray(v));
+
+// ../../utilities/core/src/object.ts
+function compact(obj) {
+  if (obj === void 0)
+    return obj;
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => value !== void 0).map(([key, value]) => [key, isObject(value) ? compact(value) : value])
+  );
+}
+
+// ../../utilities/dom/src/query.ts
+function isDocument(el) {
+  return el.nodeType === Node.DOCUMENT_NODE;
+}
+function isWindow(value) {
+  return (value == null ? void 0 : value.toString()) === "[object Window]";
+}
+function getDocument(el) {
+  var _a;
+  if (isWindow(el))
+    return el.document;
+  if (isDocument(el))
+    return el;
+  return (_a = el == null ? void 0 : el.ownerDocument) != null ? _a : document;
+}
+function getWindow(el) {
+  var _a;
+  return (_a = el == null ? void 0 : el.ownerDocument.defaultView) != null ? _a : window;
+}
+function defineDomHelpers(helpers) {
+  const dom2 = {
+    getRootNode: (ctx) => {
+      var _a, _b;
+      return (_b = (_a = ctx.getRootNode) == null ? void 0 : _a.call(ctx)) != null ? _b : document;
+    },
+    getDoc: (ctx) => getDocument(dom2.getRootNode(ctx)),
+    getWin: (ctx) => {
+      var _a;
+      return (_a = dom2.getDoc(ctx).defaultView) != null ? _a : window;
+    },
+    getActiveElement: (ctx) => dom2.getDoc(ctx).activeElement,
+    getById: (ctx, id) => dom2.getRootNode(ctx).getElementById(id),
+    createEmitter: (ctx, target) => {
+      const win = dom2.getWin(ctx);
+      return function emit(evt, detail, options) {
+        const { bubbles = true, cancelable, composed = true } = options != null ? options : {};
+        const eventName = `zag:${evt}`;
+        const init = { bubbles, cancelable, composed, detail };
+        const event = new win.CustomEvent(eventName, init);
+        target.dispatchEvent(event);
+      };
+    },
+    createListener: (target) => {
+      return function listen(evt, handler) {
+        const eventName = `zag:${evt}`;
+        const listener = (e) => handler(e);
+        target.addEventListener(eventName, listener);
+        return () => target.removeEventListener(eventName, listener);
+      };
+    }
+  };
+  return {
+    ...dom2,
+    ...helpers
+  };
+}
+
+// ../../utilities/dom/src/mutation-observer.ts
+function observeAttributes(node, attributes, fn) {
+  if (!node)
+    return;
+  const attrs = Array.isArray(attributes) ? attributes : [attributes];
+  const win = node.ownerDocument.defaultView || window;
+  const obs = new win.MutationObserver((changes) => {
+    for (const change of changes) {
+      if (change.type === "attributes" && change.attributeName && attrs.includes(change.attributeName)) {
+        fn(change);
+      }
+    }
+  });
+  obs.observe(node, { attributes: true, attributeFilter: attrs });
+  return () => obs.disconnect();
+}
+
+// ../../utilities/dom/src/nodelist.ts
+function queryAll(root, selector) {
+  var _a;
+  return Array.from((_a = root == null ? void 0 : root.querySelectorAll(selector)) != null ? _a : []);
+}
+
+// ../../utilities/form-utils/src/input-event.ts
+function getDescriptor(el, options) {
+  var _a;
+  const { type, property = "value" } = options;
+  const proto = getWindow(el)[type].prototype;
+  return (_a = Object.getOwnPropertyDescriptor(proto, property)) != null ? _a : {};
+}
+function dispatchInputCheckedEvent(el, checked) {
+  var _a;
+  if (!el)
+    return;
+  const win = getWindow(el);
+  if (!(el instanceof win.HTMLInputElement))
+    return;
+  const desc = getDescriptor(el, { type: "HTMLInputElement", property: "checked" });
+  (_a = desc.set) == null ? void 0 : _a.call(el, checked);
+  const event = new win.Event("click", { bubbles: true });
+  el.dispatchEvent(event);
+}
+
+// ../../utilities/form-utils/src/form.ts
+function getClosestForm(el) {
+  if (isFormElement(el))
+    return el.form;
+  else
+    return el.closest("form");
+}
+function isFormElement(el) {
+  return el.matches("textarea, input, select, button");
+}
+function trackFormReset(el, callback) {
+  if (!el)
+    return;
+  const form = getClosestForm(el);
+  form == null ? void 0 : form.addEventListener("reset", callback, { passive: true });
+  return () => {
+    form == null ? void 0 : form.removeEventListener("reset", callback);
+  };
+}
+function trackFieldsetDisabled(el, callback) {
+  const fieldset = el == null ? void 0 : el.closest("fieldset");
+  if (!fieldset)
+    return;
+  callback(fieldset.disabled);
+  return observeAttributes(fieldset, ["disabled"], () => callback(fieldset.disabled));
+}
+function trackFormControl(el, options) {
+  if (!el)
+    return;
+  const { onFieldsetDisabled, onFormReset } = options;
+  const cleanups = [
+    trackFormReset(el, onFormReset),
+    trackFieldsetDisabled(el, (disabled) => {
+      if (disabled)
+        onFieldsetDisabled();
+    })
+  ];
+  return () => {
+    cleanups.forEach((cleanup) => cleanup == null ? void 0 : cleanup());
+  };
+}
+
+// src/radio-group.dom.ts
+var dom = defineDomHelpers({
+  getRootId: (ctx) => {
+    var _a, _b;
+    return (_b = (_a = ctx.ids) == null ? void 0 : _a.root) != null ? _b : `radio-group:${ctx.id}`;
+  },
+  getLabelId: (ctx) => {
+    var _a, _b;
+    return (_b = (_a = ctx.ids) == null ? void 0 : _a.label) != null ? _b : `radio-group:${ctx.id}:label`;
+  },
+  getRadioId: (ctx, value) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ctx.ids) == null ? void 0 : _a.radio) == null ? void 0 : _b.call(_a, value)) != null ? _c : `radio-group:${ctx.id}:radio:${value}`;
+  },
+  getRadioInputId: (ctx, value) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ctx.ids) == null ? void 0 : _a.radioInput) == null ? void 0 : _b.call(_a, value)) != null ? _c : `radio-group:${ctx.id}:radio:input:${value}`;
+  },
+  getRadioControlId: (ctx, value) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ctx.ids) == null ? void 0 : _a.radioControl) == null ? void 0 : _b.call(_a, value)) != null ? _c : `radio-group:${ctx.id}:radio:control:${value}`;
+  },
+  getRadioLabelId: (ctx, value) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = ctx.ids) == null ? void 0 : _a.radioLabel) == null ? void 0 : _b.call(_a, value)) != null ? _c : `radio-group:${ctx.id}:radio:label:${value}`;
+  },
+  getRootEl: (ctx) => dom.getById(ctx, dom.getRootId(ctx)),
+  getRadioInputEl: (ctx, value) => dom.getById(ctx, dom.getRadioInputId(ctx, value)),
+  getFirstEnabledInputEl: (ctx) => {
+    var _a;
+    return (_a = dom.getRootEl(ctx)) == null ? void 0 : _a.querySelector("input:not(:disabled)");
+  },
+  getFirstEnabledAndCheckedInputEl: (ctx) => {
+    var _a;
+    return (_a = dom.getRootEl(ctx)) == null ? void 0 : _a.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 queryAll(dom.getRootEl(ctx), selector);
+  }
+});
+
+// src/radio-group.machine.ts
+function machine(userContext) {
+  const ctx = compact(userContext);
+  return (0, import_core.createMachine)(
+    {
+      id: "radio",
+      initial: "unknown",
+      context: {
+        value: null,
+        initialValue: null,
+        activeId: null,
+        focusedId: null,
+        hoveredId: null,
+        ...ctx
+      },
+      activities: ["trackFormControlState"],
+      on: {
+        SET_VALUE: {
+          actions: ["setValue"]
+        },
+        SET_HOVERED: {
+          actions: "setHovered"
+        },
+        SET_ACTIVE: {
+          actions: "setActive"
+        },
+        SET_FOCUSED: {
+          actions: "setFocused"
+        }
+      },
+      watch: {
+        value: ["dispatchChangeEvent", "invokeOnChange"]
+      },
+      states: {
+        unknown: {
+          on: {
+            SETUP: {
+              actions: "checkValue"
+            }
+          }
+        }
+      }
+    },
+    {
+      activities: {
+        trackFormControlState(ctx2, _evt, { send }) {
+          return trackFormControl(dom.getRootEl(ctx2), {
+            onFieldsetDisabled() {
+              ctx2.disabled = true;
+            },
+            onFormReset() {
+              send({ type: "SET_VALUE", value: ctx2.initialValue });
+            }
+          });
+        }
+      },
+      actions: {
+        checkValue(ctx2) {
+          ctx2.initialValue = ctx2.value;
+        },
+        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) {
+          var _a;
+          (_a = ctx2.onChange) == null ? void 0 : _a.call(ctx2, { value: evt.value });
+        },
+        dispatchChangeEvent(ctx2, evt) {
+          if (!evt.manual)
+            return;
+          const el = dom.getRadioInputEl(ctx2, evt.value);
+          if (!el)
+            return;
+          dispatchInputCheckedEvent(el, !!evt.value);
+        }
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  machine
+});

package/dist/radio-group.machine.mjs

@@ -0,0 +1,7 @@
+import {
+  machine
+} from "./chunk-EQKWEHJW.mjs";
+import "./chunk-JSIZLP57.mjs";
+export {
+  machine
+};

package/dist/radio-group.types.d.ts

@@ -0,0 +1,86 @@
+import { StateMachine } from '@zag-js/core';
+import { RequiredBy, DirectionProperty, CommonProperties, Context } from '@zag-js/types';
+
+type ElementIds = Partial<{
+    root: string;
+    label: 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: "unknown";
+};
+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;
+};
+
+export { InputProps, MachineContext, MachineState, RadioProps, Send, State, UserDefinedContext };

package/dist/radio-group.types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/radio-group.types.ts
+var radio_group_types_exports = {};
+module.exports = __toCommonJS(radio_group_types_exports);

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "@zag-js/radio-group",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Core logic for the radio group widget implemented as a state machine",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
   "keywords": [
     "js",
     "machine",
@@ -30,19 +27,32 @@
     "url": "https://github.com/chakra-ui/zag/issues"
   },
   "dependencies": {
-    "@zag-js/anatomy": "0.1.2",
-    "@zag-js/core": "0.2.3",
-    "@zag-js/types": "0.3.1"
+    "@zag-js/anatomy": "0.1.3",
+    "@zag-js/core": "0.2.4",
+    "@zag-js/types": "0.3.2"
   },
   "devDependencies": {
-    "@zag-js/dom-utils": "0.2.1",
-    "@zag-js/form-utils": "0.2.2",
-    "@zag-js/utils": "0.3.1"
+    "clean-package": "2.2.0",
+    "@zag-js/dom-utils": "0.2.2",
+    "@zag-js/form-utils": "0.2.3",
+    "@zag-js/utils": "0.3.2"
+  },
+  "clean-package": "../../../clean-package.config.json",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "build-fast": "tsup src/index.ts --format=esm,cjs",
+    "build-fast": "tsup src",
     "start": "pnpm build --watch",
-    "build": "tsup src/index.ts --format=esm,cjs --dts",
+    "build": "tsup src --dts",
     "test": "jest --config ../../../jest.config.js --rootDir . --passWithNoTests",
     "lint": "eslint src --ext .ts,.tsx",
     "test-ci": "pnpm test --ci --runInBand",