1454 lines
40 KiB
JavaScript
1454 lines
40 KiB
JavaScript
import {
|
|
VAvatar
|
|
} from "./chunk-5XLJYRDC.js";
|
|
import {
|
|
VDivider
|
|
} from "./chunk-NUVQUA75.js";
|
|
import {
|
|
genOverlays,
|
|
makeVariantProps,
|
|
useVariant
|
|
} from "./chunk-XQKRKMJT.js";
|
|
import {
|
|
Ripple
|
|
} from "./chunk-NMCVREUK.js";
|
|
import {
|
|
makeBorderProps,
|
|
useBorder
|
|
} from "./chunk-O7K6SSRF.js";
|
|
import {
|
|
makeElevationProps,
|
|
useElevation
|
|
} from "./chunk-QXA6VMYU.js";
|
|
import {
|
|
makeDimensionProps,
|
|
useDimension
|
|
} from "./chunk-O7EUYO3B.js";
|
|
import {
|
|
VDefaultsProvider
|
|
} from "./chunk-D42AK3WB.js";
|
|
import {
|
|
makeRouterProps,
|
|
useLink
|
|
} from "./chunk-PCNFKUUR.js";
|
|
import {
|
|
makeDensityProps,
|
|
useDensity
|
|
} from "./chunk-VQPKT5F7.js";
|
|
import {
|
|
makeRoundedProps,
|
|
useRounded
|
|
} from "./chunk-24LK52JF.js";
|
|
import {
|
|
VIcon
|
|
} from "./chunk-IFUDBK56.js";
|
|
import {
|
|
VExpandTransition
|
|
} from "./chunk-JVZUVJAC.js";
|
|
import {
|
|
MaybeTransition
|
|
} from "./chunk-XRWT7YWI.js";
|
|
import {
|
|
useBackgroundColor,
|
|
useTextColor
|
|
} from "./chunk-ZZ55KHRR.js";
|
|
import {
|
|
IconValue
|
|
} from "./chunk-472DNWSX.js";
|
|
import {
|
|
useProxiedModel
|
|
} from "./chunk-PVQHDZXM.js";
|
|
import {
|
|
useSsrBoot
|
|
} from "./chunk-VDFYLV2V.js";
|
|
import {
|
|
makeTagProps
|
|
} from "./chunk-DJRL4NAD.js";
|
|
import {
|
|
makeThemeProps,
|
|
provideTheme
|
|
} from "./chunk-CYOEVGGH.js";
|
|
import {
|
|
EventProp,
|
|
createSimpleFunctional,
|
|
deepEqual,
|
|
defineComponent,
|
|
deprecate,
|
|
focusChild,
|
|
genericComponent,
|
|
getCurrentInstance,
|
|
getPropertyFromItem,
|
|
getUid,
|
|
makeComponentProps,
|
|
omit,
|
|
propsFactory,
|
|
provideDefaults,
|
|
useRender
|
|
} from "./chunk-I4KGD5X4.js";
|
|
import {
|
|
Fragment,
|
|
computed,
|
|
createVNode,
|
|
inject,
|
|
mergeProps,
|
|
onBeforeUnmount,
|
|
provide,
|
|
ref,
|
|
resolveDirective,
|
|
shallowRef,
|
|
toRaw,
|
|
toRef,
|
|
vShow,
|
|
watch,
|
|
withDirectives
|
|
} from "./chunk-PD2AWGJV.js";
|
|
|
|
// node_modules/vuetify/lib/components/VList/VList.mjs
|
|
import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VList/VList.css";
|
|
|
|
// node_modules/vuetify/lib/components/VList/list.mjs
|
|
var DepthKey = Symbol.for("vuetify:depth");
|
|
var ListKey = Symbol.for("vuetify:list");
|
|
function createList() {
|
|
const parent = inject(ListKey, {
|
|
hasPrepend: shallowRef(false),
|
|
updateHasPrepend: () => null
|
|
});
|
|
const data = {
|
|
hasPrepend: shallowRef(false),
|
|
updateHasPrepend: (value) => {
|
|
if (value) data.hasPrepend.value = value;
|
|
}
|
|
};
|
|
provide(ListKey, data);
|
|
return parent;
|
|
}
|
|
function useList() {
|
|
return inject(ListKey, null);
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/nested/openStrategies.mjs
|
|
var singleOpenStrategy = {
|
|
open: (_ref) => {
|
|
let {
|
|
id,
|
|
value,
|
|
opened,
|
|
parents
|
|
} = _ref;
|
|
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;
|
|
} else {
|
|
opened.delete(id);
|
|
return opened;
|
|
}
|
|
},
|
|
select: () => null
|
|
};
|
|
var multipleOpenStrategy = {
|
|
open: (_ref2) => {
|
|
let {
|
|
id,
|
|
value,
|
|
opened,
|
|
parents
|
|
} = _ref2;
|
|
if (value) {
|
|
let parent = parents.get(id);
|
|
opened.add(id);
|
|
while (parent != null && parent !== id) {
|
|
opened.add(parent);
|
|
parent = parents.get(parent);
|
|
}
|
|
return opened;
|
|
} else {
|
|
opened.delete(id);
|
|
}
|
|
return opened;
|
|
},
|
|
select: () => null
|
|
};
|
|
var listOpenStrategy = {
|
|
open: multipleOpenStrategy.open,
|
|
select: (_ref3) => {
|
|
let {
|
|
id,
|
|
value,
|
|
opened,
|
|
parents
|
|
} = _ref3;
|
|
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);
|
|
}
|
|
};
|
|
|
|
// node_modules/vuetify/lib/composables/nested/selectStrategies.mjs
|
|
var independentSelectStrategy = (mandatory) => {
|
|
const strategy = {
|
|
select: (_ref) => {
|
|
let {
|
|
id,
|
|
value,
|
|
selected
|
|
} = _ref;
|
|
id = toRaw(id);
|
|
if (mandatory && !value) {
|
|
const on = Array.from(selected.entries()).reduce((arr, _ref2) => {
|
|
let [key, value2] = _ref2;
|
|
return value2 === "on" ? [...arr, key] : arr;
|
|
}, []);
|
|
if (on.length === 1 && on[0] === id) return selected;
|
|
}
|
|
selected.set(id, value ? "on" : "off");
|
|
return selected;
|
|
},
|
|
in: (v, children, parents) => {
|
|
let map = /* @__PURE__ */ new Map();
|
|
for (const id of v || []) {
|
|
map = strategy.select({
|
|
id,
|
|
value: true,
|
|
selected: new Map(map),
|
|
children,
|
|
parents
|
|
});
|
|
}
|
|
return map;
|
|
},
|
|
out: (v) => {
|
|
const arr = [];
|
|
for (const [key, value] of v.entries()) {
|
|
if (value === "on") arr.push(key);
|
|
}
|
|
return arr;
|
|
}
|
|
};
|
|
return strategy;
|
|
};
|
|
var independentSingleSelectStrategy = (mandatory) => {
|
|
const parentStrategy = independentSelectStrategy(mandatory);
|
|
const strategy = {
|
|
select: (_ref3) => {
|
|
let {
|
|
selected,
|
|
id,
|
|
...rest
|
|
} = _ref3;
|
|
id = toRaw(id);
|
|
const singleSelected = selected.has(id) ? /* @__PURE__ */ new Map([[id, selected.get(id)]]) : /* @__PURE__ */ new Map();
|
|
return parentStrategy.select({
|
|
...rest,
|
|
id,
|
|
selected: singleSelected
|
|
});
|
|
},
|
|
in: (v, children, parents) => {
|
|
let map = /* @__PURE__ */ new Map();
|
|
if (v == null ? void 0 : v.length) {
|
|
map = parentStrategy.in(v.slice(0, 1), children, parents);
|
|
}
|
|
return map;
|
|
},
|
|
out: (v, children, parents) => {
|
|
return parentStrategy.out(v, children, parents);
|
|
}
|
|
};
|
|
return strategy;
|
|
};
|
|
var leafSelectStrategy = (mandatory) => {
|
|
const parentStrategy = independentSelectStrategy(mandatory);
|
|
const strategy = {
|
|
select: (_ref4) => {
|
|
let {
|
|
id,
|
|
selected,
|
|
children,
|
|
...rest
|
|
} = _ref4;
|
|
id = toRaw(id);
|
|
if (children.has(id)) return selected;
|
|
return parentStrategy.select({
|
|
id,
|
|
selected,
|
|
children,
|
|
...rest
|
|
});
|
|
},
|
|
in: parentStrategy.in,
|
|
out: parentStrategy.out
|
|
};
|
|
return strategy;
|
|
};
|
|
var leafSingleSelectStrategy = (mandatory) => {
|
|
const parentStrategy = independentSingleSelectStrategy(mandatory);
|
|
const strategy = {
|
|
select: (_ref5) => {
|
|
let {
|
|
id,
|
|
selected,
|
|
children,
|
|
...rest
|
|
} = _ref5;
|
|
id = toRaw(id);
|
|
if (children.has(id)) return selected;
|
|
return parentStrategy.select({
|
|
id,
|
|
selected,
|
|
children,
|
|
...rest
|
|
});
|
|
},
|
|
in: parentStrategy.in,
|
|
out: parentStrategy.out
|
|
};
|
|
return strategy;
|
|
};
|
|
var classicSelectStrategy = (mandatory) => {
|
|
const strategy = {
|
|
select: (_ref6) => {
|
|
let {
|
|
id,
|
|
value,
|
|
selected,
|
|
children,
|
|
parents
|
|
} = _ref6;
|
|
id = 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 (mandatory && !value) {
|
|
const on = Array.from(selected.entries()).reduce((arr, _ref7) => {
|
|
let [key, value2] = _ref7;
|
|
return value2 === "on" ? [...arr, key] : arr;
|
|
}, []);
|
|
if (on.length === 0) return original;
|
|
}
|
|
return selected;
|
|
},
|
|
in: (v, children, parents) => {
|
|
let map = /* @__PURE__ */ new Map();
|
|
for (const id of v || []) {
|
|
map = strategy.select({
|
|
id,
|
|
value: true,
|
|
selected: new Map(map),
|
|
children,
|
|
parents
|
|
});
|
|
}
|
|
return map;
|
|
},
|
|
out: (v, children) => {
|
|
const arr = [];
|
|
for (const [key, value] of v.entries()) {
|
|
if (value === "on" && !children.has(key)) arr.push(key);
|
|
}
|
|
return arr;
|
|
}
|
|
};
|
|
return strategy;
|
|
};
|
|
|
|
// node_modules/vuetify/lib/composables/nested/nested.mjs
|
|
var VNestedSymbol = Symbol.for("vuetify:nested");
|
|
var emptyNested = {
|
|
id: shallowRef(),
|
|
root: {
|
|
register: () => null,
|
|
unregister: () => null,
|
|
parents: ref(/* @__PURE__ */ new Map()),
|
|
children: ref(/* @__PURE__ */ new Map()),
|
|
open: () => null,
|
|
openOnSelect: () => null,
|
|
select: () => null,
|
|
opened: ref(/* @__PURE__ */ new Set()),
|
|
selected: ref(/* @__PURE__ */ new Map()),
|
|
selectedValues: ref([])
|
|
}
|
|
};
|
|
var makeNestedProps = propsFactory({
|
|
selectStrategy: [String, Function],
|
|
openStrategy: [String, Object],
|
|
opened: Array,
|
|
selected: Array,
|
|
mandatory: Boolean
|
|
}, "nested");
|
|
var useNested = (props) => {
|
|
let isUnmounted = false;
|
|
const children = ref(/* @__PURE__ */ new Map());
|
|
const parents = ref(/* @__PURE__ */ new Map());
|
|
const opened = useProxiedModel(props, "opened", props.opened, (v) => new Set(v), (v) => [...v.values()]);
|
|
const selectStrategy = computed(() => {
|
|
if (typeof props.selectStrategy === "object") return props.selectStrategy;
|
|
switch (props.selectStrategy) {
|
|
case "single-leaf":
|
|
return leafSingleSelectStrategy(props.mandatory);
|
|
case "leaf":
|
|
return leafSelectStrategy(props.mandatory);
|
|
case "independent":
|
|
return independentSelectStrategy(props.mandatory);
|
|
case "single-independent":
|
|
return independentSingleSelectStrategy(props.mandatory);
|
|
case "classic":
|
|
default:
|
|
return classicSelectStrategy(props.mandatory);
|
|
}
|
|
});
|
|
const openStrategy = computed(() => {
|
|
if (typeof props.openStrategy === "object") return props.openStrategy;
|
|
switch (props.openStrategy) {
|
|
case "list":
|
|
return listOpenStrategy;
|
|
case "single":
|
|
return singleOpenStrategy;
|
|
case "multiple":
|
|
default:
|
|
return multipleOpenStrategy;
|
|
}
|
|
});
|
|
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));
|
|
onBeforeUnmount(() => {
|
|
isUnmounted = true;
|
|
});
|
|
function getPath(id) {
|
|
const path = [];
|
|
let parent = id;
|
|
while (parent != null) {
|
|
path.unshift(parent);
|
|
parent = parents.value.get(parent);
|
|
}
|
|
return path;
|
|
}
|
|
const vm = getCurrentInstance("nested");
|
|
const nested = {
|
|
id: shallowRef(),
|
|
root: {
|
|
opened,
|
|
selected,
|
|
selectedValues: computed(() => {
|
|
const arr = [];
|
|
for (const [key, value] of selected.value.entries()) {
|
|
if (value === "on") arr.push(key);
|
|
}
|
|
return arr;
|
|
}),
|
|
register: (id, parentId, isGroup) => {
|
|
parentId && id !== parentId && parents.value.set(id, parentId);
|
|
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.value.delete(id);
|
|
},
|
|
open: (id, value, event) => {
|
|
vm.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);
|
|
},
|
|
select: (id, value, event) => {
|
|
vm.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);
|
|
},
|
|
children,
|
|
parents
|
|
}
|
|
};
|
|
provide(VNestedSymbol, nested);
|
|
return nested.root;
|
|
};
|
|
var useNestedItem = (id, isGroup) => {
|
|
const parent = inject(VNestedSymbol, emptyNested);
|
|
const uidSymbol = Symbol(getUid());
|
|
const computedId = computed(() => id.value !== void 0 ? id.value : uidSymbol);
|
|
const item = {
|
|
...parent,
|
|
id: computedId,
|
|
open: (open, e) => parent.root.open(computedId.value, open, e),
|
|
openOnSelect: (open, e) => parent.root.openOnSelect(computedId.value, open, e),
|
|
isOpen: computed(() => parent.root.opened.value.has(computedId.value)),
|
|
parent: computed(() => parent.root.parents.value.get(computedId.value)),
|
|
select: (selected, e) => parent.root.select(computedId.value, selected, e),
|
|
isSelected: computed(() => parent.root.selected.value.get(toRaw(computedId.value)) === "on"),
|
|
isIndeterminate: computed(() => parent.root.selected.value.get(computedId.value) === "indeterminate"),
|
|
isLeaf: computed(() => !parent.root.children.value.get(computedId.value)),
|
|
isGroupActivator: parent.isGroupActivator
|
|
};
|
|
!parent.isGroupActivator && parent.root.register(computedId.value, parent.id.value, isGroup);
|
|
onBeforeUnmount(() => {
|
|
!parent.isGroupActivator && parent.root.unregister(computedId.value);
|
|
});
|
|
isGroup && provide(VNestedSymbol, item);
|
|
return item;
|
|
};
|
|
var useNestedGroupActivator = () => {
|
|
const parent = inject(VNestedSymbol, emptyNested);
|
|
provide(VNestedSymbol, {
|
|
...parent,
|
|
isGroupActivator: true
|
|
});
|
|
};
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListGroup.mjs
|
|
var VListGroupActivator = defineComponent({
|
|
name: "VListGroupActivator",
|
|
setup(_, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
useNestedGroupActivator();
|
|
return () => {
|
|
var _a;
|
|
return (_a = slots.default) == null ? void 0 : _a.call(slots);
|
|
};
|
|
}
|
|
});
|
|
var makeVListGroupProps = propsFactory({
|
|
/* @deprecated */
|
|
activeColor: String,
|
|
baseColor: String,
|
|
color: String,
|
|
collapseIcon: {
|
|
type: IconValue,
|
|
default: "$collapse"
|
|
},
|
|
expandIcon: {
|
|
type: IconValue,
|
|
default: "$expand"
|
|
},
|
|
prependIcon: IconValue,
|
|
appendIcon: IconValue,
|
|
fluid: Boolean,
|
|
subgroup: Boolean,
|
|
title: String,
|
|
value: null,
|
|
...makeComponentProps(),
|
|
...makeTagProps()
|
|
}, "VListGroup");
|
|
var VListGroup = genericComponent()({
|
|
name: "VListGroup",
|
|
props: makeVListGroupProps(),
|
|
setup(props, _ref2) {
|
|
let {
|
|
slots
|
|
} = _ref2;
|
|
const {
|
|
isOpen,
|
|
open,
|
|
id: _id
|
|
} = useNestedItem(toRef(props, "value"), true);
|
|
const id = computed(() => `v-list-group--id-${String(_id.value)}`);
|
|
const list = useList();
|
|
const {
|
|
isBooted
|
|
} = useSsrBoot();
|
|
function onClick(e) {
|
|
open(!isOpen.value, e);
|
|
}
|
|
const activatorProps = computed(() => ({
|
|
onClick,
|
|
class: "v-list-group__header",
|
|
id: id.value
|
|
}));
|
|
const toggleIcon = computed(() => isOpen.value ? props.collapseIcon : props.expandIcon);
|
|
const activatorDefaults = computed(() => ({
|
|
VListItem: {
|
|
active: isOpen.value,
|
|
activeColor: props.activeColor,
|
|
baseColor: props.baseColor,
|
|
color: props.color,
|
|
prependIcon: props.prependIcon || props.subgroup && toggleIcon.value,
|
|
appendIcon: props.appendIcon || !props.subgroup && toggleIcon.value,
|
|
title: props.title,
|
|
value: props.value
|
|
}
|
|
}));
|
|
useRender(() => createVNode(props.tag, {
|
|
"class": ["v-list-group", {
|
|
"v-list-group--prepend": list == null ? void 0 : list.hasPrepend.value,
|
|
"v-list-group--fluid": props.fluid,
|
|
"v-list-group--subgroup": props.subgroup,
|
|
"v-list-group--open": isOpen.value
|
|
}, props.class],
|
|
"style": props.style
|
|
}, {
|
|
default: () => [slots.activator && createVNode(VDefaultsProvider, {
|
|
"defaults": activatorDefaults.value
|
|
}, {
|
|
default: () => [createVNode(VListGroupActivator, null, {
|
|
default: () => [slots.activator({
|
|
props: activatorProps.value,
|
|
isOpen: isOpen.value
|
|
})]
|
|
})]
|
|
}), createVNode(MaybeTransition, {
|
|
"transition": {
|
|
component: VExpandTransition
|
|
},
|
|
"disabled": !isBooted.value
|
|
}, {
|
|
default: () => {
|
|
var _a;
|
|
return [withDirectives(createVNode("div", {
|
|
"class": "v-list-group__items",
|
|
"role": "group",
|
|
"aria-labelledby": id.value
|
|
}, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[vShow, isOpen.value]])];
|
|
}
|
|
})]
|
|
}));
|
|
return {};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItem.mjs
|
|
import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VList/VListItem.css";
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItemSubtitle.mjs
|
|
var VListItemSubtitle = createSimpleFunctional("v-list-item-subtitle");
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItemTitle.mjs
|
|
var VListItemTitle = createSimpleFunctional("v-list-item-title");
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItem.mjs
|
|
var makeVListItemProps = propsFactory({
|
|
active: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
activeClass: String,
|
|
/* @deprecated */
|
|
activeColor: String,
|
|
appendAvatar: String,
|
|
appendIcon: IconValue,
|
|
baseColor: String,
|
|
disabled: Boolean,
|
|
lines: String,
|
|
link: {
|
|
type: Boolean,
|
|
default: void 0
|
|
},
|
|
nav: Boolean,
|
|
prependAvatar: String,
|
|
prependIcon: IconValue,
|
|
ripple: {
|
|
type: [Boolean, Object],
|
|
default: true
|
|
},
|
|
slim: Boolean,
|
|
subtitle: [String, Number],
|
|
title: [String, Number],
|
|
value: null,
|
|
onClick: EventProp(),
|
|
onClickOnce: EventProp(),
|
|
...makeBorderProps(),
|
|
...makeComponentProps(),
|
|
...makeDensityProps(),
|
|
...makeDimensionProps(),
|
|
...makeElevationProps(),
|
|
...makeRoundedProps(),
|
|
...makeRouterProps(),
|
|
...makeTagProps(),
|
|
...makeThemeProps(),
|
|
...makeVariantProps({
|
|
variant: "text"
|
|
})
|
|
}, "VListItem");
|
|
var VListItem = genericComponent()({
|
|
name: "VListItem",
|
|
directives: {
|
|
Ripple
|
|
},
|
|
props: makeVListItemProps(),
|
|
emits: {
|
|
click: (e) => true
|
|
},
|
|
setup(props, _ref) {
|
|
let {
|
|
attrs,
|
|
slots,
|
|
emit
|
|
} = _ref;
|
|
const link = useLink(props, attrs);
|
|
const id = computed(() => props.value === void 0 ? link.href.value : props.value);
|
|
const {
|
|
select,
|
|
isSelected,
|
|
isIndeterminate,
|
|
isGroupActivator,
|
|
root,
|
|
parent,
|
|
openOnSelect
|
|
} = useNestedItem(id, false);
|
|
const list = useList();
|
|
const isActive = computed(() => {
|
|
var _a;
|
|
return props.active !== false && (props.active || ((_a = link.isActive) == null ? void 0 : _a.value) || isSelected.value);
|
|
});
|
|
const isLink = computed(() => props.link !== false && link.isLink.value);
|
|
const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || props.value != null && !!list));
|
|
const roundedProps = computed(() => props.rounded || props.nav);
|
|
const color = computed(() => props.color ?? props.activeColor);
|
|
const variantProps = computed(() => ({
|
|
color: isActive.value ? color.value ?? props.baseColor : props.baseColor,
|
|
variant: props.variant
|
|
}));
|
|
watch(() => {
|
|
var _a;
|
|
return (_a = link.isActive) == null ? void 0 : _a.value;
|
|
}, (val) => {
|
|
if (val && parent.value != null) {
|
|
root.open(parent.value, true);
|
|
}
|
|
if (val) {
|
|
openOnSelect(val);
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
const {
|
|
themeClasses
|
|
} = provideTheme(props);
|
|
const {
|
|
borderClasses
|
|
} = useBorder(props);
|
|
const {
|
|
colorClasses,
|
|
colorStyles,
|
|
variantClasses
|
|
} = useVariant(variantProps);
|
|
const {
|
|
densityClasses
|
|
} = useDensity(props);
|
|
const {
|
|
dimensionStyles
|
|
} = useDimension(props);
|
|
const {
|
|
elevationClasses
|
|
} = useElevation(props);
|
|
const {
|
|
roundedClasses
|
|
} = useRounded(roundedProps);
|
|
const lineClasses = computed(() => props.lines ? `v-list-item--${props.lines}-line` : void 0);
|
|
const slotProps = computed(() => ({
|
|
isActive: isActive.value,
|
|
select,
|
|
isSelected: isSelected.value,
|
|
isIndeterminate: isIndeterminate.value
|
|
}));
|
|
function onClick(e) {
|
|
var _a;
|
|
emit("click", e);
|
|
if (isGroupActivator || !isClickable.value) return;
|
|
(_a = link.navigate) == null ? void 0 : _a.call(link, e);
|
|
props.value != null && select(!isSelected.value, e);
|
|
}
|
|
function onKeyDown(e) {
|
|
if (e.key === "Enter" || e.key === " ") {
|
|
e.preventDefault();
|
|
onClick(e);
|
|
}
|
|
}
|
|
useRender(() => {
|
|
const Tag = isLink.value ? "a" : props.tag;
|
|
const hasTitle = slots.title || props.title != null;
|
|
const hasSubtitle = slots.subtitle || props.subtitle != null;
|
|
const hasAppendMedia = !!(props.appendAvatar || props.appendIcon);
|
|
const hasAppend = !!(hasAppendMedia || slots.append);
|
|
const hasPrependMedia = !!(props.prependAvatar || props.prependIcon);
|
|
const hasPrepend = !!(hasPrependMedia || slots.prepend);
|
|
list == null ? void 0 : list.updateHasPrepend(hasPrepend);
|
|
if (props.activeColor) {
|
|
deprecate("active-color", ["color", "base-color"]);
|
|
}
|
|
return withDirectives(createVNode(Tag, {
|
|
"class": ["v-list-item", {
|
|
"v-list-item--active": isActive.value,
|
|
"v-list-item--disabled": props.disabled,
|
|
"v-list-item--link": isClickable.value,
|
|
"v-list-item--nav": props.nav,
|
|
"v-list-item--prepend": !hasPrepend && (list == null ? void 0 : list.hasPrepend.value),
|
|
"v-list-item--slim": props.slim,
|
|
[`${props.activeClass}`]: props.activeClass && isActive.value
|
|
}, themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, elevationClasses.value, lineClasses.value, roundedClasses.value, variantClasses.value, props.class],
|
|
"style": [colorStyles.value, dimensionStyles.value, props.style],
|
|
"href": link.href.value,
|
|
"tabindex": isClickable.value ? list ? -2 : 0 : void 0,
|
|
"onClick": onClick,
|
|
"onKeydown": isClickable.value && !isLink.value && onKeyDown
|
|
}, {
|
|
default: () => {
|
|
var _a;
|
|
return [genOverlays(isClickable.value || isActive.value, "v-list-item"), hasPrepend && createVNode("div", {
|
|
"key": "prepend",
|
|
"class": "v-list-item__prepend"
|
|
}, [!slots.prepend ? createVNode(Fragment, null, [props.prependAvatar && createVNode(VAvatar, {
|
|
"key": "prepend-avatar",
|
|
"density": props.density,
|
|
"image": props.prependAvatar
|
|
}, null), props.prependIcon && createVNode(VIcon, {
|
|
"key": "prepend-icon",
|
|
"density": props.density,
|
|
"icon": props.prependIcon
|
|
}, null)]) : createVNode(VDefaultsProvider, {
|
|
"key": "prepend-defaults",
|
|
"disabled": !hasPrependMedia,
|
|
"defaults": {
|
|
VAvatar: {
|
|
density: props.density,
|
|
image: props.prependAvatar
|
|
},
|
|
VIcon: {
|
|
density: props.density,
|
|
icon: props.prependIcon
|
|
},
|
|
VListItemAction: {
|
|
start: true
|
|
}
|
|
}
|
|
}, {
|
|
default: () => {
|
|
var _a2;
|
|
return [(_a2 = slots.prepend) == null ? void 0 : _a2.call(slots, slotProps.value)];
|
|
}
|
|
}), createVNode("div", {
|
|
"class": "v-list-item__spacer"
|
|
}, null)]), createVNode("div", {
|
|
"class": "v-list-item__content",
|
|
"data-no-activator": ""
|
|
}, [hasTitle && createVNode(VListItemTitle, {
|
|
"key": "title"
|
|
}, {
|
|
default: () => {
|
|
var _a2;
|
|
return [((_a2 = slots.title) == null ? void 0 : _a2.call(slots, {
|
|
title: props.title
|
|
})) ?? props.title];
|
|
}
|
|
}), hasSubtitle && createVNode(VListItemSubtitle, {
|
|
"key": "subtitle"
|
|
}, {
|
|
default: () => {
|
|
var _a2;
|
|
return [((_a2 = slots.subtitle) == null ? void 0 : _a2.call(slots, {
|
|
subtitle: props.subtitle
|
|
})) ?? props.subtitle];
|
|
}
|
|
}), (_a = slots.default) == null ? void 0 : _a.call(slots, slotProps.value)]), hasAppend && createVNode("div", {
|
|
"key": "append",
|
|
"class": "v-list-item__append"
|
|
}, [!slots.append ? createVNode(Fragment, null, [props.appendIcon && createVNode(VIcon, {
|
|
"key": "append-icon",
|
|
"density": props.density,
|
|
"icon": props.appendIcon
|
|
}, null), props.appendAvatar && createVNode(VAvatar, {
|
|
"key": "append-avatar",
|
|
"density": props.density,
|
|
"image": props.appendAvatar
|
|
}, null)]) : createVNode(VDefaultsProvider, {
|
|
"key": "append-defaults",
|
|
"disabled": !hasAppendMedia,
|
|
"defaults": {
|
|
VAvatar: {
|
|
density: props.density,
|
|
image: props.appendAvatar
|
|
},
|
|
VIcon: {
|
|
density: props.density,
|
|
icon: props.appendIcon
|
|
},
|
|
VListItemAction: {
|
|
end: true
|
|
}
|
|
}
|
|
}, {
|
|
default: () => {
|
|
var _a2;
|
|
return [(_a2 = slots.append) == null ? void 0 : _a2.call(slots, slotProps.value)];
|
|
}
|
|
}), createVNode("div", {
|
|
"class": "v-list-item__spacer"
|
|
}, null)])];
|
|
}
|
|
}), [[resolveDirective("ripple"), isClickable.value && props.ripple]]);
|
|
});
|
|
return {};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListSubheader.mjs
|
|
var makeVListSubheaderProps = propsFactory({
|
|
color: String,
|
|
inset: Boolean,
|
|
sticky: Boolean,
|
|
title: String,
|
|
...makeComponentProps(),
|
|
...makeTagProps()
|
|
}, "VListSubheader");
|
|
var VListSubheader = genericComponent()({
|
|
name: "VListSubheader",
|
|
props: makeVListSubheaderProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
const {
|
|
textColorClasses,
|
|
textColorStyles
|
|
} = useTextColor(toRef(props, "color"));
|
|
useRender(() => {
|
|
const hasText = !!(slots.default || props.title);
|
|
return createVNode(props.tag, {
|
|
"class": ["v-list-subheader", {
|
|
"v-list-subheader--inset": props.inset,
|
|
"v-list-subheader--sticky": props.sticky
|
|
}, textColorClasses.value, props.class],
|
|
"style": [{
|
|
textColorStyles
|
|
}, props.style]
|
|
}, {
|
|
default: () => {
|
|
var _a;
|
|
return [hasText && createVNode("div", {
|
|
"class": "v-list-subheader__text"
|
|
}, [((_a = slots.default) == null ? void 0 : _a.call(slots)) ?? props.title])];
|
|
}
|
|
});
|
|
});
|
|
return {};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListChildren.mjs
|
|
var makeVListChildrenProps = propsFactory({
|
|
items: Array,
|
|
returnObject: Boolean
|
|
}, "VListChildren");
|
|
var VListChildren = genericComponent()({
|
|
name: "VListChildren",
|
|
props: makeVListChildrenProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
createList();
|
|
return () => {
|
|
var _a, _b;
|
|
return ((_a = slots.default) == null ? void 0 : _a.call(slots)) ?? ((_b = props.items) == null ? void 0 : _b.map((_ref2) => {
|
|
var _a2, _b2;
|
|
let {
|
|
children,
|
|
props: itemProps,
|
|
type,
|
|
raw: item
|
|
} = _ref2;
|
|
if (type === "divider") {
|
|
return ((_a2 = slots.divider) == null ? void 0 : _a2.call(slots, {
|
|
props: itemProps
|
|
})) ?? createVNode(VDivider, itemProps, null);
|
|
}
|
|
if (type === "subheader") {
|
|
return ((_b2 = slots.subheader) == null ? void 0 : _b2.call(slots, {
|
|
props: itemProps
|
|
})) ?? createVNode(VListSubheader, itemProps, null);
|
|
}
|
|
const slotsWithItem = {
|
|
subtitle: slots.subtitle ? (slotProps) => {
|
|
var _a3;
|
|
return (_a3 = slots.subtitle) == null ? void 0 : _a3.call(slots, {
|
|
...slotProps,
|
|
item
|
|
});
|
|
} : void 0,
|
|
prepend: slots.prepend ? (slotProps) => {
|
|
var _a3;
|
|
return (_a3 = slots.prepend) == null ? void 0 : _a3.call(slots, {
|
|
...slotProps,
|
|
item
|
|
});
|
|
} : void 0,
|
|
append: slots.append ? (slotProps) => {
|
|
var _a3;
|
|
return (_a3 = slots.append) == null ? void 0 : _a3.call(slots, {
|
|
...slotProps,
|
|
item
|
|
});
|
|
} : void 0,
|
|
title: slots.title ? (slotProps) => {
|
|
var _a3;
|
|
return (_a3 = slots.title) == null ? void 0 : _a3.call(slots, {
|
|
...slotProps,
|
|
item
|
|
});
|
|
} : void 0
|
|
};
|
|
const listGroupProps = VListGroup.filterProps(itemProps);
|
|
return children ? createVNode(VListGroup, mergeProps({
|
|
"value": itemProps == null ? void 0 : itemProps.value
|
|
}, listGroupProps), {
|
|
activator: (_ref3) => {
|
|
let {
|
|
props: activatorProps
|
|
} = _ref3;
|
|
const listItemProps = {
|
|
...itemProps,
|
|
...activatorProps,
|
|
value: props.returnObject ? item : itemProps.value
|
|
};
|
|
return slots.header ? slots.header({
|
|
props: listItemProps
|
|
}) : createVNode(VListItem, listItemProps, slotsWithItem);
|
|
},
|
|
default: () => createVNode(VListChildren, {
|
|
"items": children
|
|
}, slots)
|
|
}) : slots.item ? slots.item({
|
|
props: itemProps
|
|
}) : createVNode(VListItem, mergeProps(itemProps, {
|
|
"value": props.returnObject ? item : itemProps.value
|
|
}), slotsWithItem);
|
|
}));
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/composables/list-items.mjs
|
|
var makeItemsProps = propsFactory({
|
|
items: {
|
|
type: Array,
|
|
default: () => []
|
|
},
|
|
itemTitle: {
|
|
type: [String, Array, Function],
|
|
default: "title"
|
|
},
|
|
itemValue: {
|
|
type: [String, Array, Function],
|
|
default: "value"
|
|
},
|
|
itemChildren: {
|
|
type: [Boolean, String, Array, Function],
|
|
default: "children"
|
|
},
|
|
itemProps: {
|
|
type: [Boolean, String, Array, Function],
|
|
default: "props"
|
|
},
|
|
returnObject: Boolean,
|
|
valueComparator: {
|
|
type: Function,
|
|
default: deepEqual
|
|
}
|
|
}, "list-items");
|
|
function transformItem(props, item) {
|
|
const title = getPropertyFromItem(item, props.itemTitle, item);
|
|
const value = getPropertyFromItem(item, props.itemValue, title);
|
|
const children = getPropertyFromItem(item, props.itemChildren);
|
|
const itemProps = props.itemProps === true ? typeof item === "object" && item != null && !Array.isArray(item) ? "children" in item ? omit(item, ["children"]) : item : void 0 : getPropertyFromItem(item, props.itemProps);
|
|
const _props = {
|
|
title,
|
|
value,
|
|
...itemProps
|
|
};
|
|
return {
|
|
title: String(_props.title ?? ""),
|
|
value: _props.value,
|
|
props: _props,
|
|
children: Array.isArray(children) ? transformItems(props, children) : void 0,
|
|
raw: item
|
|
};
|
|
}
|
|
function transformItems(props, items) {
|
|
const array = [];
|
|
for (const item of items) {
|
|
array.push(transformItem(props, item));
|
|
}
|
|
return array;
|
|
}
|
|
function useItems(props) {
|
|
const items = computed(() => transformItems(props, props.items));
|
|
const hasNullItem = computed(() => items.value.some((item) => item.value === null));
|
|
function transformIn(value) {
|
|
if (!hasNullItem.value) {
|
|
value = value.filter((v) => v !== null);
|
|
}
|
|
return value.map((v) => {
|
|
if (props.returnObject && typeof v === "string") {
|
|
return transformItem(props, v);
|
|
}
|
|
return items.value.find((item) => props.valueComparator(v, item.value)) || transformItem(props, v);
|
|
});
|
|
}
|
|
function transformOut(value) {
|
|
return props.returnObject ? value.map((_ref) => {
|
|
let {
|
|
raw
|
|
} = _ref;
|
|
return raw;
|
|
}) : value.map((_ref2) => {
|
|
let {
|
|
value: value2
|
|
} = _ref2;
|
|
return value2;
|
|
});
|
|
}
|
|
return {
|
|
items,
|
|
transformIn,
|
|
transformOut
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/components/VList/VList.mjs
|
|
function isPrimitive(value) {
|
|
return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
|
|
}
|
|
function transformItem2(props, item) {
|
|
const type = getPropertyFromItem(item, props.itemType, "item");
|
|
const title = isPrimitive(item) ? item : getPropertyFromItem(item, props.itemTitle);
|
|
const value = getPropertyFromItem(item, props.itemValue, void 0);
|
|
const children = getPropertyFromItem(item, props.itemChildren);
|
|
const itemProps = props.itemProps === true ? omit(item, ["children"]) : getPropertyFromItem(item, props.itemProps);
|
|
const _props = {
|
|
title,
|
|
value,
|
|
...itemProps
|
|
};
|
|
return {
|
|
type,
|
|
title: _props.title,
|
|
value: _props.value,
|
|
props: _props,
|
|
children: type === "item" && children ? transformItems2(props, children) : void 0,
|
|
raw: item
|
|
};
|
|
}
|
|
function transformItems2(props, items) {
|
|
const array = [];
|
|
for (const item of items) {
|
|
array.push(transformItem2(props, item));
|
|
}
|
|
return array;
|
|
}
|
|
function useListItems(props) {
|
|
const items = computed(() => transformItems2(props, props.items));
|
|
return {
|
|
items
|
|
};
|
|
}
|
|
var makeVListProps = propsFactory({
|
|
baseColor: String,
|
|
/* @deprecated */
|
|
activeColor: String,
|
|
activeClass: String,
|
|
bgColor: String,
|
|
disabled: Boolean,
|
|
expandIcon: String,
|
|
collapseIcon: String,
|
|
lines: {
|
|
type: [Boolean, String],
|
|
default: "one"
|
|
},
|
|
slim: Boolean,
|
|
nav: Boolean,
|
|
...makeNestedProps({
|
|
selectStrategy: "single-leaf",
|
|
openStrategy: "list"
|
|
}),
|
|
...makeBorderProps(),
|
|
...makeComponentProps(),
|
|
...makeDensityProps(),
|
|
...makeDimensionProps(),
|
|
...makeElevationProps(),
|
|
itemType: {
|
|
type: String,
|
|
default: "type"
|
|
},
|
|
...makeItemsProps(),
|
|
...makeRoundedProps(),
|
|
...makeTagProps(),
|
|
...makeThemeProps(),
|
|
...makeVariantProps({
|
|
variant: "text"
|
|
})
|
|
}, "VList");
|
|
var VList = genericComponent()({
|
|
name: "VList",
|
|
props: makeVListProps(),
|
|
emits: {
|
|
"update:selected": (value) => true,
|
|
"update:opened": (value) => true,
|
|
"click:open": (value) => true,
|
|
"click:select": (value) => true
|
|
},
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
const {
|
|
items
|
|
} = useListItems(props);
|
|
const {
|
|
themeClasses
|
|
} = provideTheme(props);
|
|
const {
|
|
backgroundColorClasses,
|
|
backgroundColorStyles
|
|
} = useBackgroundColor(toRef(props, "bgColor"));
|
|
const {
|
|
borderClasses
|
|
} = useBorder(props);
|
|
const {
|
|
densityClasses
|
|
} = useDensity(props);
|
|
const {
|
|
dimensionStyles
|
|
} = useDimension(props);
|
|
const {
|
|
elevationClasses
|
|
} = useElevation(props);
|
|
const {
|
|
roundedClasses
|
|
} = useRounded(props);
|
|
const {
|
|
open,
|
|
select
|
|
} = useNested(props);
|
|
const lineClasses = computed(() => props.lines ? `v-list--${props.lines}-line` : void 0);
|
|
const activeColor = toRef(props, "activeColor");
|
|
const baseColor = toRef(props, "baseColor");
|
|
const color = toRef(props, "color");
|
|
createList();
|
|
provideDefaults({
|
|
VListGroup: {
|
|
activeColor,
|
|
baseColor,
|
|
color,
|
|
expandIcon: toRef(props, "expandIcon"),
|
|
collapseIcon: toRef(props, "collapseIcon")
|
|
},
|
|
VListItem: {
|
|
activeClass: toRef(props, "activeClass"),
|
|
activeColor,
|
|
baseColor,
|
|
color,
|
|
density: toRef(props, "density"),
|
|
disabled: toRef(props, "disabled"),
|
|
lines: toRef(props, "lines"),
|
|
nav: toRef(props, "nav"),
|
|
slim: toRef(props, "slim"),
|
|
variant: toRef(props, "variant")
|
|
}
|
|
});
|
|
const isFocused = shallowRef(false);
|
|
const contentRef = ref();
|
|
function onFocusin(e) {
|
|
isFocused.value = true;
|
|
}
|
|
function onFocusout(e) {
|
|
isFocused.value = false;
|
|
}
|
|
function onFocus(e) {
|
|
var _a;
|
|
if (!isFocused.value && !(e.relatedTarget && ((_a = contentRef.value) == null ? void 0 : _a.contains(e.relatedTarget)))) focus();
|
|
}
|
|
function onKeydown(e) {
|
|
if (!contentRef.value) return;
|
|
if (e.key === "ArrowDown") {
|
|
focus("next");
|
|
} else if (e.key === "ArrowUp") {
|
|
focus("prev");
|
|
} else if (e.key === "Home") {
|
|
focus("first");
|
|
} else if (e.key === "End") {
|
|
focus("last");
|
|
} else {
|
|
return;
|
|
}
|
|
e.preventDefault();
|
|
}
|
|
function onMousedown(e) {
|
|
isFocused.value = true;
|
|
}
|
|
function focus(location) {
|
|
if (contentRef.value) {
|
|
return focusChild(contentRef.value, location);
|
|
}
|
|
}
|
|
useRender(() => {
|
|
return createVNode(props.tag, {
|
|
"ref": contentRef,
|
|
"class": ["v-list", {
|
|
"v-list--disabled": props.disabled,
|
|
"v-list--nav": props.nav,
|
|
"v-list--slim": props.slim
|
|
}, themeClasses.value, backgroundColorClasses.value, borderClasses.value, densityClasses.value, elevationClasses.value, lineClasses.value, roundedClasses.value, props.class],
|
|
"style": [backgroundColorStyles.value, dimensionStyles.value, props.style],
|
|
"tabindex": props.disabled || isFocused.value ? -1 : 0,
|
|
"role": "listbox",
|
|
"aria-activedescendant": void 0,
|
|
"onFocusin": onFocusin,
|
|
"onFocusout": onFocusout,
|
|
"onFocus": onFocus,
|
|
"onKeydown": onKeydown,
|
|
"onMousedown": onMousedown
|
|
}, {
|
|
default: () => [createVNode(VListChildren, {
|
|
"items": items.value,
|
|
"returnObject": props.returnObject
|
|
}, slots)]
|
|
});
|
|
});
|
|
return {
|
|
open,
|
|
select,
|
|
focus
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListImg.mjs
|
|
var VListImg = createSimpleFunctional("v-list-img");
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItemAction.mjs
|
|
var makeVListItemActionProps = propsFactory({
|
|
start: Boolean,
|
|
end: Boolean,
|
|
...makeComponentProps(),
|
|
...makeTagProps()
|
|
}, "VListItemAction");
|
|
var VListItemAction = genericComponent()({
|
|
name: "VListItemAction",
|
|
props: makeVListItemActionProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
useRender(() => createVNode(props.tag, {
|
|
"class": ["v-list-item-action", {
|
|
"v-list-item-action--start": props.start,
|
|
"v-list-item-action--end": props.end
|
|
}, props.class],
|
|
"style": props.style
|
|
}, slots));
|
|
return {};
|
|
}
|
|
});
|
|
|
|
// node_modules/vuetify/lib/components/VList/VListItemMedia.mjs
|
|
var makeVListItemMediaProps = propsFactory({
|
|
start: Boolean,
|
|
end: Boolean,
|
|
...makeComponentProps(),
|
|
...makeTagProps()
|
|
}, "VListItemMedia");
|
|
var VListItemMedia = genericComponent()({
|
|
name: "VListItemMedia",
|
|
props: makeVListItemMediaProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
useRender(() => {
|
|
return createVNode(props.tag, {
|
|
"class": ["v-list-item-media", {
|
|
"v-list-item-media--start": props.start,
|
|
"v-list-item-media--end": props.end
|
|
}, props.class],
|
|
"style": props.style
|
|
}, slots);
|
|
});
|
|
return {};
|
|
}
|
|
});
|
|
|
|
export {
|
|
VListGroup,
|
|
VListItemSubtitle,
|
|
VListItemTitle,
|
|
VListItem,
|
|
VListSubheader,
|
|
makeItemsProps,
|
|
useItems,
|
|
VList,
|
|
VListImg,
|
|
VListItemAction,
|
|
VListItemMedia
|
|
};
|
|
//# sourceMappingURL=chunk-GCLA33SA.js.map
|