@onereach/ui-components 8.5.0 → 8.5.1-beta.3662.0

package/dist/bundled/v3/components/OrCheckboxGroupV3/OrCheckboxGroup.js

@@ -0,0 +1,85 @@
+import { resolveComponent, openBlock, createBlock, withCtx, renderSlot, createElementBlock, Fragment, renderList } from 'vue';
+import { defineComponent, toRef } from 'vue-demi';
+import { s as script$1 } from '../OrCheckboxTreeV3-a0f303f4.js';
+import { s as script$2, F as FormGroupDirection } from '../OrFormGroupV3-53cf45ee.js';
+import { u as useProxyModelValue } from '../OrBottomSheetV3-199292db.js';
+
+var script = defineComponent({
+  name: 'OrCheckboxGroup',
+  components: {
+    OrCheckboxTree: script$1,
+    OrFormGroup: script$2
+  },
+  model: {
+    prop: 'modelValue',
+    event: 'update:modelValue'
+  },
+  props: {
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    label: {
+      type: String,
+      default: ''
+    },
+    error: {
+      type: String,
+      default: ''
+    },
+    hint: {
+      type: String,
+      default: ''
+    },
+    direction: {
+      type: String,
+      default: FormGroupDirection.Vertical
+    },
+    options: {
+      type: Array,
+      default: () => []
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, context) {
+    const proxyModelValue = useProxyModelValue(toRef(props, 'modelValue'), context.emit);
+    return {
+      proxyModelValue
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_OrCheckboxTree = resolveComponent("OrCheckboxTree");
+  const _component_OrFormGroup = resolveComponent("OrFormGroup");
+  return openBlock(), createBlock(_component_OrFormGroup, {
+    label: _ctx.label,
+    error: _ctx.error,
+    hint: _ctx.hint,
+    disabled: _ctx.disabled,
+    direction: _ctx.direction
+  }, {
+    addon: withCtx(() => [renderSlot(_ctx.$slots, "addon")]),
+    default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, option => {
+      return openBlock(), createBlock(_component_OrCheckboxTree, {
+        key: option.value,
+        modelValue: _ctx.proxyModelValue,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => _ctx.proxyModelValue = $event),
+        item: option,
+        disabled: _ctx.disabled || option.disabled,
+        collapsible: option.collapsible,
+        expanded: option.expanded
+      }, null, 8 /* PROPS */, ["modelValue", "item", "disabled", "collapsible", "expanded"]);
+    }), 128 /* KEYED_FRAGMENT */))]),
+
+    _: 3 /* FORWARDED */
+  }, 8 /* PROPS */, ["label", "error", "hint", "disabled", "direction"]);
+}
+
+script.render = render;
+script.__file = "src/components/or-checkbox-group-v3/OrCheckboxGroup.vue";
+
+export { script as default };

package/dist/bundled/v3/components/OrCheckboxGroupV3/OrCheckboxGroup.vue.d.ts

@@ -0,0 +1,73 @@
+import { PropType } from 'vue-demi';
+import { CheckboxTreeNode } from '../or-checkbox-tree-v3';
+import { FormGroupDirection } from '../or-form-group-v3';
+declare const _default: import("vue-demi").DefineComponent<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    hint: {
+        type: StringConstructor;
+        default: string;
+    };
+    direction: {
+        type: PropType<"vertical" | "horizontal">;
+        default: FormGroupDirection;
+    };
+    options: {
+        type: PropType<CheckboxTreeNode[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    proxyModelValue: import("../../hooks").UseProxyModelValueReturn<string[]>;
+}, unknown, {}, {}, import("vue-demi").ComponentOptionsMixin, import("vue-demi").ComponentOptionsMixin, {}, string, import("vue-demi").VNodeProps & import("vue-demi").AllowedComponentProps & import("vue-demi").ComponentCustomProps, Readonly<import("vue-demi").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    error: {
+        type: StringConstructor;
+        default: string;
+    };
+    hint: {
+        type: StringConstructor;
+        default: string;
+    };
+    direction: {
+        type: PropType<"vertical" | "horizontal">;
+        default: FormGroupDirection;
+    };
+    options: {
+        type: PropType<CheckboxTreeNode[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    modelValue: string[];
+    label: string;
+    error: string;
+    hint: string;
+    direction: "vertical" | "horizontal";
+    options: CheckboxTreeNode[];
+    disabled: boolean;
+}>;
+export default _default;

package/dist/bundled/v3/components/OrCheckboxGroupV3/index.d.ts

@@ -0,0 +1 @@
+export { default as OrCheckboxGroupV3 } from './OrCheckboxGroup.vue';

package/dist/bundled/v3/components/OrCheckboxGroupV3/index.js

@@ -0,0 +1 @@
+export { default as OrCheckboxGroupV3 } from './OrCheckboxGroup.js';

package/dist/bundled/v3/components/OrCheckboxTreeV3/OrCheckboxTree.js

@@ -0,0 +1 @@
+export { s as default } from '../OrCheckboxTreeV3-a0f303f4.js';

package/dist/bundled/v3/components/OrCheckboxTreeV3/OrCheckboxTree.vue.d.ts

@@ -0,0 +1,65 @@
+import { PropType } from 'vue-demi';
+import { CheckboxTreeNode } from './types';
+declare const _default: import("vue-demi").DefineComponent<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    item: {
+        type: PropType<CheckboxTreeNode>;
+        required: true;
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    rootStyles: import("vue-demi").ComputedRef<string[]>;
+    parentStyles: import("vue-demi").ComputedRef<string[]>;
+    hasChildren: import("vue-demi").ComputedRef<boolean>;
+    proxyModelValue: import("../../hooks").UseProxyModelValueReturn<string[]>;
+    isOpen: import("vue-demi").Ref<boolean>;
+    setIsOpen: (value?: boolean | undefined) => boolean;
+    isIntermediate: import("vue-demi").ComputedRef<boolean>;
+    isAllChildrenSelected: import("vue-demi").ComputedRef<boolean>;
+    isAnyChildrenSelected: import("vue-demi").ComputedRef<boolean>;
+    childrenValues: import("vue-demi").ComputedRef<any[]>;
+    handleParentClick: () => void;
+}, unknown, {}, {}, import("vue-demi").ComponentOptionsMixin, import("vue-demi").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue-demi").VNodeProps & import("vue-demi").AllowedComponentProps & import("vue-demi").ComponentCustomProps, Readonly<import("vue-demi").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    item: {
+        type: PropType<CheckboxTreeNode>;
+        required: true;
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string[];
+    collapsible: boolean;
+    disabled: boolean;
+    expanded: boolean;
+}>;
+export default _default;

package/dist/bundled/v3/components/OrCheckboxTreeV3/index.d.ts

@@ -0,0 +1,2 @@
+export { default as OrCheckboxTreeV3 } from './OrCheckboxTree.vue';
+export * from './types';

package/dist/bundled/v3/components/OrCheckboxTreeV3/index.js

@@ -0,0 +1 @@
+export { s as OrCheckboxTreeV3 } from '../OrCheckboxTreeV3-a0f303f4.js';

package/dist/bundled/v3/components/OrCheckboxTreeV3/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const CheckboxTreeRoot: string[];
+export declare const CheckboxTreeRootParent: string[];

package/dist/bundled/v3/components/OrCheckboxTreeV3/styles.js

@@ -0,0 +1 @@
+export { C as CheckboxTreeRoot, a as CheckboxTreeRootParent } from '../OrCheckboxTreeV3-a0f303f4.js';

package/dist/bundled/v3/components/OrCheckboxTreeV3/types.d.ts

@@ -0,0 +1,8 @@
+export type CheckboxTreeNode = {
+    label: string;
+    value?: string;
+    children?: CheckboxTreeNode[];
+    collapsible?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+};

package/dist/bundled/v3/components/OrCheckboxTreeV3/utils/extractChildrenValues.d.ts

@@ -0,0 +1,2 @@
+import { CheckboxTreeNode } from '../types';
+export declare function extractChildrenValues(children: CheckboxTreeNode[]): any[];

package/dist/bundled/v3/components/OrCheckboxTreeV3/utils/extractChildrenValues.js

@@ -0,0 +1,2 @@
+import '../../OrBottomSheetV3-199292db.js';
+export { e as extractChildrenValues } from '../../OrCheckboxTreeV3-a0f303f4.js';

package/dist/bundled/v3/components/OrCheckboxTreeV3-a0f303f4.js

@@ -0,0 +1,192 @@
+import { resolveComponent, openBlock, createElementBlock, normalizeClass, Fragment, createElementVNode, createBlock, withCtx, createVNode, createCommentVNode, renderList } from 'vue';
+import { defineComponent, toRefs, computed, watch } from 'vue-demi';
+import { f as flattenDeep, u as useProxyModelValue, a as useToggle } from './OrBottomSheetV3-199292db.js';
+import { s as script$1 } from './OrIconV3-85d7d26b.js';
+import { s as script$2 } from './OrCheckboxV3-25ff00db.js';
+import { s as script$3 } from './OrButtonV3-c76677b3.js';
+
+const CheckboxTreeRoot = [
+// Layout
+'flex', 'flex-col',
+// Spacing
+'gap-sm+ md:gap-sm'];
+const CheckboxTreeRootParent = [
+// Layout
+'flex', 'flex-row', 'gap-xs'];
+
+const getChildValues = children => {
+  return children === null || children === void 0 ? void 0 : children.map(child => {
+    if (child.disabled) {
+      return undefined;
+    }
+    if (child.children) {
+      return getChildValues(child.children);
+    } else {
+      return child.value;
+    }
+  });
+};
+function extractChildrenValues(children) {
+  return flattenDeep(getChildValues(children)).filter(Boolean);
+}
+
+var script = defineComponent({
+  name: 'OrCheckboxTree',
+  components: {
+    OrIcon: script$1,
+    OrCheckbox: script$2,
+    OrButton: script$3
+  },
+  model: {
+    prop: 'modelValue',
+    event: 'update:modelValue'
+  },
+  props: {
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    item: {
+      type: Object,
+      required: true
+    },
+    collapsible: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    expanded: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ['update:modelValue'],
+  setup(props, context) {
+    // State
+    const {
+      modelValue,
+      item,
+      expanded
+    } = toRefs(props);
+    const children = computed(() => item.value.children || []);
+    const hasChildren = computed(() => children.value.length > 0);
+    const childrenValues = computed(() => {
+      return hasChildren.value ? extractChildrenValues(children.value) : [];
+    });
+    const proxyModelValue = useProxyModelValue(modelValue, context.emit);
+    const isAnyChildrenSelected = computed(() => {
+      var _a;
+      return (_a = proxyModelValue.value) === null || _a === void 0 ? void 0 : _a.some(value => {
+        var _a;
+        return (_a = childrenValues.value) === null || _a === void 0 ? void 0 : _a.includes(value);
+      });
+    });
+    const isAllChildrenSelected = computed(() => {
+      var _a;
+      return (_a = childrenValues.value) === null || _a === void 0 ? void 0 : _a.every(value => {
+        var _a;
+        return (_a = proxyModelValue.value) === null || _a === void 0 ? void 0 : _a.includes(value);
+      });
+    });
+    const isIntermediate = computed(() => {
+      return isAnyChildrenSelected.value && !isAllChildrenSelected.value;
+    });
+    const [isOpen, setIsOpen] = useToggle(expanded.value);
+    watch(expanded, value => {
+      if (value !== undefined) {
+        setIsOpen(value);
+      }
+    });
+    // Styles
+    const rootStyles = computed(() => ['or-checkbox-tree-v3', ...CheckboxTreeRoot]);
+    // Styles
+    const parentStyles = computed(() => [...CheckboxTreeRootParent]);
+    // Methods
+    const handleParentClick = () => {
+      if (isAllChildrenSelected.value) {
+        proxyModelValue.value = proxyModelValue.value.filter(value => !childrenValues.value.includes(value));
+      } else {
+        proxyModelValue.value = [...new Set([...proxyModelValue.value, ...childrenValues.value])];
+      }
+    };
+    return {
+      rootStyles,
+      parentStyles,
+      hasChildren,
+      proxyModelValue,
+      isOpen,
+      setIsOpen,
+      isIntermediate,
+      isAllChildrenSelected,
+      isAnyChildrenSelected,
+      childrenValues,
+      handleParentClick
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_OrIcon = resolveComponent("OrIcon");
+  const _component_OrButton = resolveComponent("OrButton");
+  const _component_OrCheckbox = resolveComponent("OrCheckbox");
+  const _component_OrCheckboxTree = resolveComponent("OrCheckboxTree", true);
+  return openBlock(), createElementBlock("div", {
+    ref: "root",
+    class: normalizeClass(_ctx.rootStyles)
+  }, [_ctx.hasChildren ? (openBlock(), createElementBlock(Fragment, {
+    key: 0
+  }, [createElementVNode("div", {
+    class: normalizeClass(_ctx.parentStyles)
+  }, [_ctx.collapsible ? (openBlock(), createBlock(_component_OrButton, {
+    key: 0,
+    variant: "link",
+    disabled: _ctx.disabled,
+    onClick: _cache[0] || (_cache[0] = () => _ctx.setIsOpen(!_ctx.isOpen))
+  }, {
+    default: withCtx(() => [createVNode(_component_OrIcon, {
+      class: normalizeClass([_ctx.isOpen ? 'rotate-[180deg]' : 'rotate-0']),
+      icon: "arrow_drop_down",
+      size: "l"
+    }, null, 8 /* PROPS */, ["class"])]),
+    _: 1 /* STABLE */
+  }, 8 /* PROPS */, ["disabled"])) : createCommentVNode("v-if", true), createVNode(_component_OrCheckbox, {
+    value: "true",
+    "model-value": _ctx.isAllChildrenSelected,
+    indeterminate: _ctx.isIntermediate,
+    label: _ctx.item.label,
+    disabled: _ctx.disabled,
+    onClick: _ctx.handleParentClick
+  }, null, 8 /* PROPS */, ["model-value", "indeterminate", "label", "disabled", "onClick"])], 2 /* CLASS */), _ctx.hasChildren && _ctx.isOpen ? (openBlock(), createElementBlock("div", {
+    key: 0,
+    class: normalizeClass({
+      'ml-2xl': _ctx.collapsible,
+      'ml-lg': !_ctx.collapsible
+    })
+  }, [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.item.children, child => {
+    return openBlock(), createBlock(_component_OrCheckboxTree, {
+      key: child.value || child.label,
+      modelValue: _ctx.proxyModelValue,
+      "onUpdate:modelValue": _cache[1] || (_cache[1] = $event => _ctx.proxyModelValue = $event),
+      class: "mt-xs",
+      item: child,
+      collapsible: child.collapsible,
+      expanded: child.expanded,
+      disabled: _ctx.disabled || child.disabled
+    }, null, 8 /* PROPS */, ["modelValue", "item", "collapsible", "expanded", "disabled"]);
+  }), 128 /* KEYED_FRAGMENT */))], 2 /* CLASS */)) : createCommentVNode("v-if", true)], 64 /* STABLE_FRAGMENT */)) : (openBlock(), createBlock(_component_OrCheckbox, {
+    key: 1,
+    modelValue: _ctx.proxyModelValue,
+    "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => _ctx.proxyModelValue = $event),
+    disabled: _ctx.disabled || _ctx.item.disabled,
+    label: _ctx.item.label,
+    value: _ctx.item.value
+  }, null, 8 /* PROPS */, ["modelValue", "disabled", "label", "value"]))], 2 /* CLASS */);
+}
+
+script.render = render;
+script.__file = "src/components/or-checkbox-tree-v3/OrCheckboxTree.vue";
+
+export { CheckboxTreeRoot as C, CheckboxTreeRootParent as a, extractChildrenValues as e, script as s };

package/dist/bundled/v3/components/OrCheckboxV3/OrCheckbox.js

@@ -0,0 +1 @@
+export { s as default } from '../OrCheckboxV3-25ff00db.js';

package/dist/bundled/v3/components/OrCheckboxV3/OrCheckbox.vue.d.ts

@@ -0,0 +1,90 @@
+import { PropType } from 'vue-demi';
+import { LabelVariant } from '../or-label-v3';
+declare const _default: import("vue-demi").DefineComponent<{
+    modelValue: {
+        type: any;
+        default: null;
+    };
+    value: {
+        type: PropType<string | number | boolean | object>;
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    labelVariant: {
+        type: PropType<"input" | "toggle" | "menu-item">;
+        default: LabelVariant;
+    };
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    root: import("vue-demi").Ref<HTMLElement | undefined>;
+    control: import("vue-demi").Ref<HTMLInputElement | undefined>;
+    rootStyles: import("vue-demi").ComputedRef<string[]>;
+    controlStyles: import("vue-demi").ComputedRef<string[]>;
+    controlAttributes: {
+        readonly: boolean | undefined;
+        disabled: boolean | undefined;
+        'force-state': string | undefined;
+        id: string | undefined;
+    };
+    isChecked: import("vue-demi").ComputedRef<boolean>;
+    handleChange: () => void;
+    focus: () => void;
+    blur: () => void;
+}, unknown, {}, {}, import("vue-demi").ComponentOptionsMixin, import("vue-demi").ComponentOptionsMixin, ("update:modelValue" | "click" | "focus" | "blur")[], "update:modelValue" | "click" | "focus" | "blur", import("vue-demi").VNodeProps & import("vue-demi").AllowedComponentProps & import("vue-demi").ComponentCustomProps, Readonly<import("vue-demi").ExtractPropTypes<{
+    modelValue: {
+        type: any;
+        default: null;
+    };
+    value: {
+        type: PropType<string | number | boolean | object>;
+        default: null;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    labelVariant: {
+        type: PropType<"input" | "toggle" | "menu-item">;
+        default: LabelVariant;
+    };
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClick?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: any;
+    value: string | number | boolean | object;
+    label: string;
+    labelVariant: "input" | "toggle" | "menu-item";
+    indeterminate: boolean;
+    required: boolean;
+    disabled: boolean;
+}>;
+export default _default;

package/dist/bundled/v3/components/OrCheckboxV3/index.d.ts

@@ -0,0 +1 @@
+export { default as OrCheckboxV3 } from './OrCheckbox.vue';

package/dist/bundled/v3/components/OrCheckboxV3/index.js

@@ -0,0 +1 @@
+export { s as OrCheckboxV3 } from '../OrCheckboxV3-25ff00db.js';

package/dist/bundled/v3/components/OrCheckboxV3/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const CheckboxRoot: string[];
+export declare const CheckboxControl: string[];
+export declare const CheckboxControlHandle: string[];

package/dist/bundled/v3/components/OrCheckboxV3/styles.js

@@ -0,0 +1 @@
+export { a as CheckboxControl, b as CheckboxControlHandle, C as CheckboxRoot } from '../OrCheckboxV3-25ff00db.js';