Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/vuetify/lib/components/VDataIterator/VDataIterator.mjs

@@ -0,0 +1,164 @@
+import { createVNode as _createVNode } from "vue";
+// Components
+import { makeDataTableExpandProps, provideExpanded } from "../VDataTable/composables/expand.mjs";
+import { makeDataTableGroupProps, provideGroupBy, useGroupedItems } from "../VDataTable/composables/group.mjs";
+import { useOptions } from "../VDataTable/composables/options.mjs";
+import { createPagination, makeDataTablePaginateProps, providePagination, usePaginatedItems } from "../VDataTable/composables/paginate.mjs";
+import { makeDataTableSelectProps, provideSelection } from "../VDataTable/composables/select.mjs";
+import { createSort, makeDataTableSortProps, provideSort, useSortedItems } from "../VDataTable/composables/sort.mjs"; // Composables
+import { makeDataIteratorItemsProps, useDataIteratorItems } from "./composables/items.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { makeFilterProps, useFilter } from "../../composables/filter.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs";
+import { makeTagProps } from "../../composables/tag.mjs"; // Utilities
+import { computed, toRef } from 'vue';
+import { genericComponent, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVDataIteratorProps = propsFactory({
+  search: String,
+  loading: Boolean,
+  ...makeComponentProps(),
+  ...makeDataIteratorItemsProps(),
+  ...makeDataTableSelectProps(),
+  ...makeDataTableSortProps(),
+  ...makeDataTablePaginateProps({
+    itemsPerPage: 5
+  }),
+  ...makeDataTableExpandProps(),
+  ...makeDataTableGroupProps(),
+  ...makeFilterProps(),
+  ...makeTagProps()
+}, 'VDataIterator');
+export const VDataIterator = genericComponent()({
+  name: 'VDataIterator',
+  props: makeVDataIteratorProps(),
+  emits: {
+    'update:modelValue': value => true,
+    'update:groupBy': value => true,
+    'update:page': value => true,
+    'update:itemsPerPage': value => true,
+    'update:sortBy': value => true,
+    'update:options': value => true,
+    'update:expanded': value => true,
+    'update:currentItems': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const groupBy = useProxiedModel(props, 'groupBy');
+    const search = toRef(props, 'search');
+    const {
+      items
+    } = useDataIteratorItems(props);
+    const {
+      filteredItems
+    } = useFilter(props, items, search, {
+      transform: item => item.raw
+    });
+    const {
+      sortBy,
+      multiSort,
+      mustSort
+    } = createSort(props);
+    const {
+      page,
+      itemsPerPage
+    } = createPagination(props);
+    const {
+      toggleSort
+    } = provideSort({
+      sortBy,
+      multiSort,
+      mustSort,
+      page
+    });
+    const {
+      sortByWithGroups,
+      opened,
+      extractRows,
+      isGroupOpen,
+      toggleGroup
+    } = provideGroupBy({
+      groupBy,
+      sortBy
+    });
+    const {
+      sortedItems
+    } = useSortedItems(props, filteredItems, sortByWithGroups);
+    const {
+      flatItems
+    } = useGroupedItems(sortedItems, groupBy, opened);
+    const itemsLength = computed(() => flatItems.value.length);
+    const {
+      startIndex,
+      stopIndex,
+      pageCount,
+      prevPage,
+      nextPage,
+      setItemsPerPage,
+      setPage
+    } = providePagination({
+      page,
+      itemsPerPage,
+      itemsLength
+    });
+    const {
+      paginatedItems
+    } = usePaginatedItems({
+      items: flatItems,
+      startIndex,
+      stopIndex,
+      itemsPerPage
+    });
+    const paginatedItemsWithoutGroups = computed(() => extractRows(paginatedItems.value));
+    const {
+      isSelected,
+      select,
+      selectAll,
+      toggleSelect
+    } = provideSelection(props, {
+      allItems: items,
+      currentPage: paginatedItemsWithoutGroups
+    });
+    const {
+      isExpanded,
+      toggleExpand
+    } = provideExpanded(props);
+    useOptions({
+      page,
+      itemsPerPage,
+      sortBy,
+      groupBy,
+      search
+    });
+    const slotProps = computed(() => ({
+      page: page.value,
+      itemsPerPage: itemsPerPage.value,
+      sortBy: sortBy.value,
+      pageCount: pageCount.value,
+      toggleSort,
+      prevPage,
+      nextPage,
+      setPage,
+      setItemsPerPage,
+      isSelected,
+      select,
+      selectAll,
+      toggleSelect,
+      isExpanded,
+      toggleExpand,
+      isGroupOpen,
+      toggleGroup,
+      items: paginatedItemsWithoutGroups.value,
+      groupedItems: paginatedItems.value
+    }));
+    useRender(() => _createVNode(props.tag, {
+      "class": ['v-data-iterator', props.class],
+      "style": props.style
+    }, {
+      default: () => [slots.header?.(slotProps.value), !paginatedItems.value.length ? slots['no-data']?.() : slots.default?.(slotProps.value), slots.footer?.(slotProps.value)]
+    }));
+    return {};
+  }
+});
+//# sourceMappingURL=VDataIterator.mjs.map

VApp/node_modules/vuetify/lib/components/VDataIterator/composables/items.mjs

@@ -0,0 +1,43 @@
+// Utilities
+import { computed } from 'vue';
+import { getPropertyFromItem, propsFactory } from "../../../util/index.mjs"; // Types
+// Composables
+export const makeDataIteratorItemsProps = propsFactory({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  itemValue: {
+    type: [String, Array, Function],
+    default: 'id'
+  },
+  itemSelectable: {
+    type: [String, Array, Function],
+    default: null
+  },
+  returnObject: Boolean
+}, 'DataIterator-items');
+export function transformItem(props, item) {
+  const value = props.returnObject ? item : getPropertyFromItem(item, props.itemValue);
+  const selectable = getPropertyFromItem(item, props.itemSelectable, true);
+  return {
+    type: 'item',
+    value,
+    selectable,
+    raw: item
+  };
+}
+export function transformItems(props, items) {
+  const array = [];
+  for (const item of items) {
+    array.push(transformItem(props, item));
+  }
+  return array;
+}
+export function useDataIteratorItems(props) {
+  const items = computed(() => transformItems(props, props.items));
+  return {
+    items
+  };
+}
+//# sourceMappingURL=items.mjs.map

VApp/node_modules/vuetify/lib/components/VDataIterator/composables/items.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.mjs","names":["computed","getPropertyFromItem","propsFactory","makeDataIteratorItemsProps","items","type","Array","default","itemValue","String","Function","itemSelectable","returnObject","Boolean","transformItem","props","item","value","selectable","raw","transformItems","array","push","useDataIteratorItems"],"sources":["../../../../src/components/VDataIterator/composables/items.ts"],"sourcesContent":["// Utilities\nimport { computed } from 'vue'\nimport { getPropertyFromItem, propsFactory } from '@/util'\n\n// Types\nimport type { PropType } from 'vue'\nimport type { GroupableItem } from '@/components/VDataTable/composables/group'\nimport type { SelectableItem } from '@/components/VDataTable/composables/select'\nimport type { SelectItemKey } from '@/util'\n\nexport interface DataIteratorItemProps {\n  items: any[]\n  itemValue: SelectItemKey\n  itemSelectable: SelectItemKey\n  returnObject: boolean\n}\n\nexport interface DataIteratorItem<T = any> extends GroupableItem<T>, SelectableItem {\n  value: unknown\n}\n\n// Composables\nexport const makeDataIteratorItemsProps = propsFactory({\n  items: {\n    type: Array as PropType<DataIteratorItemProps['items']>,\n    default: () => ([]),\n  },\n  itemValue: {\n    type: [String, Array, Function] as PropType<SelectItemKey>,\n    default: 'id',\n  },\n  itemSelectable: {\n    type: [String, Array, Function] as PropType<SelectItemKey>,\n    default: null,\n  },\n  returnObject: Boolean,\n}, 'DataIterator-items')\n\nexport function transformItem (\n  props: Omit<DataIteratorItemProps, 'items'>,\n  item: any\n): DataIteratorItem {\n  const value = props.returnObject ? item : getPropertyFromItem(item, props.itemValue)\n  const selectable = getPropertyFromItem(item, props.itemSelectable, true)\n\n  return {\n    type: 'item',\n    value,\n    selectable,\n    raw: item,\n  }\n}\n\nexport function transformItems (\n  props: Omit<DataIteratorItemProps, 'items'>,\n  items: DataIteratorItemProps['items']\n) {\n  const array: DataIteratorItem[] = []\n\n  for (const item of items) {\n    array.push(transformItem(props, item))\n  }\n\n  return array\n}\n\nexport function useDataIteratorItems (props: DataIteratorItemProps) {\n  const items = computed(() => transformItems(props, props.items))\n\n  return { items }\n}\n"],"mappings":"AAAA;AACA,SAASA,QAAQ,QAAQ,KAAK;AAAA,SACrBC,mBAAmB,EAAEC,YAAY,mCAE1C;AAiBA;AACA,OAAO,MAAMC,0BAA0B,GAAGD,YAAY,CAAC;EACrDE,KAAK,EAAE;IACLC,IAAI,EAAEC,KAAiD;IACvDC,OAAO,EAAEA,CAAA,KAAO;EAClB,CAAC;EACDC,SAAS,EAAE;IACTH,IAAI,EAAE,CAACI,MAAM,EAAEH,KAAK,EAAEI,QAAQ,CAA4B;IAC1DH,OAAO,EAAE;EACX,CAAC;EACDI,cAAc,EAAE;IACdN,IAAI,EAAE,CAACI,MAAM,EAAEH,KAAK,EAAEI,QAAQ,CAA4B;IAC1DH,OAAO,EAAE;EACX,CAAC;EACDK,YAAY,EAAEC;AAChB,CAAC,EAAE,oBAAoB,CAAC;AAExB,OAAO,SAASC,aAAaA,CAC3BC,KAA2C,EAC3CC,IAAS,EACS;EAClB,MAAMC,KAAK,GAAGF,KAAK,CAACH,YAAY,GAAGI,IAAI,GAAGf,mBAAmB,CAACe,IAAI,EAAED,KAAK,CAACP,SAAS,CAAC;EACpF,MAAMU,UAAU,GAAGjB,mBAAmB,CAACe,IAAI,EAAED,KAAK,CAACJ,cAAc,EAAE,IAAI,CAAC;EAExE,OAAO;IACLN,IAAI,EAAE,MAAM;IACZY,KAAK;IACLC,UAAU;IACVC,GAAG,EAAEH;EACP,CAAC;AACH;AAEA,OAAO,SAASI,cAAcA,CAC5BL,KAA2C,EAC3CX,KAAqC,EACrC;EACA,MAAMiB,KAAyB,GAAG,EAAE;EAEpC,KAAK,MAAML,IAAI,IAAIZ,KAAK,EAAE;IACxBiB,KAAK,CAACC,IAAI,CAACR,aAAa,CAACC,KAAK,EAAEC,IAAI,CAAC,CAAC;EACxC;EAEA,OAAOK,KAAK;AACd;AAEA,OAAO,SAASE,oBAAoBA,CAAER,KAA4B,EAAE;EAClE,MAAMX,KAAK,GAAGJ,QAAQ,CAAC,MAAMoB,cAAc,CAACL,KAAK,EAAEA,KAAK,CAACX,KAAK,CAAC,CAAC;EAEhE,OAAO;IAAEA;EAAM,CAAC;AAClB"}

VApp/node_modules/vuetify/lib/components/VDataIterator/index.d.mts

@@ -0,0 +1,710 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, PropType, Ref } from 'vue';
+
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): Partial<Pick<T, U>>;
+}
+
+declare function deepEqual(a: any, b: any): boolean;
+type SelectItemKey<T = Record<string, any>> = boolean | null | undefined | string | readonly (string | number)[] | ((item: T, fallback?: any) => any);
+type EventProp<T extends any[] = any[], F = (...args: T) => void> = F;
+declare const EventProp: <T extends any[] = any[]>() => PropType<(...args: T) => void>;
+
+type ExpandProps = {
+    expandOnClick: boolean;
+    expanded: readonly string[];
+    'onUpdate:expanded': ((value: any[]) => void) | undefined;
+};
+declare function provideExpanded(props: ExpandProps): {
+    expand: (item: DataTableItem, value: boolean) => void;
+    expanded: Ref<Set<string>> & {
+        readonly externalValue: readonly string[];
+    };
+    expandOnClick: Ref<boolean>;
+    isExpanded: (item: DataTableItem) => boolean;
+    toggleExpand: (item: DataTableItem) => void;
+};
+
+type SortItem = {
+    key: string;
+    order?: boolean | 'asc' | 'desc';
+};
+declare function provideSort(options: {
+    sortBy: Ref<readonly SortItem[]>;
+    mustSort: Ref<boolean>;
+    multiSort: Ref<boolean>;
+    page?: Ref<number>;
+}): {
+    sortBy: Ref<readonly SortItem[]>;
+    toggleSort: (column: InternalDataTableHeader) => void;
+    isSorted: (column: InternalDataTableHeader) => boolean;
+};
+
+interface GroupableItem<T = any> {
+    type: 'item';
+    raw: T;
+}
+interface Group<T = any> {
+    type: 'group';
+    depth: number;
+    id: string;
+    key: string;
+    value: any;
+    items: readonly (T | Group<T>)[];
+}
+declare function provideGroupBy(options: {
+    groupBy: Ref<readonly SortItem[]>;
+    sortBy: Ref<readonly SortItem[]>;
+}): {
+    sortByWithGroups: vue.ComputedRef<SortItem[]>;
+    toggleGroup: (group: Group) => void;
+    opened: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
+    groupBy: Ref<readonly SortItem[]>;
+    extractRows: <T extends GroupableItem<any>>(items: readonly (T | Group<T>)[]) => T[];
+    isGroupOpen: (group: Group) => boolean;
+};
+
+interface DataTableItemProps {
+    items: any[];
+    itemValue: SelectItemKey;
+    itemSelectable: SelectItemKey;
+    returnObject: boolean;
+}
+
+interface SelectableItem {
+    value: any;
+    selectable: boolean;
+}
+type SelectionProps = Pick<DataTableItemProps, 'itemValue'> & {
+    modelValue: readonly any[];
+    selectStrategy: 'single' | 'page' | 'all';
+    valueComparator: typeof deepEqual;
+    'onUpdate:modelValue': EventProp<[any[]]> | undefined;
+};
+declare function provideSelection(props: SelectionProps, { allItems, currentPage }: {
+    allItems: Ref<SelectableItem[]>;
+    currentPage: Ref<SelectableItem[]>;
+}): {
+    toggleSelect: (item: SelectableItem) => void;
+    select: (items: SelectableItem[], value: boolean) => void;
+    selectAll: (value: boolean) => void;
+    isSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+    isSomeSelected: (items: SelectableItem | SelectableItem[]) => boolean;
+    someSelected: vue.ComputedRef<boolean>;
+    allSelected: vue.ComputedRef<boolean>;
+    showSelectAll: boolean;
+};
+
+/**
+ * - match without highlight
+ * - single match (index), length already known
+ * - single match (start, end)
+ * - multiple matches (start, end), probably shouldn't overlap
+ */
+type FilterMatch = boolean | number | [number, number] | [number, number][];
+type FilterFunction = (value: string, query: string, item?: InternalItem) => FilterMatch;
+type FilterKeyFunctions = Record<string, FilterFunction>;
+type FilterKeys = string | string[];
+type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+interface InternalItem<T = any> {
+    value: any;
+    raw: T;
+}
+
+type DataTableCompareFunction<T = any> = (a: T, b: T) => number;
+type DataTableHeader = {
+    key?: 'data-table-group' | 'data-table-select' | 'data-table-expand' | (string & {});
+    value?: SelectItemKey;
+    title?: string;
+    fixed?: boolean;
+    align?: 'start' | 'end' | 'center';
+    width?: number | string;
+    minWidth?: string;
+    maxWidth?: string;
+    headerProps?: Record<string, any>;
+    cellProps?: HeaderCellProps;
+    sortable?: boolean;
+    sort?: DataTableCompareFunction;
+    sortRaw?: DataTableCompareFunction;
+    filter?: FilterFunction;
+    children?: DataTableHeader[];
+};
+type InternalDataTableHeader = Omit<DataTableHeader, 'key' | 'value' | 'children'> & {
+    key: string | null;
+    value: SelectItemKey | null;
+    sortable: boolean;
+    fixedOffset?: number;
+    lastFixed?: boolean;
+    colspan?: number;
+    rowspan?: number;
+    children?: InternalDataTableHeader[];
+};
+interface DataTableItem<T = any> extends InternalItem<T>, GroupableItem<T>, SelectableItem {
+    key: any;
+    index: number;
+    columns: {
+        [key: string]: any;
+    };
+}
+type ItemSlotBase<T> = {
+    index: number;
+    item: T;
+    internalItem: DataTableItem<T>;
+    isExpanded: ReturnType<typeof provideExpanded>['isExpanded'];
+    toggleExpand: ReturnType<typeof provideExpanded>['toggleExpand'];
+    isSelected: ReturnType<typeof provideSelection>['isSelected'];
+    toggleSelect: ReturnType<typeof provideSelection>['toggleSelect'];
+};
+type ItemKeySlot<T> = ItemSlotBase<T> & {
+    value: any;
+    column: InternalDataTableHeader;
+};
+type HeaderCellProps = Record<string, any> | ((data: Pick<ItemKeySlot<any>, 'index' | 'item' | 'internalItem' | 'value'>) => Record<string, any>);
+
+declare function providePagination(options: {
+    page: Ref<number>;
+    itemsPerPage: Ref<number>;
+    itemsLength: Ref<number>;
+}): {
+    page: Ref<number>;
+    itemsPerPage: Ref<number>;
+    startIndex: vue.ComputedRef<number>;
+    stopIndex: vue.ComputedRef<number>;
+    pageCount: vue.ComputedRef<number>;
+    itemsLength: Ref<number>;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPage: (value: number) => void;
+    setItemsPerPage: (value: number) => void;
+};
+
+interface DataIteratorItem<T = any> extends GroupableItem<T>, SelectableItem {
+    value: unknown;
+}
+
+type VDataIteratorSlotProps = {
+    page: number;
+    itemsPerPage: number;
+    sortBy: readonly SortItem[];
+    pageCount: number;
+    toggleSort: ReturnType<typeof provideSort>['toggleSort'];
+    prevPage: ReturnType<typeof providePagination>['prevPage'];
+    nextPage: ReturnType<typeof providePagination>['nextPage'];
+    setPage: ReturnType<typeof providePagination>['setPage'];
+    setItemsPerPage: ReturnType<typeof providePagination>['setItemsPerPage'];
+    isSelected: ReturnType<typeof provideSelection>['isSelected'];
+    select: ReturnType<typeof provideSelection>['select'];
+    selectAll: ReturnType<typeof provideSelection>['selectAll'];
+    toggleSelect: ReturnType<typeof provideSelection>['toggleSelect'];
+    isExpanded: ReturnType<typeof provideExpanded>['isExpanded'];
+    toggleExpand: ReturnType<typeof provideExpanded>['toggleExpand'];
+    isGroupOpen: ReturnType<typeof provideGroupBy>['isGroupOpen'];
+    toggleGroup: ReturnType<typeof provideGroupBy>['toggleGroup'];
+    items: readonly DataIteratorItem[];
+    groupedItems: readonly (DataIteratorItem | Group<DataIteratorItem>)[];
+};
+declare const VDataIterator: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        page: string | number;
+        loading: boolean;
+        style: vue.StyleValue;
+        expanded: readonly string[];
+        tag: string;
+        sortBy: readonly SortItem[];
+        items: any[];
+        modelValue: readonly any[];
+        valueComparator: typeof deepEqual;
+        selectStrategy: "all" | "page" | "single";
+        returnObject: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        itemValue: SelectItemKey;
+        multiSort: boolean;
+        mustSort: boolean;
+        groupBy: readonly SortItem[];
+        itemSelectable: SelectItemKey;
+        showSelect: boolean;
+        expandOnClick: boolean;
+        showExpand: boolean;
+        itemsPerPage: NonNullable<string | number>;
+    } & {
+        search?: string | undefined;
+        class?: any;
+        customFilter?: FilterFunction | undefined;
+        customKeyFilter?: FilterKeyFunctions | undefined;
+        filterKeys?: FilterKeys | undefined;
+        customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: VDataIteratorSlotProps) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:header"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:footer"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+        "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+        "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+        "onUpdate:expanded"?: ((value: any) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
+        "onUpdate:options"?: ((value: any) => any) | undefined;
+        "onUpdate:currentItems"?: ((value: any) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'update:modelValue': (value: any[]) => boolean;
+        'update:groupBy': (value: any) => boolean;
+        'update:page': (value: number) => boolean;
+        'update:itemsPerPage': (value: number) => boolean;
+        'update:sortBy': (value: any) => boolean;
+        'update:options': (value: any) => boolean;
+        'update:expanded': (value: any) => boolean;
+        'update:currentItems': (value: any) => boolean;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        page: string | number;
+        loading: boolean;
+        style: vue.StyleValue;
+        expanded: readonly string[];
+        tag: string;
+        sortBy: readonly SortItem[];
+        items: any[];
+        modelValue: readonly any[];
+        valueComparator: typeof deepEqual;
+        selectStrategy: "all" | "page" | "single";
+        returnObject: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        itemValue: SelectItemKey;
+        multiSort: boolean;
+        mustSort: boolean;
+        groupBy: readonly SortItem[];
+        itemSelectable: SelectItemKey;
+        showSelect: boolean;
+        expandOnClick: boolean;
+        showExpand: boolean;
+        itemsPerPage: NonNullable<string | number>;
+    } & {
+        search?: string | undefined;
+        class?: any;
+        customFilter?: FilterFunction | undefined;
+        customKeyFilter?: FilterKeyFunctions | undefined;
+        filterKeys?: FilterKeys | undefined;
+        customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: VDataIteratorSlotProps) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:header"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:footer"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+        "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+        "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+        "onUpdate:expanded"?: ((value: any) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
+        "onUpdate:options"?: ((value: any) => any) | undefined;
+        "onUpdate:currentItems"?: ((value: any) => any) | undefined;
+    }, {
+        page: string | number;
+        loading: boolean;
+        style: vue.StyleValue;
+        expanded: readonly string[];
+        tag: string;
+        sortBy: readonly SortItem[];
+        items: any[];
+        modelValue: readonly any[];
+        valueComparator: typeof deepEqual;
+        selectStrategy: "all" | "page" | "single";
+        returnObject: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        itemValue: SelectItemKey;
+        multiSort: boolean;
+        mustSort: boolean;
+        groupBy: readonly SortItem[];
+        itemSelectable: SelectItemKey;
+        showSelect: boolean;
+        expandOnClick: boolean;
+        showExpand: boolean;
+        itemsPerPage: NonNullable<string | number>;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        header: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        footer: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        page: string | number;
+        loading: boolean;
+        style: vue.StyleValue;
+        expanded: readonly string[];
+        tag: string;
+        sortBy: readonly SortItem[];
+        items: any[];
+        modelValue: readonly any[];
+        valueComparator: typeof deepEqual;
+        selectStrategy: "all" | "page" | "single";
+        returnObject: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        itemValue: SelectItemKey;
+        multiSort: boolean;
+        mustSort: boolean;
+        groupBy: readonly SortItem[];
+        itemSelectable: SelectItemKey;
+        showSelect: boolean;
+        expandOnClick: boolean;
+        showExpand: boolean;
+        itemsPerPage: NonNullable<string | number>;
+    } & {
+        search?: string | undefined;
+        class?: any;
+        customFilter?: FilterFunction | undefined;
+        customKeyFilter?: FilterKeyFunctions | undefined;
+        filterKeys?: FilterKeys | undefined;
+        customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: VDataIteratorSlotProps) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            header?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            footer?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+            'no-data'?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:header"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:footer"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+        "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+        "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+        "onUpdate:expanded"?: ((value: any) => any) | undefined;
+        "onUpdate:page"?: ((value: number) => any) | undefined;
+        "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
+        "onUpdate:options"?: ((value: any) => any) | undefined;
+        "onUpdate:currentItems"?: ((value: any) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        page: string | number;
+        loading: boolean;
+        style: vue.StyleValue;
+        expanded: readonly string[];
+        tag: string;
+        sortBy: readonly SortItem[];
+        items: any[];
+        modelValue: readonly any[];
+        valueComparator: typeof deepEqual;
+        selectStrategy: "all" | "page" | "single";
+        returnObject: boolean;
+        filterMode: FilterMode;
+        noFilter: boolean;
+        itemValue: SelectItemKey;
+        multiSort: boolean;
+        mustSort: boolean;
+        groupBy: readonly SortItem[];
+        itemSelectable: SelectItemKey;
+        showSelect: boolean;
+        expandOnClick: boolean;
+        showExpand: boolean;
+        itemsPerPage: NonNullable<string | number>;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    page: string | number;
+    loading: boolean;
+    style: vue.StyleValue;
+    expanded: readonly string[];
+    tag: string;
+    sortBy: readonly SortItem[];
+    items: any[];
+    modelValue: readonly any[];
+    valueComparator: typeof deepEqual;
+    selectStrategy: "all" | "page" | "single";
+    returnObject: boolean;
+    filterMode: FilterMode;
+    noFilter: boolean;
+    itemValue: SelectItemKey;
+    multiSort: boolean;
+    mustSort: boolean;
+    groupBy: readonly SortItem[];
+    itemSelectable: SelectItemKey;
+    showSelect: boolean;
+    expandOnClick: boolean;
+    showExpand: boolean;
+    itemsPerPage: NonNullable<string | number>;
+} & {
+    search?: string | undefined;
+    class?: any;
+    customFilter?: FilterFunction | undefined;
+    customKeyFilter?: FilterKeyFunctions | undefined;
+    filterKeys?: FilterKeys | undefined;
+    customKeySort?: Record<string, DataTableCompareFunction> | undefined;
+} & {
+    $children?: vue.VNodeChild | {
+        default?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        header?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        footer?: ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        'no-data'?: (() => vue.VNodeChild) | undefined;
+    } | ((arg: VDataIteratorSlotProps) => vue.VNodeChild);
+    'v-slots'?: {
+        default?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        header?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        footer?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+        'no-data'?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+    "v-slot:header"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+    "v-slot:footer"?: false | ((arg: VDataIteratorSlotProps) => vue.VNodeChild) | undefined;
+    "v-slot:no-data"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((value: any[]) => any) | undefined;
+    "onUpdate:sortBy"?: ((value: any) => any) | undefined;
+    "onUpdate:groupBy"?: ((value: any) => any) | undefined;
+    "onUpdate:expanded"?: ((value: any) => any) | undefined;
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+    "onUpdate:itemsPerPage"?: ((value: number) => any) | undefined;
+    "onUpdate:options"?: ((value: any) => any) | undefined;
+    "onUpdate:currentItems"?: ((value: any) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (value: any[]) => boolean;
+    'update:groupBy': (value: any) => boolean;
+    'update:page': (value: number) => boolean;
+    'update:itemsPerPage': (value: number) => boolean;
+    'update:sortBy': (value: any) => boolean;
+    'update:options': (value: any) => boolean;
+    'update:expanded': (value: any) => boolean;
+    'update:currentItems': (value: any) => boolean;
+}, string, {
+    page: string | number;
+    loading: boolean;
+    style: vue.StyleValue;
+    expanded: readonly string[];
+    tag: string;
+    sortBy: readonly SortItem[];
+    items: any[];
+    modelValue: readonly any[];
+    valueComparator: typeof deepEqual;
+    selectStrategy: "all" | "page" | "single";
+    returnObject: boolean;
+    filterMode: FilterMode;
+    noFilter: boolean;
+    itemValue: SelectItemKey;
+    multiSort: boolean;
+    mustSort: boolean;
+    groupBy: readonly SortItem[];
+    itemSelectable: SelectItemKey;
+    showSelect: boolean;
+    expandOnClick: boolean;
+    showExpand: boolean;
+    itemsPerPage: NonNullable<string | number>;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    header: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    footer: (arg: VDataIteratorSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'no-data': () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    customFilter: vue.PropType<FilterFunction>;
+    customKeyFilter: vue.PropType<FilterKeyFunctions>;
+    filterKeys: vue.PropType<FilterKeys>;
+    filterMode: {
+        type: vue.PropType<FilterMode>;
+        default: string;
+    };
+    noFilter: BooleanConstructor;
+    groupBy: {
+        type: vue.PropType<readonly SortItem[]>;
+        default: () => never[];
+    };
+    expandOnClick: BooleanConstructor;
+    showExpand: BooleanConstructor;
+    expanded: {
+        type: vue.PropType<readonly string[]>;
+        default: () => never[];
+    };
+    page: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    itemsPerPage: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    sortBy: {
+        type: vue.PropType<readonly SortItem[]>;
+        default: () => never[];
+    };
+    customKeySort: vue.PropType<Record<string, DataTableCompareFunction>>;
+    multiSort: BooleanConstructor;
+    mustSort: BooleanConstructor;
+    showSelect: BooleanConstructor;
+    selectStrategy: {
+        type: vue.PropType<"all" | "page" | "single">;
+        default: string;
+    };
+    modelValue: {
+        type: vue.PropType<readonly any[]>;
+        default: () => never[];
+    };
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    items: {
+        type: vue.PropType<any[]>;
+        default: () => never[];
+    };
+    itemValue: {
+        type: vue.PropType<SelectItemKey>;
+        default: string;
+    };
+    itemSelectable: {
+        type: vue.PropType<SelectItemKey>;
+        default: null;
+    };
+    returnObject: BooleanConstructor;
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    search: StringConstructor;
+    loading: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    customFilter: vue.PropType<FilterFunction>;
+    customKeyFilter: vue.PropType<FilterKeyFunctions>;
+    filterKeys: vue.PropType<FilterKeys>;
+    filterMode: {
+        type: vue.PropType<FilterMode>;
+        default: string;
+    };
+    noFilter: BooleanConstructor;
+    groupBy: {
+        type: vue.PropType<readonly SortItem[]>;
+        default: () => never[];
+    };
+    expandOnClick: BooleanConstructor;
+    showExpand: BooleanConstructor;
+    expanded: {
+        type: vue.PropType<readonly string[]>;
+        default: () => never[];
+    };
+    page: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    itemsPerPage: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    sortBy: {
+        type: vue.PropType<readonly SortItem[]>;
+        default: () => never[];
+    };
+    customKeySort: vue.PropType<Record<string, DataTableCompareFunction>>;
+    multiSort: BooleanConstructor;
+    mustSort: BooleanConstructor;
+    showSelect: BooleanConstructor;
+    selectStrategy: {
+        type: vue.PropType<"all" | "page" | "single">;
+        default: string;
+    };
+    modelValue: {
+        type: vue.PropType<readonly any[]>;
+        default: () => never[];
+    };
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    items: {
+        type: vue.PropType<any[]>;
+        default: () => never[];
+    };
+    itemValue: {
+        type: vue.PropType<SelectItemKey>;
+        default: string;
+    };
+    itemSelectable: {
+        type: vue.PropType<SelectItemKey>;
+        default: null;
+    };
+    returnObject: BooleanConstructor;
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    search: StringConstructor;
+    loading: BooleanConstructor;
+}>>;
+type VDataIterator = InstanceType<typeof VDataIterator>;
+
+export { VDataIterator };

VApp/node_modules/vuetify/lib/components/VDataIterator/index.mjs

@@ -0,0 +1,2 @@
+export { VDataIterator } from "./VDataIterator.mjs";
+//# sourceMappingURL=index.mjs.map

VApp/node_modules/vuetify/lib/components/VDataIterator/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["VDataIterator"],"sources":["../../../src/components/VDataIterator/index.ts"],"sourcesContent":["export { VDataIterator } from './VDataIterator'\n"],"mappings":"SAASA,aAAa"}