vuetify 3.5.7 → 3.5.9

package/dist/vuetify.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.5.7
+* Vuetify v3.5.9
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -3158,17 +3158,19 @@
     const {
       transition,
       disabled,
+      group,
       ...rest
     } = props;
     const {
-      component = vue.Transition,
+      component = group ? vue.TransitionGroup : vue.Transition,
       ...customProps
     } = typeof transition === 'object' ? transition : {};
     return vue.h(component, vue.mergeProps(typeof transition === 'string' ? {
       name: disabled ? '' : transition
-    } : customProps, rest, {
-      disabled
-    }), slots);
+    } : customProps, typeof transition === 'string' ? {} : {
+      disabled,
+      group
+    }, rest), slots);
   };
 
   // Utilities
@@ -4368,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 = {
@@ -7754,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 {
@@ -7838,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;
         }
@@ -7980,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;
         }
@@ -8024,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');
@@ -8042,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) {
@@ -8070,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;
@@ -8088,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 = [];
@@ -8161,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
       }
@@ -8179,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'),
@@ -8301,7 +8475,9 @@
           }, [slots.default?.()]), [[vue.vShow, isOpen.value]])]
         })]
       }));
-      return {};
+      return {
+        isOpen
+      };
     }
   });
 
@@ -8374,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,
@@ -8383,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(() => ({
@@ -8436,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 === ' ') {
@@ -8552,7 +8736,12 @@
           }, null)])]
         }), [[vue.resolveDirective("ripple"), isClickable.value && props.ripple]]);
       });
-      return {};
+      return {
+        isGroupActivator,
+        isSelected,
+        list,
+        select
+      };
     }
   });
 
@@ -8894,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) {
@@ -8928,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);
@@ -9018,7 +9211,9 @@
       return {
         open,
         select,
-        focus
+        focus,
+        children,
+        parents
       };
     }
   });
@@ -11898,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);
@@ -12460,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']);
@@ -16143,7 +16342,7 @@
         }
         if (e.key === 'Enter' && search.value) {
           select(transformItem$3(props, search.value));
-          if (hasSelectionSlot.value) search.value = '';
+          if (hasSelectionSlot.value) _search.value = '';
         }
         if (!props.multiple) return;
         if (['Backspace', 'Delete'].includes(e.key)) {
@@ -16237,8 +16436,24 @@
           return value === displayItems.value[0].value;
         })) {
           select(displayItems.value[0]);
-        } else if (search.value) {
-          select(transformItem$3(props, search.value));
+          return;
+        }
+        if (search.value) {
+          if (props.multiple) {
+            select(transformItem$3(props, search.value));
+            return;
+          }
+          if (!hasSelectionSlot.value) return;
+          if (model.value.some(_ref3 => {
+            let {
+              title
+            } = _ref3;
+            return title === search.value;
+          })) {
+            _search.value = '';
+          } else {
+            select(transformItem$3(props, search.value));
+          }
         }
       });
       vue.watch(menu, () => {
@@ -16249,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']);
@@ -16316,12 +16533,12 @@
                 "renderless": true,
                 "items": displayItems.value
               }, {
-                default: _ref3 => {
+                default: _ref4 => {
                   let {
                     item,
                     index,
                     itemRef
-                  } = _ref3;
+                  } = _ref4;
                   const itemProps = vue.mergeProps(item.props, {
                     ref: itemRef,
                     key: index,
@@ -16335,10 +16552,10 @@
                   }) ?? vue.createVNode(VListItem, vue.mergeProps(itemProps, {
                     "role": "option"
                   }), {
-                    prepend: _ref4 => {
+                    prepend: _ref5 => {
                       let {
                         isSelected
-                      } = _ref4;
+                      } = _ref5;
                       return vue.createVNode(vue.Fragment, null, [props.multiple && !props.hideSelected ? vue.createVNode(VCheckboxBtn, {
                         "key": item.value,
                         "modelValue": isSelected,
@@ -17354,10 +17571,28 @@
   function getDiff(date, comparing, unit) {
     const d = new Date(date);
     const c = new Date(comparing);
-    if (unit === 'month') {
-      return d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12;
+    switch (unit) {
+      case 'years':
+        return d.getFullYear() - c.getFullYear();
+      case 'quarters':
+        return Math.floor((d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12) / 4);
+      case 'months':
+        return d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12;
+      case 'weeks':
+        return Math.floor((d.getTime() - c.getTime()) / (1000 * 60 * 60 * 24 * 7));
+      case 'days':
+        return Math.floor((d.getTime() - c.getTime()) / (1000 * 60 * 60 * 24));
+      case 'hours':
+        return Math.floor((d.getTime() - c.getTime()) / (1000 * 60 * 60));
+      case 'minutes':
+        return Math.floor((d.getTime() - c.getTime()) / (1000 * 60));
+      case 'seconds':
+        return Math.floor((d.getTime() - c.getTime()) / 1000);
+      default:
+        {
+          return d.getTime() - c.getTime();
+        }
     }
-    return Math.floor((d.getTime() - c.getTime()) / (1000 * 60 * 60 * 24));
   }
   function setHours(date, count) {
     const d = new Date(date);
@@ -20254,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, {
@@ -20552,7 +20788,7 @@
           } else {
             rangeStop.value = _value;
           }
-          const diff = adapter.getDiff(rangeStop.value, rangeStart.value);
+          const diff = adapter.getDiff(rangeStop.value, rangeStart.value, 'days');
           const datesInRange = [rangeStart.value];
           for (let i = 1; i < diff; i++) {
             const nextDate = adapter.addDays(rangeStart.value, i);
@@ -24366,6 +24602,8 @@
         const controlProps = VSelectionControl.filterProps(props);
         return vue.createVNode(VInput, vue.mergeProps({
           "class": ['v-switch', {
+            'v-switch--flat': props.flat
+          }, {
             'v-switch--inset': props.inset
           }, {
             'v-switch--indeterminate': indeterminate.value
@@ -25739,7 +25977,7 @@
       goTo
     };
   }
-  const version$1 = "3.5.7";
+  const version$1 = "3.5.9";
   createVuetify$1.version = version$1;
 
   // Vue's inject() can only be used in setup
@@ -25764,7 +26002,7 @@
       ...options
     });
   };
-  const version = "3.5.7";
+  const version = "3.5.9";
   createVuetify.version = version;
 
   exports.components = components;