@ironsource/shared-ui 2.1.12-test.1 → 2.1.12-test.100

package/components/sortableList/SortableItemLabel.vue.js

@@ -1,7 +1,7 @@
 import e from "./SortableItemLabel.vue2.js";
 /* empty css                        */import o from "../../_virtual/_plugin-vue_export-helper.js";
-// import "../../SortableItemLabel.vue_vue_type_style_index_0_scoped_f2ced2f4_lang.css"; //*');
-const a = /* @__PURE__ */ o(e, [["__scopeId", "data-v-f2ced2f4"]]);
+// import "../../SortableItemLabel.vue_vue_type_style_index_0_scoped_a534c7af_lang.css"; //*');
+const s = /* @__PURE__ */ o(e, [["__scopeId", "data-v-a534c7af"]]);
 export {
-  a as default
+  s as default
 };

package/components/sortableList/SortableItemLabel.vue2.js

@@ -1,52 +1,55 @@
- import "../../SortableItemLabel.vue_vue_type_style_index_0_scoped_f2ced2f4_lang.css"; import { defineComponent as m, openBlock as l, createBlock as c, unref as a, withCtx as e, createElementVNode as u, createElementBlock as s, Fragment as _, renderList as f, createVNode as o, createTextVNode as r, toDisplayString as i } from "vue";
-import n from "../typography/v4/Typography.vue.js";
-import h from "../tooltip/v4/TooltipV4.vue.js";
+ import "../../SortableItemLabel.vue_vue_type_style_index_0_scoped_a534c7af_lang.css"; import { defineComponent as m, openBlock as a, createBlock as u, unref as l, withCtx as t, createElementVNode as p, createElementBlock as d, Fragment as f, renderList as h, createVNode as i, createTextVNode as o, toDisplayString as r, normalizeClass as x } from "vue";
+import s from "../typography/v4/Typography.vue.js";
+import b from "../tooltip/v4/TooltipV4.vue.js";
 const y = { class: "tooltip-content" }, k = /* @__PURE__ */ m({
   __name: "SortableItemLabel",
   props: {
-    item: {},
-    displayValue: {}
+    item: null,
+    displayValue: null
   },
-  setup(b) {
-    return (t, v) => (l(), c(a(h), {
+  setup(e) {
+    return (_, v) => (a(), u(l(b), {
       class: "item-label",
       placement: "right",
-      disabled: !t.item.helpText
+      disabled: !e.item.helpText
     }, {
-      tooltip: e(() => [
-        u("div", y, [
-          (l(!0), s(_, null, f(t.item.helpText, (p, d) => (l(), s("div", {
-            key: d,
+      tooltip: t(() => [
+        p("div", y, [
+          (a(!0), d(f, null, h(e.item.helpText, (n, c) => (a(), d("div", {
+            key: c,
             class: "help"
           }, [
-            o(a(n), {
+            i(l(s), {
               class: "help__title",
               variant: "h5"
             }, {
-              default: e(() => [
-                r(i(p.title), 1)
+              default: t(() => [
+                o(r(n.title), 1)
               ]),
               _: 2
             }, 1024),
-            o(a(n), {
+            i(l(s), {
               class: "help__text",
               variant: "body2"
             }, {
-              default: e(() => [
-                r(i(p.text), 1)
+              default: t(() => [
+                o(r(n.text), 1)
               ]),
               _: 2
             }, 1024)
           ]))), 128))
         ])
       ]),
-      default: e(() => [
-        o(a(n), { variant: "body2" }, {
-          default: e(() => [
-            r(i(t.displayValue(t.item)), 1)
+      default: t(() => [
+        i(l(s), {
+          variant: "body2",
+          class: x(["item-text", { "item-text--disabled": e.item.isDisabled }])
+        }, {
+          default: t(() => [
+            o(r(e.displayValue(e.item)), 1)
           ]),
           _: 1
-        })
+        }, 8, ["class"])
       ]),
       _: 1
     }, 8, ["disabled"]));

package/components/sortableList/SortableList.types.d.ts

@@ -1,3 +1,5 @@
+import { Ref } from 'vue';
+import { UseVirtualListItem } from '@vueuse/core';
 export type SortableListItem = {
     id: number | string;
     displayText: string;
@@ -8,4 +10,20 @@ export type SortableListItem = {
         title: string;
         text: string;
     }[];
+    isDisabled?: boolean;
+};
+export type VirtualListResult = {
+    list: Ref<UseVirtualListItem<SortableListItem>[]>;
+    scrollTo: (index: number) => void;
+    containerProps: {
+        ref: Ref<HTMLElement>;
+        onScroll: () => void;
+    };
+    wrapperProps: Ref<{
+        style: {
+            width: string;
+            height: string;
+            marginTop: string;
+        };
+    }>;
 };

package/components/sortableList/SortableList.vue.d.ts

@@ -1,10 +1,12 @@
 import { SortableListItem } from '@/components/sortableList/SortableList.types';
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     items: SortableListItem[];
     displayValue: (item: SortableListItem) => string;
     openId?: string | number;
     selectedId?: string | number;
     selectedChildId?: string | number;
+    variant?: "default" | "compact";
+    draggableArea?: "handle" | "full";
     search?: string;
     showSearch?: boolean;
     searchPlaceholder?: string;
@@ -22,6 +24,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     openId: any;
     selectedId: any;
     selectedChildId: any;
+    variant: string;
+    draggableArea: string;
     search: any;
     showSearch: boolean;
     searchPlaceholder: string;
@@ -33,7 +37,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     isSticky: boolean;
     zIndexBase: number;
     testId: string;
-}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     sortableItemDragged: (event: {
         id: string;
         newIndex: number;
@@ -44,12 +48,14 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     "update:selectedChildId": (id: string | number) => void;
     "update:search": (query: string) => void;
     clearSearch: () => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     items: SortableListItem[];
     displayValue: (item: SortableListItem) => string;
     openId?: string | number;
     selectedId?: string | number;
     selectedChildId?: string | number;
+    variant?: "default" | "compact";
+    draggableArea?: "handle" | "full";
     search?: string;
     showSearch?: boolean;
     searchPlaceholder?: string;
@@ -67,6 +73,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     openId: any;
     selectedId: any;
     selectedChildId: any;
+    variant: string;
+    draggableArea: string;
     search: any;
     showSearch: boolean;
     searchPlaceholder: string;
@@ -78,7 +86,8 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     isSticky: boolean;
     zIndexBase: number;
     testId: string;
-}>>> & Readonly<{
+}>>> & {
+    onClearSearch?: () => any;
     onSortableItemDragged?: (event: {
         id: string;
         newIndex: number;
@@ -88,10 +97,10 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     "onUpdate:selectedId"?: (id: string | number) => any;
     "onUpdate:selectedChildId"?: (id: string | number) => any;
     "onUpdate:search"?: (query: string) => any;
-    onClearSearch?: () => any;
-}>, {
+}, {
     search: string;
     testId: string;
+    variant: "default" | "compact";
     isLoading: boolean;
     displayValue: (item: SortableListItem) => string;
     searchPlaceholder: string;
@@ -99,14 +108,15 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     selectedChildId: string | number;
     childListMaxHeight: string;
     searchHandler: (item: SortableListItem, searchQuery: string) => boolean;
+    draggableArea: "handle" | "full";
+    loadingRowCount: number;
     openId: string | number;
+    zIndexBase: number;
     selectedId: string | number;
     showSearch: boolean;
-    loadingRowCount: number;
     emptyStateTitle: string;
     isSticky: boolean;
-    zIndexBase: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+}>, {
     header?(_: {}): any;
     menu?(_: {
         item: SortableListItem;

package/components/sortableList/SortableList.vue.js

@@ -1,7 +1,7 @@
-import o from "./SortableList.vue2.js";
-/* empty css                   */import t from "../../_virtual/_plugin-vue_export-helper.js";
-// import "../../SortableList.vue_vue_type_style_index_0_scoped_8f267f88_lang.css"; //*');
-const p = /* @__PURE__ */ t(o, [["__scopeId", "data-v-8f267f88"]]);
+import e from "./SortableList.vue2.js";
+/* empty css                   */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../SortableList.vue_vue_type_style_index_0_scoped_9aec4e9b_lang.css"; //*');
+const a = /* @__PURE__ */ o(e, [["__scopeId", "data-v-9aec4e9b"]]);
 export {
-  p as default
+  a as default
 };

package/components/sortableList/SortableList.vue2.js

@@ -1,28 +1,31 @@
- import "../../SortableList.vue_vue_type_style_index_0_scoped_8f267f88_lang.css"; import { defineComponent as z, useCssVars as G, useSlots as U, computed as y, ref as K, openBlock as d, createElementBlock as r, mergeProps as V, unref as l, normalizeClass as Q, renderSlot as h, createCommentVNode as c, createBlock as v, isRef as j, withCtx as S, Fragment as B, renderList as D, createSlots as E, createElementVNode as J, createVNode as H, createTextVNode as W, toDisplayString as X } from "vue";
-import { VueDraggable as Y } from "vue-draggable-plus";
-import N from "./SortableItem.vue.js";
-import Z from "../search/v4/SearchV4.vue.js";
-import x from "../typography/v4/Typography.vue.js";
-import _ from "../skeleton/v4/SkeletonV4.vue.js";
-import { useVModel as ee } from "@vueuse/core";
-import { matchString as q } from "../../utils/search.js";
-import { useTestIdAttrs as te } from "../../utils/testIds.js";
+ import "../../SortableList.vue_vue_type_style_index_0_scoped_9aec4e9b_lang.css"; import { defineComponent as M, useCssVars as P, useSlots as z, computed as g, openBlock as s, createElementBlock as u, mergeProps as T, unref as t, normalizeClass as U, renderSlot as f, createCommentVNode as c, createBlock as S, isRef as x, withCtx as p, Fragment as D, renderList as H, createSlots as R, createVNode as w, createTextVNode as K, toDisplayString as Q } from "vue";
+import { VueDraggable as j } from "vue-draggable-plus";
+import $ from "./SortableItem.vue.js";
+import J from "./LoaderBars.vue.js";
+import W from "../search/v4/SearchV4.vue.js";
+import X from "../typography/v4/Typography.vue.js";
+import { useVModel as Y } from "@vueuse/core";
+import { matchString as N } from "../../utils/search.js";
+import { useTestIdAttrs as Z } from "../../utils/testIds.js";
 import { SortableListTestIdModifiers as I } from "../../testids/index.js";
-import { DRAG_CURSOR_CSS_CLASS as O } from "./consts.js";
-const le = {
+import { useDraggableHelpers as _ } from "./composables/useDraggableHelpers.js";
+import { DRAGGABLE_HANDLE_SELECTOR as ee, DRAGGABLE_AREA_SELECTOR as le } from "./consts.js";
+const te = {
   key: 1,
   class: "sortable-list-container"
-}, ae = { class: "loader-bars" }, de = {
+}, ae = {
   key: 3,
   class: "empty-state-title"
-}, ge = /* @__PURE__ */ z({
+}, me = /* @__PURE__ */ M({
   __name: "SortableList",
   props: {
     items: { default: () => [] },
-    displayValue: { type: Function, default: (p) => p.displayText || p.toString() },
+    displayValue: { type: Function, default: (a) => a.displayText || a.toString() },
     openId: { default: null },
     selectedId: { default: null },
     selectedChildId: { default: null },
+    variant: { default: "default" },
+    draggableArea: { default: "handle" },
     search: { default: null },
     showSearch: { type: Boolean, default: !1 },
     searchPlaceholder: { default: "Search" },
@@ -36,135 +39,131 @@ const le = {
     testId: { default: "" }
   },
   emits: ["sortableItemDragged", "update:items", "update:openId", "update:selectedId", "update:selectedChildId", "update:search", "clearSearch"],
-  setup(p, { emit: F }) {
-    G((e) => ({
-      "2b5787e0": e.zIndexBase
+  setup(a, { emit: n }) {
+    const r = a;
+    P((l) => ({
+      "0d58eb02": a.zIndexBase
     }));
-    const n = p, s = F, m = U(), i = ee(n, "search", s), k = y(() => !!i.value?.trim()), C = y(() => k.value ? n.items.filter((e) => {
-      const a = e.children || [], t = i.value;
-      return n.searchHandler ? n.searchHandler(e, t) : q(e.displayText, t) || // match parent item
-      a.some((o) => q(o.displayText, t));
-    }) : n.items), f = y({
+    const y = z(), i = Y(r, "search", n), b = g(() => !!i.value?.trim()), C = g(() => b.value ? r.items.filter((l) => {
+      const d = l.children || [], e = i.value;
+      return r.searchHandler ? r.searchHandler(l, e) : N(l.displayText, e) || // match parent item
+      d.some((o) => N(o.displayText, e));
+    }) : r.items), h = g({
       get() {
-        return C.value.filter((e) => !e.isLocked);
+        return C.value.filter((l) => !l.isLocked);
       },
-      set(e) {
-        s("update:items", [...e, ...L.value]);
+      set(l) {
+        n("update:items", [...l, ...k.value]);
       }
-    }), L = y(
-      () => C.value.filter((e) => e.isLocked)
-    ), b = K(!1), M = (e) => {
-      b.value = !0, setTimeout(() => e.target.classList.add(O), 50);
-    }, P = (e) => {
-      const { target: a, item: t, newIndex: o } = e;
-      b.value = !1, a.classList.remove(O);
-      const u = t.attributes["data-id"]?.value;
-      s("sortableItemDragged", { id: u, newIndex: o });
-    }, R = (e) => (k.value || e.id === n.openId) && !b.value, $ = (e, a) => {
-      a ? s("update:openId", e.id) : s("update:openId", null);
-    }, g = (e) => e.id === n.selectedId, w = (e) => {
-      s("update:selectedId", e.id), s("update:selectedChildId", null);
-    }, A = (e, a) => {
-      s("update:selectedChildId", e.id), s("update:selectedId", a.id), s("update:openId", a.id);
-    }, T = te(n.testId, I);
-    return (e, a) => (d(), r("div", V({ class: "sortable-list-and-header-container" }, l(T)[l(I).CONTAINER]), [
-      l(m).header || e.showSearch ? (d(), r("div", {
+    }), k = g(
+      () => C.value.filter((l) => l.isLocked)
+    ), G = g(
+      () => r.draggableArea === "handle" ? ee : le
+    ), { onDragStart: O, onDragEnd: q, draggingInProgress: F } = _(n), A = (l) => (b.value || l.id === r.openId) && !F.value, E = (l, d) => {
+      d ? n("update:openId", l.id) : n("update:openId", null);
+    }, m = (l) => l.id === r.selectedId, V = (l) => {
+      n("update:selectedId", l.id), n("update:selectedChildId", null);
+    }, B = (l, d) => {
+      n("update:selectedChildId", l.id), n("update:selectedId", d.id), n("update:openId", d.id);
+    }, L = Z(r.testId, I);
+    return (l, d) => (s(), u("div", T({ class: "sortable-list-and-header-container" }, t(L)[t(I).CONTAINER]), [
+      t(y).header || a.showSearch ? (s(), u("div", {
         key: 0,
-        class: Q(["header-container", { sticky: e.isSticky }])
+        class: U(["header-container", { sticky: a.isSticky }])
       }, [
-        l(m).header ? h(e.$slots, "header", { key: 0 }, void 0, !0) : c("", !0),
-        e.showSearch ? (d(), v(l(Z), {
+        t(y).header ? f(l.$slots, "header", { key: 0 }, void 0, !0) : c("", !0),
+        a.showSearch ? (s(), S(t(W), {
           key: 1,
-          modelValue: l(i),
-          "onUpdate:modelValue": a[0] || (a[0] = (t) => j(i) ? i.value = t : null),
-          placeholder: e.searchPlaceholder,
-          "test-id": e.testId,
-          onOnClear: a[1] || (a[1] = (t) => s("clearSearch"))
+          modelValue: t(i),
+          "onUpdate:modelValue": d[0] || (d[0] = (e) => x(i) ? i.value = e : null),
+          placeholder: a.searchPlaceholder,
+          "test-id": a.testId,
+          onOnClear: d[1] || (d[1] = (e) => n("clearSearch"))
         }, null, 8, ["modelValue", "placeholder", "test-id"])) : c("", !0)
       ], 2)) : c("", !0),
-      e.isLoading ? h(e.$slots, "loader", { key: 2 }, () => [
-        J("div", ae, [
-          (d(!0), r(B, null, D(e.loadingRowCount, (t) => (d(), r("div", { key: t }, [
-            H(l(_), {
-              round: "",
-              class: "loader-bar"
-            })
-          ]))), 128))
-        ])
-      ], !0) : (d(), r("div", le, [
-        f.value.length ? (d(), v(l(Y), V({
+      a.isLoading ? f(l.$slots, "loader", { key: 2 }, () => [
+        w(J, {
+          "loading-row-count": a.loadingRowCount,
+          variant: a.variant
+        }, null, 8, ["loading-row-count", "variant"])
+      ], !0) : (s(), u("div", te, [
+        t(h).length ? (s(), S(t(j), T({
           key: 0,
-          modelValue: f.value,
-          "onUpdate:modelValue": a[2] || (a[2] = (t) => f.value = t),
+          modelValue: t(h),
+          "onUpdate:modelValue": d[2] || (d[2] = (e) => x(h) ? h.value = e : null),
           class: "sortable-list",
           filter: ".expand-icon",
           animation: 150,
-          handle: ".draggable-handle",
-          disabled: k.value
-        }, l(T)[l(I).DRAGGABLE_LIST], {
-          onStart: M,
-          onEnd: P
+          handle: t(G),
+          disabled: t(b)
+        }, t(L)[t(I).DRAGGABLE_LIST], {
+          onStart: t(O),
+          onEnd: t(q)
         }), {
-          default: S(() => [
-            (d(!0), r(B, null, D(f.value, (t, o) => (d(), v(N, {
-              key: t.id,
-              "data-id": t.id,
-              item: t,
+          default: p(() => [
+            (s(!0), u(D, null, H(t(h), (e, o) => (s(), S($, {
+              key: e.id,
+              "data-id": e.id,
+              item: e,
               index: o,
-              "is-open": R(t),
-              "is-selected": g(t),
-              "selected-child-id": g(t) ? e.selectedChildId : null,
-              "display-value": e.displayValue,
-              "search-query": l(i),
-              "search-handler": e.searchHandler,
-              onToggle: (u) => $(t, u),
-              onSelect: (u) => w(t),
-              onSelectChild: (u) => A(u, t)
-            }, E({ _: 2 }, [
-              l(m).menu ? {
+              "is-open": A(e),
+              "is-selected": m(e),
+              "is-disabled": !!e.isDisabled,
+              "selected-child-id": m(e) ? a.selectedChildId : null,
+              "display-value": a.displayValue,
+              "search-query": t(i),
+              "search-handler": a.searchHandler,
+              variant: a.variant,
+              "draggable-area": a.draggableArea,
+              onToggle: (v) => E(e, v),
+              onSelect: (v) => V(e),
+              onSelectChild: (v) => B(v, e)
+            }, R({ _: 2 }, [
+              t(y).menu ? {
                 name: "menu",
-                fn: S(() => [
-                  h(e.$slots, "menu", { item: t }, void 0, !0)
+                fn: p(() => [
+                  f(l.$slots, "menu", { item: e }, void 0, !0)
                 ]),
                 key: "0"
               } : void 0
-            ]), 1032, ["data-id", "item", "index", "is-open", "is-selected", "selected-child-id", "display-value", "search-query", "search-handler", "onToggle", "onSelect", "onSelectChild"]))), 128))
+            ]), 1032, ["data-id", "item", "index", "is-open", "is-selected", "is-disabled", "selected-child-id", "display-value", "search-query", "search-handler", "variant", "draggable-area", "onToggle", "onSelect", "onSelectChild"]))), 128))
           ]),
           _: 3
-        }, 16, ["modelValue", "disabled"])) : c("", !0),
-        L.value.length ? (d(), r("div", V({
+        }, 16, ["modelValue", "handle", "disabled", "onStart", "onEnd"])) : c("", !0),
+        t(k).length ? (s(), u("div", T({
           key: 1,
           class: "locked-list"
-        }, l(T)[l(I).LOCKED_LIST]), [
-          (d(!0), r(B, null, D(L.value, (t) => (d(), v(N, {
-            key: t.id,
-            item: t,
-            "is-open": R(t),
-            "is-selected": g(t),
-            "selected-child-id": g(t) ? e.selectedChildId : null,
-            "display-value": e.displayValue,
-            "search-query": l(i),
-            "on-search": e.searchHandler,
-            "child-list-max-height": e.childListMaxHeight,
-            onToggle: (o) => $(t, o),
-            onSelect: (o) => w(t),
-            onSelectChild: (o) => A(o, t)
-          }, E({ _: 2 }, [
-            l(m).menu ? {
+        }, t(L)[t(I).LOCKED_LIST]), [
+          (s(!0), u(D, null, H(t(k), (e) => (s(), S($, {
+            key: e.id,
+            item: e,
+            "is-open": A(e),
+            "is-selected": m(e),
+            "selected-child-id": m(e) ? a.selectedChildId : null,
+            "display-value": a.displayValue,
+            "search-query": t(i),
+            "on-search": a.searchHandler,
+            "child-list-max-height": a.childListMaxHeight,
+            variant: a.variant,
+            onToggle: (o) => E(e, o),
+            onSelect: (o) => V(e),
+            onSelectChild: (o) => B(o, e)
+          }, R({ _: 2 }, [
+            t(y).menu ? {
               name: "menu",
-              fn: S(() => [
-                h(e.$slots, "menu", { item: t }, void 0, !0)
+              fn: p(() => [
+                f(l.$slots, "menu", { item: e }, void 0, !0)
               ]),
               key: "0"
             } : void 0
-          ]), 1032, ["item", "is-open", "is-selected", "selected-child-id", "display-value", "search-query", "on-search", "child-list-max-height", "onToggle", "onSelect", "onSelectChild"]))), 128))
+          ]), 1032, ["item", "is-open", "is-selected", "selected-child-id", "display-value", "search-query", "on-search", "child-list-max-height", "variant", "onToggle", "onSelect", "onSelectChild"]))), 128))
         ], 16)) : c("", !0)
       ])),
-      !C.value.length && !e.isLoading ? (d(), r("div", de, [
-        h(e.$slots, "empty-state", {}, () => [
-          H(l(x), { variant: "body2" }, {
-            default: S(() => [
-              W(X(e.emptyStateTitle), 1)
+      !t(C).length && !a.isLoading ? (s(), u("div", ae, [
+        f(l.$slots, "empty-state", {}, () => [
+          w(t(X), { variant: "body2" }, {
+            default: p(() => [
+              K(Q(a.emptyStateTitle), 1)
             ]),
             _: 1
           })
@@ -174,5 +173,5 @@ const le = {
   }
 });
 export {
-  ge as default
+  me as default
 };

package/components/sortableList/SortableSelectableList.vue.d.ts

@@ -0,0 +1,107 @@
+import { SortableListItem } from '@/components/sortableList/SortableList.types';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    items: SortableListItem[];
+    displayValue?: (item: SortableListItem) => string;
+    openId?: string | number;
+    selectedChildPerItem?: Record<string | number, string | number>;
+    variant?: "default" | "compact";
+    draggableArea?: "handle" | "full";
+    isLoading?: boolean;
+    loadingRowCount?: number;
+    alwaysVisibleCount?: number;
+    zIndexBase?: number;
+    testId?: string;
+}>, {
+    items: () => any[];
+    displayValue: (item: SortableListItem) => string;
+    openId: any;
+    selectedChildPerItem: () => {};
+    alwaysVisibleCount: any;
+    variant: string;
+    draggableArea: string;
+    isLoading: boolean;
+    loadingRowCount: number;
+    zIndexBase: number;
+    testId: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    sortableItemDragged: (event: {
+        id: string;
+        newIndex: number;
+    }) => void;
+    "update:items": (items: SortableListItem[]) => void;
+    "update:openId": (id: string | number) => void;
+    "update:selectedChildPerItem": (value: Record<string | number, string | number>) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    items: SortableListItem[];
+    displayValue?: (item: SortableListItem) => string;
+    openId?: string | number;
+    selectedChildPerItem?: Record<string | number, string | number>;
+    variant?: "default" | "compact";
+    draggableArea?: "handle" | "full";
+    isLoading?: boolean;
+    loadingRowCount?: number;
+    alwaysVisibleCount?: number;
+    zIndexBase?: number;
+    testId?: string;
+}>, {
+    items: () => any[];
+    displayValue: (item: SortableListItem) => string;
+    openId: any;
+    selectedChildPerItem: () => {};
+    alwaysVisibleCount: any;
+    variant: string;
+    draggableArea: string;
+    isLoading: boolean;
+    loadingRowCount: number;
+    zIndexBase: number;
+    testId: string;
+}>>> & {
+    onSortableItemDragged?: (event: {
+        id: string;
+        newIndex: number;
+    }) => any;
+    "onUpdate:items"?: (items: SortableListItem[]) => any;
+    "onUpdate:openId"?: (id: string | number) => any;
+    "onUpdate:selectedChildPerItem"?: (value: Record<string | number, string | number>) => any;
+}, {
+    testId: string;
+    variant: "default" | "compact";
+    isLoading: boolean;
+    displayValue: (item: SortableListItem) => string;
+    items: SortableListItem[];
+    draggableArea: "handle" | "full";
+    loadingRowCount: number;
+    openId: string | number;
+    selectedChildPerItem: Record<string | number, string | number>;
+    alwaysVisibleCount: number;
+    zIndexBase: number;
+}>, {
+    header?(_: {}): any;
+    menu?(_: {
+        item: SortableListItem;
+    }): any;
+    loader?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/sortableList/SortableSelectableList.vue.js

@@ -0,0 +1,7 @@
+import e from "./SortableSelectableList.vue2.js";
+/* empty css                             */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../SortableSelectableList.vue_vue_type_style_index_0_scoped_40b0a4de_lang.css"; //*');
+const a = /* @__PURE__ */ o(e, [["__scopeId", "data-v-40b0a4de"]]);
+export {
+  a as default
+};