@evance/evance-ui 1.0.37 → 1.0.39

package/dist/cjs/chunks/EvListItem.vue_vue_type_script_setup_true_lang-C3ZW2eo-.cjs

@@ -0,0 +1,649 @@
+"use strict";
+/*! Evance UI v1.0.39 | MIT License */
+const vue = require("vue");
+const router = require("./router-DJoH04_B.cjs");
+const icons = require("./icons-DW3wRMYZ.cjs");
+const component = require("./component-AtNT2fuh.cjs");
+const props = require("./props-BjI4Mhey.cjs");
+const events = require("./events-zYOfuE8E.cjs");
+const hasSlotWithContent = require("./hasSlotWithContent-BXiH__4c.cjs");
+const isFunctions = require("./is-functions-BhjwCVcN.cjs");
+const modelProxy = require("./modelProxy-DMlLwZWj.cjs");
+const components = require("./components-CpYQTGYF.cjs");
+const helpers = require("./helpers-D5sNmblP.cjs");
+const EvIcon_vue_vue_type_style_index_0_lang = require("./EvIcon.vue_vue_type_style_index_0_lang-8acRhMGV.cjs");
+const ListKey = Symbol.for("ev:list");
+function createList() {
+  const defaultValue = {
+    hasPrepend: vue.shallowRef(false),
+    updateHasPrepend: () => null
+  };
+  const parent = vue.inject(ListKey, defaultValue);
+  const data = {
+    hasPrepend: vue.shallowRef(false),
+    updateHasPrepend: (value) => {
+      if (value) {
+        data.hasPrepend.value = value;
+      }
+    }
+  };
+  vue.provide(ListKey, data);
+  return parent;
+}
+function useList() {
+  return vue.inject(ListKey, null);
+}
+const cascadeLeaf = (isRequired) => {
+  const strategy = {
+    select: ({ id, value, selected, children, parents }) => {
+      id = vue.toRaw(id);
+      const original = new Map(selected);
+      const items = [id];
+      while (items.length) {
+        const item = items.shift();
+        selected.set(item, value ? "on" : "off");
+        if (children.has(item)) {
+          items.push(...children.get(item));
+        }
+      }
+      let parent = parents.get(id);
+      while (parent) {
+        const childrenIds = children.get(parent);
+        const everySelected = childrenIds.every(
+          (cid) => selected.get(cid) === "on"
+        );
+        const noneSelected = childrenIds.every(
+          (cid) => !selected.has(cid) || selected.get(cid) === "off"
+        );
+        selected.set(
+          parent,
+          everySelected ? "on" : noneSelected ? "off" : "indeterminate"
+        );
+        parent = parents.get(parent);
+      }
+      if (isRequired && !value) {
+        const on = Array.from(selected.entries()).reduce(
+          (arr, [key, value2]) => value2 === "on" ? [...arr, key] : arr,
+          []
+        );
+        if (on.length === 0) {
+          return original;
+        }
+      }
+      return selected;
+    },
+    in: (values, children, parents) => {
+      let map = /* @__PURE__ */ new Map();
+      for (const id of values || []) {
+        map = strategy.select({
+          id,
+          value: true,
+          selected: new Map(map),
+          children,
+          parents
+        });
+      }
+      return map;
+    },
+    out: (values, children) => {
+      const arr = [];
+      for (const [key, value] of values.entries()) {
+        if (value === "on" && !children.has(key)) {
+          arr.push(key);
+        }
+      }
+      return arr;
+    }
+  };
+  return strategy;
+};
+const multiAny = (isRequired) => {
+  const selectFn = (data) => {
+    const id = vue.toRaw(data.id);
+    if (isRequired && !data.value) {
+      const reducer = (arr, [key, value]) => {
+        return value === "on" ? [...arr, key] : arr;
+      };
+      const on = Array.from(data.selected.entries()).reduce(reducer, []);
+      if (on.length === 1 && on[0] === id) {
+        return data.selected;
+      }
+    }
+    data.selected.set(id, data.value ? "on" : "off");
+    return data.selected;
+  };
+  const transformIn = (values, children, parents) => {
+    let map = /* @__PURE__ */ new Map();
+    for (const id of values || []) {
+      map = selectFn({
+        id,
+        value: true,
+        selected: new Map(map)
+      });
+    }
+    return map;
+  };
+  const transformOut = (values) => {
+    const selections = [];
+    for (const [key, value] of values.entries()) {
+      if (value === "on") {
+        selections.push(key);
+      }
+    }
+    return selections;
+  };
+  return {
+    select: selectFn,
+    in: transformIn,
+    out: transformOut
+  };
+};
+const multiLeaf = (isRequired) => {
+  const parentStrategy = multiAny(isRequired);
+  return {
+    select: ({ id, selected, children, ...rest }) => {
+      id = vue.toRaw(id);
+      if (children.has(id)) {
+        return selected;
+      }
+      return parentStrategy.select({ id, selected, children, ...rest });
+    },
+    in: parentStrategy.in,
+    out: parentStrategy.out
+  };
+};
+const singleAny = (isRequired) => {
+  const parentStrategy = multiAny(isRequired);
+  const selectFn = (data) => {
+    const id = vue.toRaw(data.id);
+    const singleSelection = data.selected.has(id) || isRequired ? /* @__PURE__ */ new Map([[id, data.selected.get(id)]]) : /* @__PURE__ */ new Map();
+    return parentStrategy.select({
+      ...data,
+      id,
+      selected: singleSelection
+    });
+  };
+  const transformIn = (values, children, parents) => {
+    let map = /* @__PURE__ */ new Map();
+    if (Array.isArray(values) && values.length) {
+      map = parentStrategy.in(values.slice(0, 1), children, parents);
+    }
+    return map;
+  };
+  const transformOut = (values, children, parents) => {
+    return parentStrategy.out(values, children, parents);
+  };
+  return {
+    select: selectFn,
+    in: transformIn,
+    out: transformOut
+  };
+};
+const singleLeaf = (isRequired) => {
+  const parentStrategy = singleAny(isRequired);
+  return {
+    select: ({ id, selected, children, ...rest }) => {
+      id = vue.toRaw(id);
+      if (children.has(id)) {
+        return selected;
+      }
+      return parentStrategy.select({ id, selected, children, ...rest });
+    },
+    in: parentStrategy.in,
+    out: parentStrategy.out
+  };
+};
+const makeSelectedProps = props.propsFactory(
+  {
+    selectStrategy: [String, Function],
+    selected: Array,
+    required: Boolean
+  },
+  "select-strategies"
+);
+function useSelectStrategy(props2) {
+  return vue.computed(() => {
+    if (isFunctions.isObject(props2.selectStrategy) && !isFunctions.isFunction(props2.selectStrategy)) {
+      return props2.selectStrategy;
+    }
+    switch (props2.selectStrategy) {
+      case "single-leaf":
+        return singleLeaf(props2.required);
+      case "single-any":
+        return singleAny(props2.required);
+      case "multi-leaf":
+        return multiLeaf(props2.required);
+      case "multi-any":
+        return multiAny(props2.required);
+      case "cascade-leaf":
+      default:
+        return cascadeLeaf(props2.required);
+    }
+  });
+}
+function useSelectedValues(selected) {
+  return vue.computed(() => {
+    const values = [];
+    for (const [key, value] of selected.value.entries()) {
+      if (value === "on") {
+        values.push(key);
+      }
+    }
+    return values;
+  });
+}
+const singleOpenStrategy = {
+  open: ({ id, value, opened, parents }) => {
+    if (value) {
+      const newOpened = /* @__PURE__ */ new Set();
+      newOpened.add(id);
+      let parent = parents.get(id);
+      while (parent != null) {
+        newOpened.add(parent);
+        parent = parents.get(parent);
+      }
+      return newOpened;
+    }
+    opened.delete(id);
+    return opened;
+  },
+  select: () => null
+};
+const multipleOpenStrategy = {
+  open: ({ id, value, opened, parents }) => {
+    if (value) {
+      let parent = parents.get(id);
+      opened.add(id);
+      while (parent != null && parent !== id) {
+        opened.add(parent);
+        parent = parents.get(parent);
+      }
+      return opened;
+    }
+    opened.delete(id);
+    return opened;
+  },
+  select: () => null
+};
+const listOpenStrategy = {
+  open: multipleOpenStrategy.open,
+  select: ({ id, value, opened, parents }) => {
+    if (!value) {
+      return opened;
+    }
+    const path = [];
+    let parent = parents.get(id);
+    while (parent != null) {
+      path.push(parent);
+      parent = parents.get(parent);
+    }
+    return new Set(path);
+  }
+};
+const makeOpenStrategyProps = props.propsFactory(
+  {
+    openStrategy: [String, Object],
+    opened: Array
+  },
+  "open-strategies"
+);
+function useOpenStrategy(props2) {
+  return vue.computed(() => {
+    if (isFunctions.isObject(props2.openStrategy)) {
+      return props2.openStrategy;
+    }
+    switch (props2.openStrategy) {
+      case "list":
+        return listOpenStrategy;
+      case "single":
+        return singleOpenStrategy;
+      case "multiple":
+      default:
+        return multipleOpenStrategy;
+    }
+  });
+}
+const EvNestedSymbol = Symbol.for("ev:nested");
+const emptyNestedList = {
+  id: vue.shallowRef(),
+  root: {
+    children: vue.ref(/* @__PURE__ */ new Map()),
+    parents: vue.ref(/* @__PURE__ */ new Map()),
+    opened: vue.ref(/* @__PURE__ */ new Set()),
+    select: () => null,
+    selected: vue.ref(/* @__PURE__ */ new Map()),
+    selectedValues: vue.ref([]),
+    register: () => null,
+    unregister: () => null,
+    open: () => null,
+    openOnSelect: () => null
+  }
+};
+const makeNestedProps = props.propsFactory(
+  {
+    ...makeSelectedProps(),
+    ...makeOpenStrategyProps()
+  },
+  "nested"
+);
+const useNestedList = (props2) => {
+  let isUnmounted = false;
+  const component2 = components.getCurrentComponent("nested");
+  const children = vue.ref(/* @__PURE__ */ new Map());
+  const parents = vue.ref(/* @__PURE__ */ new Map());
+  const selectStrategy = useSelectStrategy(props2);
+  const selected = modelProxy.useModelProxy(
+    props2,
+    "selected",
+    props2.selected,
+    (values) => {
+      return selectStrategy.value.in(
+        values,
+        children.value,
+        parents.value
+      );
+    },
+    (values) => {
+      return selectStrategy.value.out(
+        values,
+        children.value,
+        parents.value
+      );
+    }
+  );
+  const openStrategy = useOpenStrategy(props2);
+  const opened = modelProxy.useModelProxy(
+    props2,
+    "opened",
+    props2.opened,
+    (values) => {
+      return new Set(values);
+    },
+    (values) => {
+      return [...values.values()];
+    }
+  );
+  vue.onBeforeMount(() => {
+    isUnmounted = true;
+  });
+  function getPath(id) {
+    const path = [];
+    let parent = id;
+    while (parent != null) {
+      path.unshift(parent);
+      parent = parents.value.get(parent);
+    }
+    return path;
+  }
+  const nested = {
+    id: vue.shallowRef(),
+    root: {
+      children,
+      parents,
+      selected,
+      selectedValues: useSelectedValues(selected),
+      select: (id, value, event) => {
+        component2.emit("click:select", {
+          id,
+          value,
+          path: getPath(id),
+          event
+        });
+        const newSelected = selectStrategy.value.select({
+          id,
+          value,
+          selected: new Map(selected.value),
+          children: children.value,
+          parents: parents.value,
+          event
+        });
+        newSelected && (selected.value = newSelected);
+        nested.root.openOnSelect(id, value, event);
+      },
+      register: (id, parentId, isGroup) => {
+        parentId && id !== parentId && parents.value.set(id, parentId);
+        if (isGroup) {
+          children.value.set(id, []);
+        }
+        if (parentId != null) {
+          children.value.set(parentId, [
+            ...children.value.get(parentId) || [],
+            id
+          ]);
+        }
+      },
+      unregister: (id) => {
+        if (isUnmounted) {
+          return;
+        }
+        children.value.delete(id);
+        const parent = parents.value.get(id);
+        if (parent) {
+          const list = children.value.get(parent) ?? [];
+          children.value.set(
+            parent,
+            list.filter((child) => child !== id)
+          );
+        }
+        parents.value.delete(id);
+      },
+      opened,
+      open: (id, value, event) => {
+        component2.emit("click:open", {
+          id,
+          value,
+          path: getPath(id),
+          event
+        });
+        const newOpened = openStrategy.value.open({
+          id,
+          value,
+          opened: new Set(opened.value),
+          children: children.value,
+          parents: parents.value,
+          event
+        });
+        newOpened && (opened.value = newOpened);
+      },
+      openOnSelect: (id, value, event) => {
+        const newOpened = openStrategy.value.select({
+          id,
+          value,
+          selected: new Map(selected.value),
+          opened: new Set(opened.value),
+          children: children.value,
+          parents: parents.value,
+          event
+        });
+        newOpened && (opened.value = newOpened);
+      }
+    }
+  };
+  vue.provide(EvNestedSymbol, nested);
+  return nested.root;
+};
+const useNestedListItem = (id, isGroup) => {
+  const parent = vue.inject(EvNestedSymbol, emptyNestedList);
+  const idSymbol = Symbol(helpers.getNextId());
+  const idComputed = vue.computed(() => {
+    return id.value !== void 0 ? id.value : idSymbol;
+  });
+  const item = {
+    ...parent,
+    id: idComputed,
+    parent: vue.computed(() => parent.root.parents.value.get(idComputed.value)),
+    select: (selected, e) => {
+      return parent.root.select(idComputed.value, selected, e);
+    },
+    isSelected: vue.computed(() => {
+      return parent.root.selected.value.get(vue.toRaw(idComputed.value)) === "on";
+    }),
+    isIndeterminate: vue.computed(() => {
+      return parent.root.selected.value.get(idComputed.value) === "indeterminate";
+    }),
+    isLeaf: vue.computed(() => {
+      return !parent.root.children.value.get(idComputed.value);
+    }),
+    isGroupActivator: parent.isGroupActivator
+  };
+  !parent.isGroupActivator && parent.root.register(idComputed.value, parent.id.value, isGroup);
+  vue.onBeforeUnmount(() => {
+    !parent.isGroupActivator && parent.root.unregister(idComputed.value);
+  });
+  return item;
+};
+const makeEvListItemProps = props.propsFactory(
+  {
+    active: {
+      type: Boolean,
+      default: void 0
+    },
+    activeExact: {
+      type: Boolean,
+      default: void 0
+    },
+    disabled: Boolean,
+    iconEnd: icons.IconProp,
+    iconStart: icons.IconProp,
+    link: {
+      type: Boolean,
+      default: void 0
+    },
+    tag: {
+      type: String,
+      default: "div"
+    },
+    title: [String, Number, Boolean],
+    value: null,
+    onClick: events.EventProp(),
+    ...router.makeRouterLinkOrHrefProps(),
+    ...component.makeComponentProps()
+  },
+  "EvListItem"
+);
+const _hoisted_1 = {
+  key: 0,
+  class: "ev-list-item--icon-start"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "ev-list-item--prefix"
+};
+const _hoisted_3 = { class: "ev-list-item--content" };
+const _hoisted_4 = {
+  key: 2,
+  class: "ev-list-item--suffix"
+};
+const _hoisted_5 = {
+  key: 3,
+  class: "ev-list-item--icon-end"
+};
+const _hoisted_6 = /* @__PURE__ */ vue.createElementVNode("div", { class: "ev-list-item--indicator" }, null, -1);
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "EvListItem",
+  props: {
+    ...makeEvListItemProps()
+  },
+  emits: ["click"],
+  setup(__props, { emit }) {
+    const props2 = __props;
+    const slots = vue.useSlots();
+    const attrs = vue.useAttrs();
+    const link = router.useRouterLinkOrHref(props2, attrs);
+    const list = useList();
+    const id = vue.computed(
+      () => props2.value === void 0 ? link.href.value : props2.value
+    );
+    const { select, isSelected } = useNestedListItem(id, false);
+    const hasSuffixSlot = hasSlotWithContent.hasSlotWithContent(slots, "suffix");
+    const hasPrefixSlot = hasSlotWithContent.hasSlotWithContent(slots, "prefix");
+    const isLink = vue.computed(() => props2.link !== false && link.isLink.value);
+    const isClickable = vue.computed(() => {
+      return !props2.disabled && props2.link !== false && (props2.link || link.isClickable.value || props2.value != null && !!list);
+    });
+    const isActive = vue.computed(() => {
+      var _a;
+      return props2.active !== false && (props2.active || ((_a = link.isActive) == null ? void 0 : _a.value) || isSelected.value);
+    });
+    const isActiveExact = vue.computed(() => {
+      var _a;
+      return props2.exact !== false && (props2.exact || ((_a = link.isExactActive) == null ? void 0 : _a.value));
+    });
+    const iconStart = EvIcon_vue_vue_type_style_index_0_lang.useIcon(props2, "iconStart");
+    const iconEnd = EvIcon_vue_vue_type_style_index_0_lang.useIcon(props2, "iconEnd");
+    function getComponentElement() {
+      return isLink.value ? "a" : props2.tag;
+    }
+    function getTabIndex() {
+      return isClickable.value ? list ? -2 : 0 : null;
+    }
+    function onClick(e) {
+      var _a;
+      emit("click", e);
+      if (!isClickable.value) {
+        return;
+      }
+      (_a = link.navigate) == null ? void 0 : _a.call(link, e);
+      if (props2.value != null) {
+        select(!isSelected.value, e);
+      }
+    }
+    function onKeyDown(e) {
+      e.preventDefault();
+      onClick(e);
+    }
+    const hasClickListener = vue.computed(
+      () => !!link.isClickable.value || !!props2.onClick
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(getComponentElement()), {
+        class: vue.normalizeClass([
+          "ev-list-item",
+          {
+            "is-active": isActive.value,
+            "is-active--exact": isActiveExact.value,
+            "is-clickable": isClickable.value || hasClickListener.value,
+            "is-disabled": props2.disabled
+          },
+          props2.class
+        ]),
+        style: vue.normalizeStyle(props2.style),
+        href: vue.unref(link).href.value,
+        tabindex: getTabIndex(),
+        onClick,
+        onKeydown: [
+          vue.withKeys(onKeyDown, ["enter"]),
+          vue.withKeys(onKeyDown, ["space"])
+        ]
+      }, {
+        default: vue.withCtx(() => [
+          vue.unref(iconStart) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+            vue.createVNode(vue.unref(EvIcon_vue_vue_type_style_index_0_lang._sfc_main), { glyph: vue.unref(iconStart) }, null, 8, ["glyph"])
+          ])) : vue.createCommentVNode("", true),
+          vue.unref(hasPrefixSlot) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+            vue.renderSlot(_ctx.$slots, "prefix")
+          ])) : vue.createCommentVNode("", true),
+          vue.createElementVNode("div", _hoisted_3, [
+            vue.renderSlot(_ctx.$slots, "default", {}, () => [
+              vue.createTextVNode(vue.toDisplayString(props2.title), 1)
+            ])
+          ]),
+          vue.unref(hasSuffixSlot) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
+            vue.renderSlot(_ctx.$slots, "suffix")
+          ])) : vue.createCommentVNode("", true),
+          vue.unref(iconEnd) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5, [
+            vue.createVNode(vue.unref(EvIcon_vue_vue_type_style_index_0_lang._sfc_main), { glyph: vue.unref(iconEnd) }, null, 8, ["glyph"])
+          ])) : vue.createCommentVNode("", true),
+          _hoisted_6
+        ]),
+        _: 3
+      }, 40, ["class", "style", "href", "tabindex", "onKeydown"]);
+    };
+  }
+});
+exports._sfc_main = _sfc_main;
+exports.createList = createList;
+exports.makeEvListItemProps = makeEvListItemProps;
+exports.makeNestedProps = makeNestedProps;
+exports.useNestedList = useNestedList;
+//# sourceMappingURL=EvListItem.vue_vue_type_script_setup_true_lang-C3ZW2eo-.cjs.map