@onereach/ui-components 4.10.1 → 4.10.2-beta.2933.0

package/dist/esm/v2/OrTree-9db9d3d3.js

@@ -0,0 +1,428 @@
+import { defineComponent, ref, computed, watch, unref, onMounted } from 'vue-demi';
+import { useToggle } from '@vueuse/core';
+import { _ as __vue_component__$2 } from './OrButton-9622e713.js';
+import { _ as __vue_component__$3 } from './OrIcon-d35a84d8.js';
+import { n as normalizeComponent } from './normalize-component-6e8e3d80.js';
+
+var TreeNodeDropPosition;
+(function (TreeNodeDropPosition) {
+  TreeNodeDropPosition["Top"] = "top";
+  TreeNodeDropPosition["Bottom"] = "bottom";
+  TreeNodeDropPosition["Middle"] = "middle";
+})(TreeNodeDropPosition || (TreeNodeDropPosition = {}));
+
+function inRange(num, min, max) {
+  return num >= min && num <= max;
+}
+function getDropOffset(e) {
+  let canMiddleDrop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  const {
+    clientY
+  } = e;
+  const {
+    top,
+    height
+  } = e.target.getBoundingClientRect();
+  const offset = (clientY - top) / height;
+  if (canMiddleDrop && inRange(offset, 0.4, 0.7)) {
+    return TreeNodeDropPosition.Middle;
+  } else if (inRange(offset, 0, 0.5)) {
+    return TreeNodeDropPosition.Top;
+  }
+  return TreeNodeDropPosition.Bottom;
+}
+function applyPadding(element, level, hasCollapseTrigger) {
+  const padding = level * 20 - (hasCollapseTrigger ? 20 : 0);
+  Object.assign(element.style, {
+    paddingLeft: `${padding}px`
+  });
+}
+
+const TreeNodeRoot = [];
+const TreeNodeItemRoot = [
+// Layout
+'layout-row', 'py-xs', '!items-start',
+// Theme
+'hover:bg-primary-opacity-0-08', 'dark:hover:bg-primary-opacity-0-08-dark', 'selected:bg-primary-opacity-0-08', 'dark:selected:bg-primary-opacity-0-08-dark', 'selected:hover:bg-primary-opacity-0-16', 'dark:selected:hover:bg-primary-opacity-0-16-dark'];
+const TreeNodeDragIndicator = [
+// Layout
+'absolute h-[2px] w-full left-[0px]',
+// Theme
+'bg-primary',
+// Interaction
+'pointer-events-none'];
+const TreeNodeDragIndicatorPosition = {
+  top: ['top-[-1px]'],
+  middle: ['top-[0px]', 'left-[0px]', 'w-[2px]', '!h-full'],
+  bottom: ['bottom-[-1px]']
+};
+
+var script$1 = defineComponent({
+  name: 'OrTreeNode',
+  components: {
+    OrButton: __vue_component__$2,
+    OrIcon: __vue_component__$3
+  },
+  props: {
+    node: {
+      type: Object,
+      required: true
+    },
+    collapsible: {
+      type: Boolean,
+      default: false
+    },
+    selected: {
+      type: Boolean,
+      default: undefined
+    },
+    expanded: {
+      type: Boolean,
+      default: true
+    },
+    depth: {
+      type: Number,
+      default: 1
+    },
+    draggable: {
+      type: Boolean,
+      default: null
+    }
+  },
+  emits: ['drop', 'dragstart', 'click', 'expand', 'collapse', 'contextmenu'],
+  setup(props, _ref) {
+    let {
+      emit
+    } = _ref;
+    // Refs
+    const root = ref(null);
+    const nodeRoot = ref(null);
+    // State
+    const isDragOver = ref(false);
+    const isDrag = ref(false);
+    const dragPosition = ref('top');
+    const hasChildren = computed(() => !!props.node.children && props.node.children.length > 0);
+    const [isOpen, setIsOpen] = useToggle(props.expanded);
+    const hasCollapseTrigger = computed(() => props.collapsible && hasChildren.value);
+    const isLeaf = computed(() => !hasChildren.value);
+    // Effects
+    watch(() => props.depth, value => {
+      applyPadding(unref(nodeRoot), value, hasCollapseTrigger.value);
+    });
+    watch(() => props.expanded, value => {
+      if (value !== undefined) {
+        setIsOpen(value);
+      }
+    }, {
+      immediate: true
+    });
+    onMounted(() => {
+      applyPadding(unref(nodeRoot), props.depth, hasCollapseTrigger.value);
+    });
+    // Methods
+    const handleDrop = e => {
+      var _a;
+      const nodeKey = (_a = e === null || e === void 0 ? void 0 : e.dataTransfer) === null || _a === void 0 ? void 0 : _a.getData('node-key');
+      isDragOver.value = false;
+      emit('drop', {
+        dropKey: props.node.key,
+        dragKey: nodeKey,
+        dropPosition: dragPosition.value
+      });
+    };
+    const handleDragStart = e => {
+      var _a;
+      isDrag.value = true;
+      setIsOpen(false);
+      (_a = e === null || e === void 0 ? void 0 : e.dataTransfer) === null || _a === void 0 ? void 0 : _a.setData('node-key', props.node.key);
+      emit('dragstart', props.node.key);
+    };
+    const handleDragOver = e => {
+      e.preventDefault();
+      e.stopPropagation();
+      dragPosition.value = getDropOffset(e, props.node.canMiddleDrop);
+      isDragOver.value = true;
+    };
+    const handleDragLeave = e => {
+      e.preventDefault();
+      e.stopPropagation();
+      isDragOver.value = false;
+    };
+    const handleContextMenu = e => {
+      e.preventDefault();
+      emit('contextmenu', {
+        $event: e,
+        nodeKey: props.node.key
+      });
+    };
+    const handleClick = e => {
+      e.preventDefault();
+      emit('click', props.node.key);
+    };
+    const handleCollapse = () => {
+      if (isOpen.value) {
+        setIsOpen(false);
+        emit('collapse', props.node.key);
+      } else {
+        setIsOpen(true);
+        emit('expand', props.node.key);
+      }
+    };
+    // Styles
+    const rootStyles = computed(() => ['or-tree-node-v3', ...TreeNodeRoot]);
+    const nodeStyles = computed(() => [...TreeNodeItemRoot, 'relative']);
+    const dragIndicatorStyles = computed(() => [...TreeNodeDragIndicator, ...TreeNodeDragIndicatorPosition[dragPosition.value]]);
+    return {
+      root,
+      isOpen,
+      isLeaf,
+      rootStyles,
+      nodeStyles,
+      dragIndicatorStyles,
+      setIsOpen,
+      nodeRoot,
+      isDrag,
+      dragPosition,
+      handleDragStart,
+      handleDrop,
+      handleCollapse,
+      handleContextMenu,
+      handleClick,
+      handleDragOver,
+      handleDragLeave,
+      hasCollapseTrigger,
+      isDragOver
+    };
+  }
+});
+
+/* script */
+const __vue_script__$1 = script$1;
+
+/* template */
+var __vue_render__$1 = function () {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c('div', {
+    ref: "root",
+    staticClass: "or-tree-node-v3"
+  }, [_c('div', {
+    ref: "nodeRoot",
+    class: _vm.nodeStyles,
+    attrs: {
+      "draggable": _vm.draggable ? true : undefined,
+      "selected": _vm.selected ? true : undefined
+    },
+    on: {
+      "dragend": function ($event) {
+        _vm.isDrag = false;
+      },
+      "dragstart": function ($event) {
+        $event.stopPropagation();
+        return _vm.handleDragStart.apply(null, arguments);
+      },
+      "dragover": function ($event) {
+        $event.preventDefault();
+        return _vm.handleDragOver.apply(null, arguments);
+      },
+      "dragenter": function ($event) {
+        $event.preventDefault();
+        return _vm.handleDragOver.apply(null, arguments);
+      },
+      "dragleave": _vm.handleDragLeave,
+      "drop": _vm.handleDrop,
+      "click": _vm.handleClick,
+      "contextmenu": _vm.handleContextMenu
+    }
+  }, [_vm.hasCollapseTrigger ? [_c('OrButton', {
+    attrs: {
+      "variant": "link"
+    },
+    on: {
+      "click": function ($event) {
+        $event.stopPropagation();
+        return _vm.handleCollapse.apply(null, arguments);
+      }
+    }
+  }, [_c('OrIcon', {
+    class: [_vm.isOpen ? 'rotate-90' : 'rotate-0'],
+    attrs: {
+      "icon": "arrow_right",
+      "size": "l"
+    }
+  })], 1)] : _vm._e(), _vm._v(" "), _vm._t("node", function () {
+    return [_vm._v("\n      " + _vm._s(_vm.node.key) + "\n    ")];
+  }, null, {
+    node: _vm.node,
+    isOpen: _vm.isOpen,
+    isLeaf: _vm.isLeaf,
+    isDrag: _vm.isDrag,
+    isDragOver: _vm.isDragOver,
+    depth: _vm.depth
+  }), _vm._v(" "), _vm.isDragOver && !_vm.isDrag ? _c('div', {
+    class: _vm.dragIndicatorStyles
+  }) : _vm._e()], 2), _vm._v(" "), !_vm.isLeaf && _vm.isOpen ? _vm._l(_vm.node.children, function (child) {
+    return _c('OrTreeNode', {
+      key: child.key,
+      attrs: {
+        "node": child,
+        "collapsible": _vm.collapsible || child.collapsible,
+        "depth": _vm.depth + 1,
+        "selected": _vm.selected || child.selected,
+        "draggable": !child.hasOwnProperty('draggable') || child.draggable === null ? _vm.draggable : child.draggable
+      },
+      on: {
+        "drop": function ($event) {
+          return _vm.$emit('drop', $event);
+        },
+        "dragstart": function ($event) {
+          return _vm.$emit('dragstart', $event);
+        },
+        "click": function ($event) {
+          return _vm.$emit('click', $event);
+        },
+        "expand": function ($event) {
+          return _vm.$emit('expand', $event);
+        },
+        "collapse": function ($event) {
+          return _vm.$emit('collapse', $event);
+        },
+        "contextmenu": function ($event) {
+          return _vm.$emit('contextmenu', $event);
+        }
+      },
+      scopedSlots: _vm._u([{
+        key: "node",
+        fn: function (props) {
+          return [_vm._t("node", null, null, props)];
+        }
+      }], null, true)
+    });
+  }) : _vm._e()], 2);
+};
+var __vue_staticRenderFns__$1 = [];
+
+/* style */
+const __vue_inject_styles__$1 = undefined;
+/* scoped */
+const __vue_scope_id__$1 = undefined;
+/* module identifier */
+const __vue_module_identifier__$1 = undefined;
+/* functional template */
+const __vue_is_functional_template__$1 = false;
+/* style inject */
+
+/* style inject SSR */
+
+/* style inject shadow dom */
+
+const __vue_component__$1 = /*#__PURE__*/normalizeComponent({
+  render: __vue_render__$1,
+  staticRenderFns: __vue_staticRenderFns__$1
+}, __vue_inject_styles__$1, __vue_script__$1, __vue_scope_id__$1, __vue_is_functional_template__$1, __vue_module_identifier__$1, false, undefined, undefined, undefined);
+
+var script = defineComponent({
+  name: 'OrTree',
+  components: {
+    OrTreeNode: __vue_component__$1
+  },
+  props: {
+    nodes: {
+      type: Array,
+      default: () => []
+    },
+    collapsible: {
+      type: Boolean,
+      default: false
+    },
+    draggable: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ['drop', 'dragstart', 'click', 'expand', 'collapse', 'contextmenu'],
+  setup() {
+    // Refs
+    const root = ref(null);
+    // Styles
+    const rootStyles = computed(() => ['or-tree-v3']);
+    return {
+      root,
+      rootStyles
+    };
+  }
+});
+
+/* script */
+const __vue_script__ = script;
+
+/* template */
+var __vue_render__ = function () {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c('div', {
+    ref: "root",
+    class: _vm.rootStyles
+  }, _vm._l(_vm.nodes, function (item) {
+    return _c('OrTreeNode', {
+      key: item.key,
+      attrs: {
+        "node": item,
+        "collapsible": _vm.collapsible || item.collapsible,
+        "expanded": item.expanded,
+        "selected": item.selected,
+        "draggable": !item.hasOwnProperty('draggable') || item.draggable === null ? _vm.draggable : item.draggable
+      },
+      on: {
+        "drop": function ($event) {
+          return _vm.$emit('drop', $event);
+        },
+        "dragstart": function ($event) {
+          return _vm.$emit('dragstart', $event);
+        },
+        "click": function ($event) {
+          return _vm.$emit('click', $event);
+        },
+        "collapse": function ($event) {
+          return _vm.$emit('collapse', $event);
+        },
+        "expand": function ($event) {
+          return _vm.$emit('expand', $event);
+        },
+        "contextmenu": function ($event) {
+          return _vm.$emit('contextmenu', $event);
+        }
+      },
+      scopedSlots: _vm._u([{
+        key: "node",
+        fn: function (props) {
+          return [_vm._t("node", null, null, props)];
+        }
+      }], null, true)
+    });
+  }), 1);
+};
+var __vue_staticRenderFns__ = [];
+
+/* style */
+const __vue_inject_styles__ = undefined;
+/* scoped */
+const __vue_scope_id__ = undefined;
+/* module identifier */
+const __vue_module_identifier__ = undefined;
+/* functional template */
+const __vue_is_functional_template__ = false;
+/* style inject */
+
+/* style inject SSR */
+
+/* style inject shadow dom */
+
+const __vue_component__ = /*#__PURE__*/normalizeComponent({
+  render: __vue_render__,
+  staticRenderFns: __vue_staticRenderFns__
+}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);
+
+export { TreeNodeDropPosition as T, __vue_component__ as _ };

package/dist/esm/v2/components/index.d.ts

@@ -104,3 +104,4 @@ export * from './or-toast';
 export * from './or-toast-v3';
 export * from './or-tooltip';
 export * from './or-tooltip-v3';
+export * from './or-tree-v3';

package/dist/esm/v2/components/index.js

@@ -118,6 +118,7 @@ export { p as PropsV3, a as useQueueV3, u as useToastV3 } from '../useToast-a133
 export { _ as OrTooltip } from '../OrTooltip-0bbf1ed5.js';
 export { _ as OrTooltipContent } from '../OrTooltipContent-57a25502.js';
 export { _ as OrTooltipV3 } from '../OrTooltip-bf4c725c.js';
+export { _ as OrTreeV3, T as TreeNodeDropPosition } from '../OrTree-9db9d3d3.js';
 import 'vue-demi';
 import '../style-inject.es-4c6f2515.js';
 import '../normalize-component-6e8e3d80.js';

package/dist/esm/v2/components/or-tree-v3/OrTree.vue.d.ts

@@ -0,0 +1,52 @@
+import { PropType } from 'vue-demi';
+import { TreeNode } from './types';
+declare const _default: import("vue2").ComponentOptions<import("vue2").default, import("@vue/composition-api").ShallowUnwrapRef<{
+    root: import("@vue/composition-api").Ref<HTMLElement | null>;
+    rootStyles: import("@vue/composition-api").ComputedRef<string[]>;
+}> & import("@vue/composition-api").Data, {}, {}, {
+    nodes: {
+        type: PropType<TreeNode[]>;
+        default: () => never[];
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, import("@vue/composition-api").ExtractPropTypes<{
+    nodes: {
+        type: PropType<TreeNode[]>;
+        default: () => never[];
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Omit<import("vue2").VueConstructor<import("vue2").default>, never> & (new (...args: any[]) => import("@vue/composition-api").ComponentRenderProxy<{
+    nodes: TreeNode[];
+    collapsible: boolean;
+    draggable: boolean;
+} & {} & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, import("@vue/composition-api").ShallowUnwrapRef<{
+    root: import("@vue/composition-api").Ref<HTMLElement | null>;
+    rootStyles: import("@vue/composition-api").ComputedRef<string[]>;
+}>, import("@vue/composition-api").Data, {}, {}, {}, {}, string[], {
+    nodes: TreeNode[];
+    collapsible: boolean;
+    draggable: boolean;
+} & {} & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    nodes: TreeNode[];
+    collapsible: boolean;
+    draggable: boolean;
+}, true>);
+export default _default;

package/dist/esm/v2/components/or-tree-v3/index.d.ts

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

package/dist/esm/v2/components/or-tree-v3/index.js

@@ -0,0 +1,7 @@
+export { _ as OrTreeV3, T as TreeNodeDropPosition } from '../../OrTree-9db9d3d3.js';
+import 'vue-demi';
+import '@vueuse/core';
+import '../../OrButton-9622e713.js';
+import '../../OrLoader-b0c381f9.js';
+import '../../normalize-component-6e8e3d80.js';
+import '../../OrIcon-d35a84d8.js';

package/dist/esm/v2/components/or-tree-v3/partials/or-tree-node/OrTreeNode.vue.d.ts

@@ -0,0 +1,118 @@
+import { PropType } from 'vue-demi';
+import { TreeNode } from '../../types';
+declare const _default: import("vue").ComponentOptions<import("vue").default, import("@vue/composition-api").ShallowUnwrapRef<{
+    root: import("@vue/composition-api").Ref<HTMLElement | null>;
+    isOpen: import("@vue/composition-api").Ref<boolean>;
+    isLeaf: import("@vue/composition-api").ComputedRef<boolean>;
+    rootStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    nodeStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    dragIndicatorStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    setIsOpen: (value?: boolean | undefined) => boolean;
+    nodeRoot: import("@vue/composition-api").Ref<HTMLElement | null>;
+    isDrag: import("@vue/composition-api").Ref<boolean>;
+    dragPosition: import("@vue/composition-api").Ref<"top" | "bottom" | "middle">;
+    handleDragStart: (e: DragEvent) => void;
+    handleDrop: (e: DragEvent) => void;
+    handleCollapse: () => void;
+    handleContextMenu: (e: MouseEvent) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleDragOver: (e: DragEvent) => void;
+    handleDragLeave: (e: DragEvent) => void;
+    hasCollapseTrigger: import("@vue/composition-api").ComputedRef<boolean>;
+    isDragOver: import("@vue/composition-api").Ref<boolean>;
+}> & import("@vue/composition-api").Data, {}, {}, {
+    node: {
+        type: PropType<TreeNode>;
+        required: true;
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}, import("@vue/composition-api").ExtractPropTypes<{
+    node: {
+        type: PropType<TreeNode>;
+        required: true;
+    };
+    collapsible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}>> & Omit<import("vue").VueConstructor<import("vue").default>, never> & (new (...args: any[]) => import("@vue/composition-api").ComponentRenderProxy<{
+    node: TreeNode;
+    collapsible: boolean;
+    selected: boolean;
+    expanded: boolean;
+    depth: number;
+    draggable: boolean;
+} & {} & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, import("@vue/composition-api").ShallowUnwrapRef<{
+    root: import("@vue/composition-api").Ref<HTMLElement | null>;
+    isOpen: import("@vue/composition-api").Ref<boolean>;
+    isLeaf: import("@vue/composition-api").ComputedRef<boolean>;
+    rootStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    nodeStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    dragIndicatorStyles: import("@vue/composition-api").ComputedRef<string[]>;
+    setIsOpen: (value?: boolean | undefined) => boolean;
+    nodeRoot: import("@vue/composition-api").Ref<HTMLElement | null>;
+    isDrag: import("@vue/composition-api").Ref<boolean>;
+    dragPosition: import("@vue/composition-api").Ref<"top" | "bottom" | "middle">;
+    handleDragStart: (e: DragEvent) => void;
+    handleDrop: (e: DragEvent) => void;
+    handleCollapse: () => void;
+    handleContextMenu: (e: MouseEvent) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleDragOver: (e: DragEvent) => void;
+    handleDragLeave: (e: DragEvent) => void;
+    hasCollapseTrigger: import("@vue/composition-api").ComputedRef<boolean>;
+    isDragOver: import("@vue/composition-api").Ref<boolean>;
+}>, import("@vue/composition-api").Data, {}, {}, {}, {}, string[], {
+    node: TreeNode;
+    collapsible: boolean;
+    selected: boolean;
+    expanded: boolean;
+    depth: number;
+    draggable: boolean;
+} & {} & {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, {
+    collapsible: boolean;
+    selected: boolean;
+    expanded: boolean;
+    depth: number;
+    draggable: boolean;
+}, true>);
+export default _default;

package/dist/esm/v2/components/or-tree-v3/partials/or-tree-node/styles.d.ts

@@ -0,0 +1,5 @@
+import { TreeNodeDropPosition } from '../../types';
+export declare const TreeNodeRoot: never[];
+export declare const TreeNodeItemRoot: string[];
+export declare const TreeNodeDragIndicator: string[];
+export declare const TreeNodeDragIndicatorPosition: Record<TreeNodeDropPosition, string[]>;

package/dist/esm/v2/components/or-tree-v3/partials/or-tree-node/utils.d.ts

@@ -0,0 +1,3 @@
+import { TreeNodeDropPosition } from '../../types';
+export declare function getDropOffset(e: DragEvent, canMiddleDrop?: boolean): TreeNodeDropPosition;
+export declare function applyPadding(element: HTMLElement, level: number, hasCollapseTrigger: boolean): void;

package/dist/esm/v2/components/or-tree-v3/types.d.ts

@@ -0,0 +1,15 @@
+export type TreeNode = {
+    key: string;
+    children?: TreeNode[];
+    collapsible?: boolean;
+    expanded?: boolean;
+    selected?: boolean;
+    draggable?: boolean;
+    [key: string]: any;
+    canMiddleDrop?: boolean;
+};
+export declare enum TreeNodeDropPosition {
+    Top = "top",
+    Bottom = "bottom",
+    Middle = "middle"
+}

package/dist/esm/v2/index.js

@@ -118,6 +118,7 @@ export { p as PropsV3, a as useQueueV3, u as useToastV3 } from './useToast-a1332
 export { _ as OrTooltip } from './OrTooltip-0bbf1ed5.js';
 export { _ as OrTooltipContent } from './OrTooltipContent-57a25502.js';
 export { _ as OrTooltipV3 } from './OrTooltip-bf4c725c.js';
+export { _ as OrTreeV3, T as TreeNodeDropPosition } from './OrTree-9db9d3d3.js';
 export { D as DropdownClose, a as DropdownOpen } from './dropdown-open-e1f90e0a.js';
 export { u as useControlAttributes, a as useIdAttribute } from './useIdAttribute-859439f0.js';
 export { u as useElevation } from './useElevation-a50ec347.js';