@elliemae/ds-legacy-form-radio 1.0.0-rc.1

package/dist/cjs/ControlledRadio.js

@@ -0,0 +1,111 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ControlledRadio_exports = {};
+__export(ControlledRadio_exports, {
+  DSControlledRadio: () => DSControlledRadio,
+  DSControlledRadioWithSchema: () => DSControlledRadioWithSchema
+});
+module.exports = __toCommonJS(ControlledRadio_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_uid = require("uid");
+var import_ds_legacy_truncated_tooltip_text = require("@elliemae/ds-legacy-truncated-tooltip-text");
+var import_styles = require("./styles.js");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_useValidateProps = require("./config/useValidateProps.js");
+const DSControlledRadio = (props) => {
+  const propsWithDefault = (0, import_ds_legacy_props_helpers.useMemoMergePropsWithDefault)(props, import_react_desc_prop_types.defaultProps);
+  (0, import_useValidateProps.useValidateProps)(props, import_react_desc_prop_types.DSControlledRadioPropTypes);
+  const { checked, visualOnly, device, hasError, innerRef, value, wrapLabel, onChange } = propsWithDefault;
+  const handleOnChange = (0, import_react.useCallback)(
+    (e) => {
+      if (onChange && value)
+        onChange(value, e);
+    },
+    [onChange, value]
+  );
+  const handleKeyDown = (0, import_react.useCallback)(
+    (e) => {
+      if (e.key === "Enter")
+        handleOnChange(e);
+    },
+    [handleOnChange]
+  );
+  const sharedListeners = import_react.default.useMemo(
+    () => ({
+      onKeyDown: handleKeyDown
+      // we can't declare onChange here, we are "overwriting" the event,
+      //   if we put it here we invoke it twice, once with our overwritten arguments, once with the native ones
+      // onChange: handleOnChange,
+    }),
+    [handleKeyDown]
+  );
+  const { id, disabled, readOnly, label, className, ...restGlobals } = (0, import_ds_legacy_props_helpers.useGetGlobalAttributes)(
+    propsWithDefault,
+    sharedListeners
+  );
+  const instanceUid = (0, import_react.useMemo)(() => id || `ds-form-radio-${(0, import_uid.uid)(5)}`, [id]);
+  const xstyledProps = (0, import_ds_legacy_props_helpers.useGetXstyledProps)(propsWithDefault);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_styles.StyledContainer, { device, "data-testid": "ds-radio-container", className, ...xstyledProps, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_styles.StyledRadio, { device, checked, hasError, disabled, readOnly, children: !visualOnly ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_styles.StyledInput,
+      {
+        "data-testid": "ds-radio",
+        type: "radio",
+        ...sharedListeners,
+        ...restGlobals,
+        onChange: handleOnChange,
+        ref: innerRef,
+        id: instanceUid,
+        checked,
+        disabled
+      }
+    ) : null }),
+    label && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_styles.StyledLabel,
+      {
+        device,
+        htmlFor: instanceUid,
+        disabled,
+        readOnly,
+        checked,
+        "data-testid": "ds-radio-label",
+        wrapLabel,
+        children: wrapLabel ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_styles.StyledWrapLabel, { children: label }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ds_legacy_truncated_tooltip_text.SimpleTruncatedTooltipText, { value: label })
+      }
+    )
+  ] });
+};
+DSControlledRadio.propTypes = import_react_desc_prop_types.DSControlledRadioPropTypesSchema;
+DSControlledRadio.displayName = "DSControlledRadio";
+const DSControlledRadioWithSchema = (0, import_ds_legacy_props_helpers.describe)(DSControlledRadio);
+DSControlledRadioWithSchema.propTypes = import_react_desc_prop_types.DSControlledRadioPropTypesSchema;
+//# sourceMappingURL=ControlledRadio.js.map

package/dist/cjs/ControlledRadio.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ControlledRadio.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable complexity */\nimport React, { useCallback, useMemo } from 'react';\nimport {\n  describe,\n  useGetGlobalAttributes,\n  useGetXstyledProps,\n  useMemoMergePropsWithDefault,\n} from '@elliemae/ds-legacy-props-helpers';\nimport { uid } from 'uid';\nimport { SimpleTruncatedTooltipText } from '@elliemae/ds-legacy-truncated-tooltip-text';\nimport { StyledContainer, StyledWrapLabel, StyledInput, StyledLabel, StyledRadio } from './styles.js';\nimport type { DSControlledRadioT } from './react-desc-prop-types.js';\nimport { DSControlledRadioPropTypes, DSControlledRadioPropTypesSchema, defaultProps } from './react-desc-prop-types.js';\nimport { useValidateProps } from './config/useValidateProps.js';\n\nconst DSControlledRadio: React.ComponentType<DSControlledRadioT.Props> = (props) => {\n  const propsWithDefault = useMemoMergePropsWithDefault<DSControlledRadioT.InternalProps>(props, defaultProps);\n  useValidateProps(props, DSControlledRadioPropTypes);\n  const { checked, visualOnly, device, hasError, innerRef, value, wrapLabel, onChange } = propsWithDefault;\n\n  const handleOnChange = useCallback(\n    (e: React.ChangeEvent | React.KeyboardEvent) => {\n      if (onChange && value) onChange(value, e);\n    },\n    [onChange, value],\n  );\n\n  const handleKeyDown = useCallback(\n    (e: React.KeyboardEvent) => {\n      if (e.key === 'Enter') handleOnChange(e);\n    },\n    [handleOnChange],\n  );\n\n  const sharedListeners = React.useMemo(\n    () => ({\n      onKeyDown: handleKeyDown,\n      // we can't declare onChange here, we are \"overwriting\" the event,\n      //   if we put it here we invoke it twice, once with our overwritten arguments, once with the native ones\n      // onChange: handleOnChange,\n    }),\n    [handleKeyDown],\n  );\n  const { id, disabled, readOnly, label, className, ...restGlobals } = useGetGlobalAttributes<DSControlledRadioT.Props>(\n    propsWithDefault,\n    sharedListeners,\n  );\n\n  const instanceUid = useMemo(() => id || `ds-form-radio-${uid(5)}`, [id]);\n  const xstyledProps = useGetXstyledProps(propsWithDefault);\n\n  return (\n    <StyledContainer device={device} data-testid=\"ds-radio-container\" className={className} {...xstyledProps}>\n      <StyledRadio device={device} checked={checked} hasError={hasError} disabled={disabled} readOnly={readOnly}>\n        {!visualOnly ? (\n          <StyledInput\n            data-testid=\"ds-radio\"\n            type=\"radio\"\n            {...sharedListeners}\n            {...restGlobals}\n            onChange={handleOnChange}\n            ref={innerRef}\n            id={instanceUid}\n            checked={checked}\n            disabled={disabled}\n          />\n        ) : null}\n      </StyledRadio>\n      {label && (\n        <StyledLabel\n          device={device}\n          htmlFor={instanceUid}\n          disabled={disabled}\n          readOnly={readOnly}\n          checked={checked}\n          data-testid=\"ds-radio-label\"\n          wrapLabel={wrapLabel}\n        >\n          {wrapLabel ? <StyledWrapLabel>{label}</StyledWrapLabel> : <SimpleTruncatedTooltipText value={label} />}\n        </StyledLabel>\n      )}\n    </StyledContainer>\n  );\n};\n\nDSControlledRadio.propTypes = DSControlledRadioPropTypesSchema;\nDSControlledRadio.displayName = 'DSControlledRadio';\nconst DSControlledRadioWithSchema = describe(DSControlledRadio);\nDSControlledRadioWithSchema.propTypes = DSControlledRadioPropTypesSchema;\n\nexport { DSControlledRadio, DSControlledRadioWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADoDnB;AAnDJ,mBAA4C;AAC5C,qCAKO;AACP,iBAAoB;AACpB,8CAA2C;AAC3C,oBAAwF;AAExF,mCAA2F;AAC3F,8BAAiC;AAEjC,MAAM,oBAAmE,CAAC,UAAU;AAClF,QAAM,uBAAmB,6DAA+D,OAAO,yCAAY;AAC3G,gDAAiB,OAAO,uDAA0B;AAClD,QAAM,EAAE,SAAS,YAAY,QAAQ,UAAU,UAAU,OAAO,WAAW,SAAS,IAAI;AAExF,QAAM,qBAAiB;AAAA,IACrB,CAAC,MAA+C;AAC9C,UAAI,YAAY;AAAO,iBAAS,OAAO,CAAC;AAAA,IAC1C;AAAA,IACA,CAAC,UAAU,KAAK;AAAA,EAClB;AAEA,QAAM,oBAAgB;AAAA,IACpB,CAAC,MAA2B;AAC1B,UAAI,EAAE,QAAQ;AAAS,uBAAe,CAAC;AAAA,IACzC;AAAA,IACA,CAAC,cAAc;AAAA,EACjB;AAEA,QAAM,kBAAkB,aAAAA,QAAM;AAAA,IAC5B,OAAO;AAAA,MACL,WAAW;AAAA;AAAA;AAAA;AAAA,IAIb;AAAA,IACA,CAAC,aAAa;AAAA,EAChB;AACA,QAAM,EAAE,IAAI,UAAU,UAAU,OAAO,WAAW,GAAG,YAAY,QAAI;AAAA,IACnE;AAAA,IACA;AAAA,EACF;AAEA,QAAM,kBAAc,sBAAQ,MAAM,MAAM,qBAAiB,gBAAI,CAAC,KAAK,CAAC,EAAE,CAAC;AACvE,QAAM,mBAAe,mDAAmB,gBAAgB;AAExD,SACE,6CAAC,iCAAgB,QAAgB,eAAY,sBAAqB,WAAuB,GAAG,cAC1F;AAAA,gDAAC,6BAAY,QAAgB,SAAkB,UAAoB,UAAoB,UACpF,WAAC,aACA;AAAA,MAAC;AAAA;AAAA,QACC,eAAY;AAAA,QACZ,MAAK;AAAA,QACJ,GAAG;AAAA,QACH,GAAG;AAAA,QACJ,UAAU;AAAA,QACV,KAAK;AAAA,QACL,IAAI;AAAA,QACJ;AAAA,QACA;AAAA;AAAA,IACF,IACE,MACN;AAAA,IACC,SACC;AAAA,MAAC;AAAA;AAAA,QACC;AAAA,QACA,SAAS;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA,eAAY;AAAA,QACZ;AAAA,QAEC,sBAAY,4CAAC,iCAAiB,iBAAM,IAAqB,4CAAC,sEAA2B,OAAO,OAAO;AAAA;AAAA,IACtG;AAAA,KAEJ;AAEJ;AAEA,kBAAkB,YAAY;AAC9B,kBAAkB,cAAc;AAChC,MAAM,kCAA8B,yCAAS,iBAAiB;AAC9D,4BAA4B,YAAY;",
+  "names": ["React"]
+}

package/dist/cjs/config/useValidateProps.js

@@ -0,0 +1,49 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useValidateProps_exports = {};
+__export(useValidateProps_exports, {
+  useValidateProps: () => useValidateProps
+});
+module.exports = __toCommonJS(useValidateProps_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+var import_exported_related = require("../exported-related/index.js");
+const throwError = (message) => {
+  throw new Error(
+    `DSControlledRadio:: ${message}
+  `
+  );
+};
+const useValidateProps = (props, propTypes) => {
+  (0, import_ds_legacy_props_helpers.useValidateTypescriptPropTypes)(props, propTypes, import_exported_related.DSRadioName);
+  if (typeof props.label === "undefined" && typeof props["aria-label"] === "undefined") {
+    throwError(`Please provide a label or ariaLabel property to use this component.`);
+  }
+};
+//# sourceMappingURL=useValidateProps.js.map

package/dist/cjs/config/useValidateProps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useValidateProps.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useValidateTypescriptPropTypes } from '@elliemae/ds-legacy-props-helpers';\nimport { DSRadioName } from '../exported-related/index.js';\nimport type React from 'react';\nimport type { DSControlledRadioT } from '../react-desc-prop-types.js';\n\nconst throwError = (message: string): void => {\n  throw new Error(\n    `DSControlledRadio:: ${message}\n  `,\n  );\n};\n\nexport const useValidateProps = (\n  props: DSControlledRadioT.Props,\n  propTypes: React.WeakValidationMap<unknown>,\n): void => {\n  useValidateTypescriptPropTypes(props, propTypes, DSRadioName);\n  if (typeof props.label === 'undefined' && typeof props['aria-label'] === 'undefined') {\n    throwError(`Please provide a label or ariaLabel property to use this component.`);\n  }\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,qCAA+C;AAC/C,8BAA4B;AAI5B,MAAM,aAAa,CAAC,YAA0B;AAC5C,QAAM,IAAI;AAAA,IACR,uBAAuB;AAAA;AAAA,EAEzB;AACF;AAEO,MAAM,mBAAmB,CAC9B,OACA,cACS;AACT,qEAA+B,OAAO,WAAW,mCAAW;AAC5D,MAAI,OAAO,MAAM,UAAU,eAAe,OAAO,MAAM,YAAY,MAAM,aAAa;AACpF,eAAW,qEAAqE;AAAA,EAClF;AACF;",
+  "names": []
+}

package/dist/cjs/exported-related/data-test-ids.js

@@ -0,0 +1,39 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var data_test_ids_exports = {};
+__export(data_test_ids_exports, {
+  DSRadioDataTestIds: () => DSRadioDataTestIds
+});
+module.exports = __toCommonJS(data_test_ids_exports);
+var React = __toESM(require("react"));
+const DSRadioDataTestIds = {
+  CONTAINER: "ds-radio-container",
+  INPUT: "ds-radio"
+};
+//# sourceMappingURL=data-test-ids.js.map

package/dist/cjs/exported-related/data-test-ids.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/data-test-ids.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const DSRadioDataTestIds = {\n  CONTAINER: 'ds-radio-container',\n  INPUT: 'ds-radio',\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,qBAAqB;AAAA,EAChC,WAAW;AAAA,EACX,OAAO;AACT;",
+  "names": []
+}

package/dist/cjs/exported-related/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var exported_related_exports = {};
+module.exports = __toCommonJS(exported_related_exports);
+var React = __toESM(require("react"));
+__reExport(exported_related_exports, require("./data-test-ids.js"), module.exports);
+__reExport(exported_related_exports, require("./theming.js"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/exported-related/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './data-test-ids.js';\nexport * from './theming.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;ADAvB,qCAAc,+BAAd;AACA,qCAAc,yBADd;",
+  "names": []
+}

package/dist/cjs/exported-related/theming.js

@@ -0,0 +1,42 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var theming_exports = {};
+__export(theming_exports, {
+  DSRadioName: () => DSRadioName,
+  DSRadioSlots: () => DSRadioSlots
+});
+module.exports = __toCommonJS(theming_exports);
+var React = __toESM(require("react"));
+const DSRadioName = "DSRadio";
+const DSRadioSlots = {
+  CONTAINER: "root",
+  INPUT: "input",
+  LABEL: "label"
+};
+//# sourceMappingURL=theming.js.map

package/dist/cjs/exported-related/theming.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/theming.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const DSRadioName = 'DSRadio';\n\nexport const DSRadioSlots = {\n  CONTAINER: 'root',\n  INPUT: 'input',\n  LABEL: 'label',\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,cAAc;AAEpB,MAAM,eAAe;AAAA,EAC1B,WAAW;AAAA,EACX,OAAO;AAAA,EACP,OAAO;AACT;",
+  "names": []
+}

package/dist/cjs/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  DSControlledRadio: () => DSControlledRadio,
+  DSControlledRadioWithSchema: () => import_ControlledRadio2.DSControlledRadioWithSchema,
+  PresentationalRadio: () => PresentationalRadio
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_ControlledRadio = require("./ControlledRadio.js");
+var import_ControlledRadio2 = require("./ControlledRadio.js");
+__reExport(src_exports, require("./exported-related/index.js"), module.exports);
+const DSControlledRadio = ({ ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ControlledRadio.DSControlledRadio, { ...props });
+const PresentationalRadio = ({ ...props }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ControlledRadio.DSControlledRadio, { ...props, visualOnly: true });
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { DSControlledRadio as Radio } from './ControlledRadio.js';\n\nexport const DSControlledRadio = ({ ...props }) => <Radio {...props} />;\nexport const PresentationalRadio = ({ ...props }) => <Radio {...props} visualOnly />;\nexport { DSControlledRadioWithSchema } from './ControlledRadio.js';\nexport * from './exported-related/index.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADE4B;AAFnD,6BAA2C;AAI3C,IAAAA,0BAA4C;AAC5C,wBAAc,wCALd;AAEO,MAAM,oBAAoB,CAAC,EAAE,GAAG,MAAM,MAAM,4CAAC,uBAAAC,mBAAA,EAAO,GAAG,OAAO;AAC9D,MAAM,sBAAsB,CAAC,EAAE,GAAG,MAAM,MAAM,4CAAC,uBAAAA,mBAAA,EAAO,GAAG,OAAO,YAAU,MAAC;",
+  "names": ["import_ControlledRadio", "Radio"]
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ]
+}

package/dist/cjs/react-desc-prop-types.js

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_desc_prop_types_exports = {};
+__export(react_desc_prop_types_exports, {
+  DSControlledRadioPropTypes: () => DSControlledRadioPropTypes,
+  DSControlledRadioPropTypesSchema: () => DSControlledRadioPropTypesSchema,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_props_helpers = require("@elliemae/ds-legacy-props-helpers");
+const defaultProps = {
+  wrapLabel: false,
+  hasError: false,
+  checked: false,
+  disabled: false,
+  visualOnly: false,
+  device: "mediaquery"
+};
+const DSControlledRadioPropTypes = {
+  ...import_ds_legacy_props_helpers.globalAttributesPropTypes,
+  ...import_ds_legacy_props_helpers.xstyledPropTypes,
+  value: import_ds_legacy_props_helpers.PropTypes.string.description("Radio value"),
+  onChange: import_ds_legacy_props_helpers.PropTypes.func.description("Radio onchange callback").signature("((newValue: string,e:  React.ChangeEvent | React.KeyboardEvent) => void)"),
+  label: import_ds_legacy_props_helpers.PropTypes.string.description(
+    "Radio Label property. This label is also going to be used as an aria-label for screen readers."
+  ),
+  checked: import_ds_legacy_props_helpers.PropTypes.bool.description("Whether the radio is checked or not"),
+  hasError: import_ds_legacy_props_helpers.PropTypes.bool.description("Whether the radio has error or not."),
+  innerRef: import_ds_legacy_props_helpers.PropTypes.oneOfType([import_ds_legacy_props_helpers.PropTypes.func, import_ds_legacy_props_helpers.PropTypes.object]).description("Radio input ref."),
+  wrapLabel: import_ds_legacy_props_helpers.PropTypes.bool.description("Whether to wrap or truncate the label"),
+  device: import_ds_legacy_props_helpers.PropTypes.oneOf(["mobile", "desktop", "mediaquery"]).description(
+    "used for responsive designs, this controls how the styling should behave. you can force mobile/desktop styling or rely on mediaquery to auto-detect"
+  ).defaultValue("mediaquery")
+};
+const DSControlledRadioPropTypesSchema = DSControlledRadioPropTypes;
+//# sourceMappingURL=react-desc-prop-types.js.map

package/dist/cjs/react-desc-prop-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/react-desc-prop-types.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type React from 'react';\nimport type {} from '@elliemae/ds-legacy-utilities';\nimport type { GlobalAttributesT, XstyledProps, DSPropTypesSchema } from '@elliemae/ds-legacy-props-helpers';\nimport { PropTypes, globalAttributesPropTypes, xstyledPropTypes } from '@elliemae/ds-legacy-props-helpers';\nexport declare namespace DSControlledRadioT {\n  export type Devices = 'mobile' | 'desktop' | 'mediaquery';\n  export interface DefaultProps {\n    checked: boolean;\n    hasError: boolean;\n    wrapLabel: boolean;\n    disabled: boolean;\n    visualOnly: boolean;\n    device: Devices;\n  }\n  export interface RequiredProps {}\n\n  export interface OptionalProps {\n    value?: string;\n    onChange?: (newValue: string, e: React.ChangeEvent | React.KeyboardEvent) => void;\n    label?: string;\n    innerRef?: React.RefObject<HTMLInputElement>;\n  }\n\n  export interface StyledRadioT {\n    checked?: boolean;\n    readOnly?: boolean;\n    hasError?: boolean;\n    disabled?: boolean;\n    device?: Devices;\n  }\n\n  export interface Props\n    extends Partial<DefaultProps>,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof OptionalProps>,\n      XstyledProps,\n      RequiredProps {}\n\n  export interface InternalProps\n    extends DefaultProps,\n      OptionalProps,\n      Omit<GlobalAttributesT<HTMLButtonElement>, keyof DefaultProps | keyof OptionalProps>,\n      XstyledProps,\n      RequiredProps {}\n}\n\nexport const defaultProps: Partial<DSControlledRadioT.Props> = {\n  wrapLabel: false,\n  hasError: false,\n  checked: false,\n  disabled: false,\n  visualOnly: false,\n  device: 'mediaquery',\n};\n\n// Omit<DSControlledRadioT.Props, 'visualOnly'>\n//  visualOnly is an internal only prop, so we don't want to expose it in the docs\nexport const DSControlledRadioPropTypes: DSPropTypesSchema<Omit<DSControlledRadioT.Props, 'visualOnly'>> = {\n  ...globalAttributesPropTypes,\n  ...xstyledPropTypes,\n  value: PropTypes.string.description('Radio value'),\n  onChange: PropTypes.func\n    .description('Radio onchange callback')\n    .signature('((newValue: string,e:  React.ChangeEvent | React.KeyboardEvent) => void)'),\n  label: PropTypes.string.description(\n    'Radio Label property. This label is also going to be used as an aria-label for screen readers.',\n  ),\n  checked: PropTypes.bool.description('Whether the radio is checked or not'),\n  hasError: PropTypes.bool.description('Whether the radio has error or not.'),\n  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).description('Radio input ref.'),\n  wrapLabel: PropTypes.bool.description('Whether to wrap or truncate the label'),\n  device: PropTypes.oneOf(['mobile', 'desktop', 'mediaquery'])\n    .description(\n      'used for responsive designs, this controls how the styling should behave. you can force mobile/desktop styling or rely on mediaquery to auto-detect',\n    )\n    .defaultValue('mediaquery'),\n};\n\nexport const DSControlledRadioPropTypesSchema =\n  DSControlledRadioPropTypes as unknown as React.WeakValidationMap<DSControlledRadioT.Props>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADGvB,qCAAuE;AA2ChE,MAAM,eAAkD;AAAA,EAC7D,WAAW;AAAA,EACX,UAAU;AAAA,EACV,SAAS;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,QAAQ;AACV;AAIO,MAAM,6BAA8F;AAAA,EACzG,GAAG;AAAA,EACH,GAAG;AAAA,EACH,OAAO,yCAAU,OAAO,YAAY,aAAa;AAAA,EACjD,UAAU,yCAAU,KACjB,YAAY,yBAAyB,EACrC,UAAU,0EAA0E;AAAA,EACvF,OAAO,yCAAU,OAAO;AAAA,IACtB;AAAA,EACF;AAAA,EACA,SAAS,yCAAU,KAAK,YAAY,qCAAqC;AAAA,EACzE,UAAU,yCAAU,KAAK,YAAY,qCAAqC;AAAA,EAC1E,UAAU,yCAAU,UAAU,CAAC,yCAAU,MAAM,yCAAU,MAAM,CAAC,EAAE,YAAY,kBAAkB;AAAA,EAChG,WAAW,yCAAU,KAAK,YAAY,uCAAuC;AAAA,EAC7E,QAAQ,yCAAU,MAAM,CAAC,UAAU,WAAW,YAAY,CAAC,EACxD;AAAA,IACC;AAAA,EACF,EACC,aAAa,YAAY;AAC9B;AAEO,MAAM,mCACX;",
+  "names": []
+}

package/dist/cjs/styles.js

@@ -0,0 +1,170 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var styles_exports = {};
+__export(styles_exports, {
+  StyledContainer: () => StyledContainer,
+  StyledInput: () => StyledInput,
+  StyledLabel: () => StyledLabel,
+  StyledRadio: () => StyledRadio,
+  StyledWrapLabel: () => StyledWrapLabel
+});
+module.exports = __toCommonJS(styles_exports);
+var React = __toESM(require("react"));
+var import_ds_legacy_system = require("@elliemae/ds-legacy-system");
+var import_styleHelpers = require("./utils/styleHelpers.js");
+var import_exported_related = require("./exported-related/index.js");
+const StyledContainer = (0, import_ds_legacy_system.styled)("div", {
+  name: import_exported_related.DSRadioName,
+  slot: import_exported_related.DSRadioSlots.CONTAINER
+})`
+  ${({ device, theme }) => {
+  if (device === "mobile") {
+    return `    
+      grid-template-columns: 24px auto;`;
+  }
+  if (device === "mediaquery") {
+    return `
+      @media (max-width: ${theme.breakpoints.small}) {
+        grid-template-columns: 24px auto;
+      }
+      grid-template-columns: ${theme.space.xs} auto;
+  `;
+  }
+  return `
+    grid-template-columns: ${theme.space.xs} auto;
+`;
+}}
+  display: inline-grid;
+  grid-template-rows: min-content;
+  align-items: center;
+  ${import_ds_legacy_system.xStyledCommonProps}
+`;
+const StyledRadio = (0, import_ds_legacy_system.styled)("span")`
+  ${({ device, theme }) => {
+  if (device === "mobile") {
+    return `    
+      width: 24px;
+      height: 24px;`;
+  }
+  if (device === "mediaquery") {
+    return `
+        @media (max-width: ${theme.breakpoints.small}) {
+          width: 24px;
+          height: 24px;
+        }
+        width: ${theme.space.xs};
+        height: ${theme.space.xs};
+      `;
+  }
+  return `
+      width: ${theme.space.xs};
+      height: ${theme.space.xs};
+    `;
+}}
+  border: 1px solid ${({ theme, hasError }) => hasError ? theme.colors.danger[900] : theme.colors.neutral[400]};
+  border-radius: 50px;
+  position: relative;
+  background: ${({ theme, disabled }) => (0, import_styleHelpers.handleBackgroundColor)(theme, disabled)};
+  ${({ theme, checked, disabled, readOnly, hasError, device }) => (0, import_styleHelpers.handleCheckmark)(theme, checked, disabled, readOnly, hasError, false, device)}
+  &:focus-within {
+    ${({ theme, hasError, disabled }) => !disabled ? `border: 1px solid ${hasError ? theme.colors.danger[900] : theme.colors.brand[700]}; outline : 1px solid ${hasError ? theme.colors.danger[900] : theme.colors.brand[700]} ` : void 0};
+    &:hover {
+      ${({ theme, checked, disabled, readOnly, hasError, device }) => (0, import_styleHelpers.handleCheckmark)(theme, checked, disabled, readOnly, hasError, true, device)}
+    }
+  }
+  &:hover {
+    background: ${({ theme, disabled }) => !disabled ? theme.colors.brand[200] : void 0};
+    ${({ theme, hasError, disabled, readOnly }) => !hasError && !disabled && !readOnly ? ` border: 1px solid  ${theme.colors.brand[600]}` : void 0};
+  }
+`;
+const radioStyles = import_ds_legacy_system.css`
+  &:hover {
+    cursor: pointer;
+  }
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
+  opacity: 0;
+`;
+const StyledInput = (0, import_ds_legacy_system.styled)("input", {
+  name: import_exported_related.DSRadioName,
+  slot: import_exported_related.DSRadioSlots.INPUT
+})`
+  ${radioStyles}
+  &:disabled {
+    cursor: not-allowed;
+  }
+`;
+const StyledLabel = (0, import_ds_legacy_system.styled)("label", {
+  name: import_exported_related.DSRadioName,
+  slot: import_exported_related.DSRadioSlots.LABEL
+})`
+  ${({ wrapLabel, theme }) => wrapLabel ? "padding: 8px 0px 8px 8px;" : `padding-left: ${theme.space.xxs}`};
+
+  color: ${({ theme, disabled, readOnly }) => disabled || readOnly ? theme.colors.neutral[500] : theme.colors.neutral[800]};
+  font-size: 13px;
+  line-height: 1.1;
+  ${({ device, theme, wrapLabel }) => {
+  if (device === "mobile") {
+    return `    
+      font-size: 16px;
+      line-height: 1.2;
+      ${wrapLabel ? `padding: 8px 0px 8px 12px;` : `padding-left: ${theme.space.xs}`};
+      `;
+  }
+  if (device === "mediaquery") {
+    return `
+        @media (max-width: ${theme.breakpoints.small}) {
+          font-size: 16px;
+          line-height: 1.2;
+          ${wrapLabel ? `padding: 8px 0px 8px 12px;` : `padding-left: ${theme.space.xs}`};
+        }
+
+        font-size: 13px;
+        line-height: 1.1;
+      `;
+  }
+  return `
+      font-size: 13px;
+      line-height: 1.1;
+    `;
+}}
+  display: inherit;
+  width: fit-content;
+
+  ${({ disabled }) => disabled ? `&:hover {
+    cursor: not-allowed;
+  }` : `&:hover {
+    cursor: pointer;
+  }`}
+`;
+const StyledWrapLabel = (0, import_ds_legacy_system.styled)("span")``;
+//# sourceMappingURL=styles.js.map