vuetify 3.5.8 → 3.5.9

package/dist/vuetify.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.5.8
+* Vuetify v3.5.9
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -4370,6 +4370,8 @@
     plus: 'mdi-plus',
     minus: 'mdi-minus',
     calendar: 'mdi-calendar',
+    treeviewCollapse: 'mdi-menu-down',
+    treeviewExpand: 'mdi-menu-right',
     eyeDropper: 'mdi-eyedropper'
   };
   const mdi = {
@@ -7756,6 +7758,126 @@
     return vue.inject(ListKey, null);
   }
 
+  /* eslint-disable sonarjs/no-identical-functions */
+  // Utilities
+  const independentActiveStrategy = mandatory => {
+    const strategy = {
+      activate: _ref => {
+        let {
+          id,
+          value,
+          activated
+        } = _ref;
+        id = vue.toRaw(id);
+
+        // When mandatory and we're trying to deselect when id
+        // is the only currently selected item then do nothing
+        if (mandatory && !value && activated.size === 1 && activated.has(id)) return activated;
+        if (value) {
+          activated.add(id);
+        } else {
+          activated.delete(id);
+        }
+        return activated;
+      },
+      in: (v, children, parents) => {
+        let set = new Set();
+        for (const id of v || []) {
+          set = strategy.activate({
+            id,
+            value: true,
+            activated: new Set(set),
+            children,
+            parents
+          });
+        }
+        return set;
+      },
+      out: v => {
+        return Array.from(v);
+      }
+    };
+    return strategy;
+  };
+  const independentSingleActiveStrategy = mandatory => {
+    const parentStrategy = independentActiveStrategy(mandatory);
+    const strategy = {
+      activate: _ref2 => {
+        let {
+          activated,
+          id,
+          ...rest
+        } = _ref2;
+        id = vue.toRaw(id);
+        const singleSelected = activated.has(id) ? new Set([id]) : new Set();
+        return parentStrategy.activate({
+          ...rest,
+          id,
+          activated: singleSelected
+        });
+      },
+      in: (v, children, parents) => {
+        let set = new Set();
+        if (v?.length) {
+          set = parentStrategy.in(v.slice(0, 1), children, parents);
+        }
+        return set;
+      },
+      out: (v, children, parents) => {
+        return parentStrategy.out(v, children, parents);
+      }
+    };
+    return strategy;
+  };
+  const leafActiveStrategy = mandatory => {
+    const parentStrategy = independentActiveStrategy(mandatory);
+    const strategy = {
+      activate: _ref3 => {
+        let {
+          id,
+          activated,
+          children,
+          ...rest
+        } = _ref3;
+        id = vue.toRaw(id);
+        if (children.has(id)) return activated;
+        return parentStrategy.activate({
+          id,
+          activated,
+          children,
+          ...rest
+        });
+      },
+      in: parentStrategy.in,
+      out: parentStrategy.out
+    };
+    return strategy;
+  };
+  const leafSingleActiveStrategy = mandatory => {
+    const parentStrategy = independentSingleActiveStrategy(mandatory);
+    const strategy = {
+      activate: _ref4 => {
+        let {
+          id,
+          activated,
+          children,
+          ...rest
+        } = _ref4;
+        id = vue.toRaw(id);
+        if (children.has(id)) return activated;
+        return parentStrategy.activate({
+          id,
+          activated,
+          children,
+          ...rest
+        });
+      },
+      in: parentStrategy.in,
+      out: parentStrategy.out
+    };
+    return strategy;
+  };
+
   const singleOpenStrategy = {
     open: _ref => {
       let {
@@ -7840,7 +7962,8 @@
         if (mandatory && !value) {
           const on = Array.from(selected.entries()).reduce((arr, _ref2) => {
             let [key, value] = _ref2;
-            return value === 'on' ? [...arr, key] : arr;
+            if (value === 'on') arr.push(key);
+            return arr;
           }, []);
           if (on.length === 1 && on[0] === id) return selected;
         }
@@ -7982,7 +8105,8 @@
         if (mandatory && !value) {
           const on = Array.from(selected.entries()).reduce((arr, _ref7) => {
             let [key, value] = _ref7;
-            return value === 'on' ? [...arr, key] : arr;
+            if (value === 'on') arr.push(key);
+            return arr;
           }, []);
           if (on.length === 0) return original;
         }
@@ -8026,16 +8150,24 @@
       children: vue.ref(new Map()),
       open: () => null,
       openOnSelect: () => null,
+      activate: () => null,
       select: () => null,
+      activatable: vue.ref(false),
+      selectable: vue.ref(false),
       opened: vue.ref(new Set()),
+      activated: vue.ref(new Set()),
       selected: vue.ref(new Map()),
       selectedValues: vue.ref([])
     }
   };
   const makeNestedProps = propsFactory({
+    activatable: Boolean,
+    selectable: Boolean,
+    activeStrategy: [String, Function],
     selectStrategy: [String, Function],
     openStrategy: [String, Object],
     opened: Array,
+    activated: Array,
     selected: Array,
     mandatory: Boolean
   }, 'nested');
@@ -8044,6 +8176,20 @@
     const children = vue.ref(new Map());
     const parents = vue.ref(new Map());
     const opened = useProxiedModel(props, 'opened', props.opened, v => new Set(v), v => [...v.values()]);
+    const activeStrategy = vue.computed(() => {
+      if (typeof props.activeStrategy === 'object') return props.activeStrategy;
+      switch (props.activeStrategy) {
+        case 'leaf':
+          return leafActiveStrategy(props.mandatory);
+        case 'single-leaf':
+          return leafSingleActiveStrategy(props.mandatory);
+        case 'independent':
+          return independentActiveStrategy(props.mandatory);
+        case 'single-independent':
+        default:
+          return independentSingleActiveStrategy(props.mandatory);
+      }
+    });
     const selectStrategy = vue.computed(() => {
       if (typeof props.selectStrategy === 'object') return props.selectStrategy;
       switch (props.selectStrategy) {
@@ -8072,6 +8218,7 @@
           return multipleOpenStrategy;
       }
     });
+    const activated = useProxiedModel(props, 'activated', props.activated, v => activeStrategy.value.in(v, children.value, parents.value), v => activeStrategy.value.out(v, children.value, parents.value));
     const selected = useProxiedModel(props, 'selected', props.selected, v => selectStrategy.value.in(v, children.value, parents.value), v => selectStrategy.value.out(v, children.value, parents.value));
     vue.onBeforeUnmount(() => {
       isUnmounted = true;
@@ -8090,6 +8237,9 @@
       id: vue.shallowRef(),
       root: {
         opened,
+        activatable: vue.toRef(props, 'activatable'),
+        selectable: vue.toRef(props, 'selectable'),
+        activated,
         selected,
         selectedValues: vue.computed(() => {
           const arr = [];
@@ -8163,6 +8313,26 @@
           newSelected && (selected.value = newSelected);
           nested.root.openOnSelect(id, value, event);
         },
+        activate: (id, value, event) => {
+          if (!props.activatable) {
+            return nested.root.select(id, true, event);
+          }
+          vm.emit('click:activate', {
+            id,
+            value,
+            path: getPath(id),
+            event
+          });
+          const newActivated = activeStrategy.value.activate({
+            id,
+            value,
+            activated: new Set(activated.value),
+            children: children.value,
+            parents: parents.value,
+            event
+          });
+          newActivated && (activated.value = newActivated);
+        },
         children,
         parents
       }
@@ -8181,6 +8351,8 @@
       openOnSelect: (open, e) => parent.root.openOnSelect(computedId.value, open, e),
       isOpen: vue.computed(() => parent.root.opened.value.has(computedId.value)),
       parent: vue.computed(() => parent.root.parents.value.get(computedId.value)),
+      activate: (activated, e) => parent.root.activate(computedId.value, activated, e),
+      isActivated: vue.computed(() => parent.root.activated.value.has(vue.toRaw(computedId.value))),
       select: (selected, e) => parent.root.select(computedId.value, selected, e),
       isSelected: vue.computed(() => parent.root.selected.value.get(vue.toRaw(computedId.value)) === 'on'),
       isIndeterminate: vue.computed(() => parent.root.selected.value.get(computedId.value) === 'indeterminate'),
@@ -8303,7 +8475,9 @@
           }, [slots.default?.()]), [[vue.vShow, isOpen.value]])]
         })]
       }));
-      return {};
+      return {
+        isOpen
+      };
     }
   });
 
@@ -8376,6 +8550,8 @@
       const link = useLink(props, attrs);
       const id = vue.computed(() => props.value === undefined ? link.href.value : props.value);
       const {
+        activate,
+        isActivated,
         select,
         isSelected,
         isIndeterminate,
@@ -8385,9 +8561,9 @@
         openOnSelect
       } = useNestedItem(id, false);
       const list = useList();
-      const isActive = vue.computed(() => props.active !== false && (props.active || link.isActive?.value || isSelected.value));
+      const isActive = vue.computed(() => props.active !== false && (props.active || link.isActive?.value || (root.activatable.value ? isActivated.value : isSelected.value)));
       const isLink = vue.computed(() => props.link !== false && link.isLink.value);
-      const isClickable = vue.computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || props.value != null && !!list));
+      const isClickable = vue.computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || !!list && (root.selectable.value || root.activatable.value || props.value != null)));
       const roundedProps = vue.computed(() => props.rounded || props.nav);
       const color = vue.computed(() => props.color ?? props.activeColor);
       const variantProps = vue.computed(() => ({
@@ -8438,7 +8614,13 @@
         emit('click', e);
         if (isGroupActivator || !isClickable.value) return;
         link.navigate?.(e);
-        props.value != null && select(!isSelected.value, e);
+        if (root.activatable) {
+          activate(!isActivated.value, e);
+        } else if (root.selectable) {
+          select(!isSelected.value, e);
+        } else if (props.value != null) {
+          select(!isSelected.value, e);
+        }
       }
       function onKeyDown(e) {
         if (e.key === 'Enter' || e.key === ' ') {
@@ -8554,7 +8736,12 @@
           }, null)])]
         }), [[vue.resolveDirective("ripple"), isClickable.value && props.ripple]]);
       });
-      return {};
+      return {
+        isGroupActivator,
+        isSelected,
+        list,
+        select
+      };
     }
   });
 
@@ -8896,8 +9083,10 @@
     props: makeVListProps(),
     emits: {
       'update:selected': value => true,
+      'update:activated': value => true,
       'update:opened': value => true,
       'click:open': value => true,
+      'click:activate': value => true,
       'click:select': value => true
     },
     setup(props, _ref) {
@@ -8930,7 +9119,9 @@
         roundedClasses
       } = useRounded(props);
       const {
+        children,
         open,
+        parents,
         select
       } = useNested(props);
       const lineClasses = vue.computed(() => props.lines ? `v-list--${props.lines}-line` : undefined);
@@ -9020,7 +9211,9 @@
       return {
         open,
         select,
-        focus
+        focus,
+        children,
+        parents
       };
     }
   });
@@ -11900,9 +12093,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.watch(() => props.items, (newVal, oldVal) => {
+        if (menu.value) return;
+        if (isFocused.value && !oldVal.length && newVal.length) {
+          menu.value = true;
+        }
       });
       useRender(() => {
         const hasChips = !!(props.chips || slots.chip);
@@ -12462,9 +12657,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.watch(() => props.items, (newVal, oldVal) => {
+        if (menu.value) return;
+        if (isFocused.value && !oldVal.length && newVal.length) {
+          menu.value = true;
+        }
       });
       useRender(() => {
         const hasList = !!(!props.hideNoData || displayItems.value.length || slots['prepend-item'] || slots['append-item'] || slots['no-data']);
@@ -16267,9 +16464,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.watch(() => props.items, (newVal, oldVal) => {
+        if (menu.value) return;
+        if (isFocused.value && !oldVal.length && newVal.length) {
+          menu.value = true;
+        }
       });
       useRender(() => {
         const hasList = !!(!props.hideNoData || displayItems.value.length || slots['prepend-item'] || slots['append-item'] || slots['no-data']);
@@ -20290,6 +20489,7 @@
         emit('click:month');
       }
       useRender(() => {
+        // TODO: add slot support and scope defaults
         return vue.createVNode("div", {
           "class": ['v-date-picker-controls']
         }, [vue.createVNode(VBtn, {
@@ -25777,7 +25977,7 @@
       goTo
     };
   }
-  const version$1 = "3.5.8";
+  const version$1 = "3.5.9";
   createVuetify$1.version = version$1;
 
   // Vue's inject() can only be used in setup
@@ -25802,7 +26002,7 @@
       ...options
     });
   };
-  const version = "3.5.8";
+  const version = "3.5.9";
   createVuetify.version = version;
 
   exports.components = components;