@onereach/ui-components 20.1.0 → 20.1.2

package/dist/esm/components/or-popover-v3/index.js

@@ -0,0 +1,442 @@
+import { p, t as te, n as ne, J } from '../OrAutocompleteV3-8c6de221.js';
+import { computed, unref, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly, defineComponent, toRefs, toRef, resolveComponent, openBlock, createBlock, withCtx, withDirectives, createElementVNode, createElementBlock, mergeProps, renderSlot, normalizeClass, vShow, createCommentVNode } from 'vue';
+import { computePosition, offset, shift, flip, hide, size, autoUpdate } from '@floating-ui/dom';
+import { onClickOutside } from '@vueuse/core';
+import { OrBottomSheetV3 as script$1 } from '../or-bottom-sheet-v3/index.js';
+import { OrTeleportV3 as script$2 } from '../or-teleport-v3/index.js';
+import '@onereach/styles/screens.json';
+import '@onereach/styles/tailwind.config.json';
+import 'lodash/get';
+import 'lodash/isElement';
+import '../or-error-v3/index.js';
+import '../or-hint-v3/index.js';
+import '../or-icon-button-v3/index.js';
+import '../or-icon-v3/index.js';
+import '../or-tooltip-v3/index.js';
+import './index.js';
+import '../or-input-box-v3/index.js';
+import '../or-input-v3/index.js';
+import '../OrInlineInputV3-061441a3.js';
+import '../or-inline-input-box-v3/index.js';
+import '../or-text-v3/index.js';
+import '../or-label-v3/index.js';
+import '../or-loader-v3/index.js';
+import '../or-menu-item-v3/index.js';
+import '../or-overlay-v3/index.js';
+import '../or-tag-input-v3/index.js';
+import '../or-tags-v3/index.js';
+import '../or-button-v3/index.js';
+import '../or-tag-v3/index.js';
+
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+function getDPR(element) {
+  if (typeof window === 'undefined') {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+function unwrapElement(element) {
+  var _a;
+  return (_a = element === null || element === void 0 ? void 0 : element.$el) !== null && _a !== void 0 ? _a : element;
+}
+function useFloating(reference, floating, options = {}) {
+  const whileElementsMountedOption = options.whileElementsMounted;
+  const openOption = computed(() => {
+    var _a;
+    return (_a = unref(options.open)) !== null && _a !== void 0 ? _a : true;
+  });
+  const middlewareOption = computed(() => unref(options.middleware));
+  const placementOption = computed(() => {
+    var _a;
+    return (_a = unref(options.placement)) !== null && _a !== void 0 ? _a : 'bottom';
+  });
+  const strategyOption = computed(() => {
+    var _a;
+    return (_a = unref(options.strategy)) !== null && _a !== void 0 ? _a : 'absolute';
+  });
+  const transformOption = computed(() => {
+    var _a;
+    return (_a = unref(options.transform)) !== null && _a !== void 0 ? _a : true;
+  });
+  const referenceElement = computed(() => unwrapElement(reference.value));
+  const floatingElement = computed(() => unwrapElement(floating.value));
+  const x = ref(0);
+  const y = ref(0);
+  const strategy = ref(strategyOption.value);
+  const placement = ref(placementOption.value);
+  const middlewareData = shallowRef({});
+  const isPositioned = ref(false);
+  const floatingStyles = computed(() => {
+    const initialStyles = {
+      position: strategy.value,
+      left: '0',
+      top: '0'
+    };
+    if (!floatingElement.value) {
+      return initialStyles;
+    }
+    const xVal = roundByDPR(floatingElement.value, x.value);
+    const yVal = roundByDPR(floatingElement.value, y.value);
+    if (transformOption.value) {
+      return {
+        ...initialStyles,
+        transform: `translate(${xVal}px, ${yVal}px)`,
+        ...(getDPR(floatingElement.value) >= 1.5 && {
+          willChange: 'transform'
+        })
+      };
+    }
+    return {
+      position: strategy.value,
+      left: `${xVal}px`,
+      top: `${yVal}px`
+    };
+  });
+  let whileElementsMountedCleanup;
+  function update() {
+    if (referenceElement.value == null || floatingElement.value == null) {
+      return;
+    }
+    computePosition(referenceElement.value, floatingElement.value, {
+      middleware: middlewareOption.value,
+      placement: placementOption.value,
+      strategy: strategyOption.value
+    }).then(position => {
+      x.value = position.x;
+      y.value = position.y;
+      strategy.value = position.strategy;
+      placement.value = position.placement;
+      middlewareData.value = position.middlewareData;
+      isPositioned.value = true;
+    });
+  }
+  function cleanup() {
+    if (typeof whileElementsMountedCleanup === 'function') {
+      whileElementsMountedCleanup();
+      whileElementsMountedCleanup = undefined;
+    }
+  }
+  function attach() {
+    cleanup();
+    if (whileElementsMountedOption === undefined) {
+      update();
+      return;
+    }
+    if (referenceElement.value != null && floatingElement.value != null) {
+      whileElementsMountedCleanup = whileElementsMountedOption(referenceElement.value, floatingElement.value, update);
+      return;
+    }
+  }
+  function reset() {
+    if (!openOption.value) {
+      isPositioned.value = false;
+    }
+  }
+  watch([middlewareOption, placementOption, strategyOption], update, {
+    flush: 'sync'
+  });
+  watch([referenceElement, floatingElement], attach, {
+    flush: 'sync'
+  });
+  watch(openOption, reset, {
+    flush: 'sync'
+  });
+  if (getCurrentScope()) {
+    onScopeDispose(cleanup);
+  }
+  return {
+    x: shallowReadonly(x),
+    y: shallowReadonly(y),
+    strategy: shallowReadonly(strategy),
+    placement: shallowReadonly(placement),
+    middlewareData: shallowReadonly(middlewareData),
+    isPositioned: shallowReadonly(isPositioned),
+    floatingStyles,
+    update
+  };
+}
+
+var PopoverVariant;
+(function (PopoverVariant) {
+  PopoverVariant["Auto"] = "auto";
+  PopoverVariant["Popover"] = "popover";
+  PopoverVariant["BottomSheet"] = "bottom-sheet";
+})(PopoverVariant || (PopoverVariant = {}));
+var PopoverPlacement;
+(function (PopoverPlacement) {
+  PopoverPlacement["Top"] = "top";
+  PopoverPlacement["TopStart"] = "top-start";
+  PopoverPlacement["TopEnd"] = "top-end";
+  PopoverPlacement["Bottom"] = "bottom";
+  PopoverPlacement["BottomStart"] = "bottom-start";
+  PopoverPlacement["BottomEnd"] = "bottom-end";
+  PopoverPlacement["Left"] = "left";
+  PopoverPlacement["LeftStart"] = "left-start";
+  PopoverPlacement["LeftEnd"] = "left-end";
+  PopoverPlacement["Right"] = "right";
+  PopoverPlacement["RightStart"] = "right-start";
+  PopoverPlacement["RightEnd"] = "right-end";
+})(PopoverPlacement || (PopoverPlacement = {}));
+
+const Popover = [
+// Position
+'absolute'];
+const PopoverBody = [
+// Shape
+'rounded-md',
+// Spacing
+'mx-sm', 'my-sm',
+// Elevation
+'shadow-contextual', 'dark:shadow-contextual-dark',
+// Theme
+'theme-background-default', 'dark:theme-background-default-dark', 'theme-foreground-default', 'dark:theme-foreground-default-dark'];
+const PopoverBodyPlacements = {
+  [PopoverPlacement.Top]: [
+  // Spacing
+  'mb-0'],
+  [PopoverPlacement.TopStart]: [
+  // Spacing
+  'mb-0', 'ml-0'],
+  [PopoverPlacement.TopEnd]: [
+  // Spacing
+  'mb-0', 'mr-0'],
+  [PopoverPlacement.Bottom]: [
+  // Spacing
+  'mt-0'],
+  [PopoverPlacement.BottomStart]: [
+  // Spacing
+  'mt-0', 'ml-0'],
+  [PopoverPlacement.BottomEnd]: [
+  // Spacing
+  'mt-0', 'mr-0'],
+  [PopoverPlacement.Left]: [
+  // Spacing
+  'mr-0'],
+  [PopoverPlacement.LeftStart]: [
+  // Spacing
+  'mr-0', 'mt-0'],
+  [PopoverPlacement.LeftEnd]: [
+  // Spacing
+  'mr-0', 'mb-0'],
+  [PopoverPlacement.Right]: [
+  // Spacing
+  'ml-0'],
+  [PopoverPlacement.RightStart]: [
+  // Spacing
+  'ml-0', 'mt-0'],
+  [PopoverPlacement.RightEnd]: [
+  // Spacing
+  'ml-0', 'mb-0']
+};
+
+function isPrevented(path, trigger) {
+  return path.some(element => {
+    const {
+      classList
+    } = element;
+    if (!p(element, trigger)) {
+      if (classList === null || classList === void 0 ? void 0 : classList.contains('or-popover-v3')) {
+        return true;
+      }
+      if (classList === null || classList === void 0 ? void 0 : classList.contains('or-bottom-sheet-v3')) {
+        return true;
+      }
+      if (classList === null || classList === void 0 ? void 0 : classList.contains('or-confirm-v3')) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+var script = defineComponent({
+  name: 'OrPopover',
+  components: {
+    OrBottomSheet: script$1,
+    OrTeleport: script$2
+  },
+  inheritAttrs: false,
+  props: {
+    // @workaround for Vue 2
+    customStyles: {
+      type: Array,
+      default: () => []
+    },
+    isOpen: {
+      type: Boolean,
+      default: false
+    },
+    variant: {
+      type: String,
+      default: () => PopoverVariant.Auto
+    },
+    bottomSheetProps: {
+      type: Object,
+      default: undefined
+    },
+    trigger: {
+      type: Object,
+      default: undefined
+    },
+    placement: {
+      type: String,
+      default: () => PopoverPlacement.Bottom
+    },
+    fallbackPlacement: {
+      type: String,
+      default: 'end'
+    },
+    hideOptions: {
+      type: Object,
+      default: undefined
+    },
+    offset: {
+      type: [Number, Object, Function],
+      default: 8
+    },
+    fullWidth: {
+      type: Boolean,
+      default: false
+    },
+    disableDefaultStyles: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ['update:state', 'open', 'close'],
+  expose: ['root', 'state', 'isFlipped', 'isHidden', 'open', 'close', 'toggle', 'bottomSheet'],
+  setup(props, context) {
+    // Refs
+    const root = ref();
+    const containerRoot = ref();
+    const bottomSheet = ref();
+    const bottomSheetRoot = computed(() => {
+      var _a;
+      return (_a = bottomSheet.value) === null || _a === void 0 ? void 0 : _a.root;
+    });
+    const {
+      trigger,
+      placement,
+      offset: offset$1,
+      fullWidth,
+      hideOptions
+    } = toRefs(props);
+    // Styles
+    const rootStyles = computed(() => ['or-popover-v3', ...Popover, ...('class' in context.attrs ? [] : props.customStyles)]);
+    const bodyStyles = computed(() => [...PopoverBody, ...PopoverBodyPlacements[placement.value]]);
+    // State
+    const {
+      state,
+      open,
+      close,
+      toggle
+    } = te(toRef(props, 'isOpen'), context.emit);
+    const {
+      floatingStyles,
+      middlewareData,
+      placement: computedPlacement
+    } = useFloating(trigger, root, {
+      placement,
+      middleware: [offset(offset$1.value), shift(), flip(() => ({
+        fallbackAxisSideDirection: props.fallbackPlacement
+      })), hide(hideOptions.value), size({
+        apply({
+          rects,
+          elements
+        }) {
+          if (fullWidth.value) {
+            Object.assign(elements.floating.style, {
+              width: `${rects.reference.width}px`
+            });
+          }
+        }
+      })],
+      whileElementsMounted(...args) {
+        return autoUpdate(...args, {
+          animationFrame: true
+        });
+      }
+    });
+    const isFlipped = computed(() => computedPlacement.value !== placement.value);
+    const isHidden = computed(() => {
+      var _a;
+      return Boolean((_a = middlewareData.value.hide) === null || _a === void 0 ? void 0 : _a.referenceHidden);
+    });
+    // Helpers
+    const {
+      isDesktop,
+      isMobile
+    } = ne(containerRoot);
+    // #region Elevation
+    J(root, state);
+    // #endregion
+    // #region Click Outside
+    onClickOutside(root, event => {
+      if (state.value === 'open' && !isPrevented(event.composedPath(), props.trigger)) {
+        close();
+      }
+    }, {
+      ignore: [trigger]
+    });
+    // #endregion
+    return {
+      root,
+      containerRoot,
+      bottomSheet,
+      bottomSheetRoot,
+      rootStyles,
+      bodyStyles,
+      floatingStyles,
+      state,
+      isFlipped,
+      isHidden,
+      isDesktop,
+      isMobile,
+      open,
+      close,
+      toggle
+    };
+  }
+});
+
+const _hoisted_1 = {
+  ref: 'containerRoot',
+  class: /*#__PURE__*/normalizeClass(['contents'])
+};
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_OrBottomSheet = resolveComponent("OrBottomSheet");
+  const _component_OrTeleport = resolveComponent("OrTeleport");
+  return openBlock(), createBlock(_component_OrTeleport, null, {
+    default: withCtx(() => [withDirectives(createElementVNode("div", _hoisted_1, [_ctx.isDesktop && _ctx.variant === 'auto' || _ctx.variant === 'popover' ? withDirectives((openBlock(), createElementBlock("div", mergeProps({
+      key: 0
+    }, _ctx.$attrs, {
+      ref: 'root',
+      class: _ctx.rootStyles,
+      style: _ctx.floatingStyles
+    }), [_ctx.disableDefaultStyles ? renderSlot(_ctx.$slots, "default", {
+      key: 0
+    }) : (openBlock(), createElementBlock("div", {
+      key: 1,
+      class: normalizeClass(_ctx.bodyStyles)
+    }, [renderSlot(_ctx.$slots, "default")], 2 /* CLASS */))], 16 /* FULL_PROPS */)), [[vShow, !_ctx.isHidden]]) : createCommentVNode("v-if", true), _ctx.isMobile && _ctx.variant === 'auto' || _ctx.variant === 'bottom-sheet' ? (openBlock(), createBlock(_component_OrBottomSheet, mergeProps({
+      key: 1,
+      ref: 'bottomSheet'
+    }, _ctx.bottomSheetProps, {
+      "is-open": _ctx.state === 'open',
+      "onUpdate:state": _cache[0] || (_cache[0] = $event => $event === 'open' ? _ctx.open() : _ctx.close())
+    }), {
+      default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+      _: 3 /* FORWARDED */
+    }, 16 /* FULL_PROPS */, ["is-open"])) : createCommentVNode("v-if", true)], 512 /* NEED_PATCH */), [[vShow, _ctx.state === 'open']])]),
+    _: 3 /* FORWARDED */
+  });
+}
+
+script.render = render;
+script.__file = "src/components/or-popover-v3/OrPopover.vue";
+
+export { script as OrPopoverV3, PopoverPlacement, PopoverVariant, isPrevented };

package/dist/{esm-deps → esm}/components/or-progress-v3/index.js

@@ -1,10 +1,33 @@
+import { defineComponent, ref, useSlots, computed, openBlock, createElementBlock, normalizeClass, Fragment, renderSlot, createElementVNode, createTextVNode, toDisplayString, createCommentVNode } from 'vue';
 import { useElementBounding } from '@vueuse/core';
 import round from 'lodash/round';
-import { defineComponent, ref, useSlots, computed } from 'vue';
-import { n as ne } from '../../useValidationAttributes-DxhcSj_h-3380c3cf.js';
-import '../../dom-CwV-xS38-5babad01.js';
+import { n as ne } from '../OrAutocompleteV3-8c6de221.js';
+import '@onereach/styles/screens.json';
+import '@onereach/styles/tailwind.config.json';
 import 'lodash/get';
 import 'lodash/isElement';
+import '../or-error-v3/index.js';
+import '../or-hint-v3/index.js';
+import '../or-icon-button-v3/index.js';
+import '../or-icon-v3/index.js';
+import '../or-tooltip-v3/index.js';
+import '../or-popover-v3/index.js';
+import '@floating-ui/dom';
+import '../or-bottom-sheet-v3/index.js';
+import '../or-overlay-v3/index.js';
+import '../or-teleport-v3/index.js';
+import '../or-input-box-v3/index.js';
+import '../or-input-v3/index.js';
+import '../OrInlineInputV3-061441a3.js';
+import '../or-inline-input-box-v3/index.js';
+import '../or-text-v3/index.js';
+import '../or-label-v3/index.js';
+import '../or-loader-v3/index.js';
+import '../or-menu-item-v3/index.js';
+import '../or-tag-input-v3/index.js';
+import '../or-tags-v3/index.js';
+import '../or-button-v3/index.js';
+import '../or-tag-v3/index.js';
 
 var ProgressColor;
 (function (ProgressColor) {
@@ -208,4 +231,79 @@ var script = defineComponent({
   }
 });
 
+const _hoisted_1 = {
+  width: "100%",
+  height: "2"
+};
+const _hoisted_2 = {
+  fill: "none",
+  "stroke-width": "2",
+  "stroke-linecap": "round"
+};
+const _hoisted_3 = ["x2"];
+const _hoisted_4 = ["x2", "stroke-dasharray", "stroke-dashoffset"];
+const _hoisted_5 = ["width", "height"];
+const _hoisted_6 = {
+  fill: "none",
+  "stroke-width": "2",
+  "stroke-linecap": "round"
+};
+const _hoisted_7 = ["stroke-dasharray", "stroke-dashoffset"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    ref: 'root',
+    class: normalizeClass(_ctx.rootStyles)
+  }, [_ctx.isLinearType ? (openBlock(), createElementBlock(Fragment, {
+    key: 0
+  }, [_ctx.isShowingHeader ? (openBlock(), createElementBlock("div", {
+    key: 0,
+    class: normalizeClass(_ctx.headerStyles)
+  }, [renderSlot(_ctx.$slots, "header", {}, () => [createElementVNode("div", {
+    class: normalizeClass(_ctx.labelStyles)
+  }, [renderSlot(_ctx.$slots, "label")], 2 /* CLASS */), createElementVNode("div", {
+    class: normalizeClass(_ctx.percentStyles)
+  }, [renderSlot(_ctx.$slots, "percent", {
+    value: _ctx.percent
+  }, () => [createTextVNode(toDisplayString(_ctx.percent), 1 /* TEXT */)])], 2 /* CLASS */)])], 2 /* CLASS */)) : createCommentVNode("v-if", true), (openBlock(), createElementBlock("svg", _hoisted_1, [createElementVNode("g", _hoisted_2, [createElementVNode("line", {
+    class: normalizeClass(_ctx.progressBarBackgroundStyles),
+    x1: "2",
+    y1: "50%",
+    x2: _ctx.strokeWidth,
+    y2: "50%"
+  }, null, 10 /* CLASS, PROPS */, _hoisted_3), createElementVNode("line", {
+    class: normalizeClass(_ctx.progressBarMainPartStyles),
+    x1: "2",
+    y1: "50%",
+    x2: _ctx.strokeWidth,
+    y2: "50%",
+    "stroke-dasharray": _ctx.strokeDasharray,
+    "stroke-dashoffset": _ctx.strokeDashoffset
+  }, null, 10 /* CLASS, PROPS */, _hoisted_4)])])), _ctx.isShowingFooter ? (openBlock(), createElementBlock("div", {
+    key: 1,
+    class: normalizeClass(_ctx.footerStyles)
+  }, [renderSlot(_ctx.$slots, "footer", {
+    value: _ctx.localValue
+  })], 2 /* CLASS */)) : createCommentVNode("v-if", true)], 64 /* STABLE_FRAGMENT */)) : _ctx.isCircleType ? (openBlock(), createElementBlock("svg", {
+    key: 1,
+    viewBox: "0 0 16 16",
+    width: _ctx.computedSize,
+    height: _ctx.computedSize
+  }, [createElementVNode("g", _hoisted_6, [createElementVNode("circle", {
+    class: normalizeClass(_ctx.progressBarBackgroundStyles),
+    cx: "50%",
+    cy: "50%",
+    r: "7"
+  }, null, 2 /* CLASS */), createElementVNode("circle", {
+    class: normalizeClass(_ctx.progressBarMainPartStyles),
+    cx: "50%",
+    cy: "50%",
+    r: "7",
+    "stroke-dasharray": _ctx.strokeDasharray,
+    "stroke-dashoffset": _ctx.strokeDashoffset
+  }, null, 10 /* CLASS, PROPS */, _hoisted_7)])], 8 /* PROPS */, _hoisted_5)) : createCommentVNode("v-if", true)], 2 /* CLASS */);
+}
+
+script.render = render;
+script.__file = "src/components/or-progress-v3/OrProgress.vue";
+
 export { script as OrProgressV3, ProgressColor, ProgressType };

package/dist/esm/components/or-radio-group-v3/index.js

@@ -0,0 +1,116 @@
+import { defineComponent, toRef, resolveComponent, openBlock, createBlock, withCtx, renderSlot, createElementBlock, Fragment, renderList } from 'vue';
+import { r as re } from '../OrAutocompleteV3-8c6de221.js';
+import { OrFormGroupV3 as script$1, FormGroupDirection } from '../or-form-group-v3/index.js';
+import { OrRadioV3 as script$2 } from '../or-radio-v3/index.js';
+import '@vueuse/core';
+import '@onereach/styles/screens.json';
+import '@onereach/styles/tailwind.config.json';
+import 'lodash/get';
+import 'lodash/isElement';
+import '../or-error-v3/index.js';
+import '../or-hint-v3/index.js';
+import '../or-icon-button-v3/index.js';
+import '../or-icon-v3/index.js';
+import '../or-tooltip-v3/index.js';
+import '../or-popover-v3/index.js';
+import '@floating-ui/dom';
+import '../or-bottom-sheet-v3/index.js';
+import '../or-overlay-v3/index.js';
+import '../or-teleport-v3/index.js';
+import '../or-input-box-v3/index.js';
+import '../or-input-v3/index.js';
+import '../OrInlineInputV3-061441a3.js';
+import '../or-inline-input-box-v3/index.js';
+import '../or-text-v3/index.js';
+import '../or-label-v3/index.js';
+import '../or-loader-v3/index.js';
+import '../or-menu-item-v3/index.js';
+import '../or-tag-input-v3/index.js';
+import '../or-tags-v3/index.js';
+import '../or-button-v3/index.js';
+import '../or-tag-v3/index.js';
+
+var script = defineComponent({
+  name: 'OrRadioGroup',
+  components: {
+    OrFormGroup: script$1,
+    OrRadio: script$2
+  },
+  model: {
+    prop: 'modelValue',
+    event: 'update:modelValue'
+  },
+  props: {
+    modelValue: {
+      type: undefined,
+      default: undefined
+    },
+    options: {
+      type: Array,
+      default: () => []
+    },
+    direction: {
+      type: String,
+      default: () => FormGroupDirection.Vertical
+    },
+    label: {
+      type: String,
+      default: undefined
+    },
+    hint: {
+      type: String,
+      default: undefined
+    },
+    error: {
+      type: String,
+      default: undefined
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    readonly: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ['update:modelValue'],
+  setup(props, context) {
+    // State
+    const proxyModelValue = re(toRef(props, 'modelValue'), context.emit);
+    return {
+      proxyModelValue
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_OrRadio = resolveComponent("OrRadio");
+  const _component_OrFormGroup = resolveComponent("OrFormGroup");
+  return openBlock(), createBlock(_component_OrFormGroup, {
+    direction: _ctx.direction,
+    label: _ctx.label,
+    hint: _ctx.hint,
+    error: _ctx.error,
+    disabled: _ctx.disabled
+  }, {
+    addon: withCtx(() => [renderSlot(_ctx.$slots, "addon")]),
+    default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, option => {
+      return openBlock(), createBlock(_component_OrRadio, {
+        key: option.label,
+        modelValue: _ctx.proxyModelValue,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => _ctx.proxyModelValue = $event),
+        value: option.value,
+        label: option.label,
+        disabled: _ctx.disabled || option.disabled,
+        readonly: _ctx.readonly || option.readonly
+      }, null, 8 /* PROPS */, ["modelValue", "value", "label", "disabled", "readonly"]);
+    }), 128 /* KEYED_FRAGMENT */))]),
+    _: 3 /* FORWARDED */
+  }, 8 /* PROPS */, ["direction", "label", "hint", "error", "disabled"]);
+}
+
+script.render = render;
+script.__file = "src/components/or-radio-group-v3/OrRadioGroup.vue";
+
+export { script as OrRadioGroupV3 };