eco-vue-js 0.3.67

package/dist/components/InfiniteList/components/InfiniteListPage.vue.js

@@ -0,0 +1,236 @@
+import { defineComponent, ref, toRef, computed, watch, onMounted, nextTick, openBlock, createElementBlock, unref, Fragment, createElementVNode, normalizeClass, createBlock, createCommentVNode, TransitionGroup, withCtx, renderList, renderSlot, toDisplayString } from 'vue';
+import _sfc_main$2 from './InfiniteListPageTitle.vue.js';
+import _sfc_main$1 from './InfiniteListPageSelection.vue.js';
+
+const _hoisted_1 = { class: "[overflow:inherit]" };
+const _hoisted_2 = { class: "select-none cursor-default w-select-field sm-not:px-3" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InfiniteListPage",
+  props: {
+    queryParams: {},
+    useQueryFn: {},
+    isInvalidPage: {},
+    skeletonLength: {},
+    firstPage: { type: Boolean },
+    lastPage: { type: Boolean },
+    hidePageTitle: { type: Boolean },
+    selected: { default: void 0 },
+    wrap: { type: Boolean },
+    noGap: { type: Boolean },
+    transition: { type: Boolean },
+    resetting: { type: Boolean },
+    emptyStub: { default: "Nothing to show" },
+    selectOnly: { type: Boolean },
+    unselectOnly: { type: Boolean },
+    reverseSelection: { type: Boolean },
+    allowPageSelection: { type: Boolean },
+    minHeight: { type: Boolean },
+    pageClass: { default: void 0 }
+  },
+  emits: ["update:count", "update:pagesCount", "update:nextPage", "update:previousPage", "update:scroll", "error:invalidPage", "refetch", "update-from-header:scroll", "update:selected", "fetched"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const element = ref();
+    const { data, error, setData, refetch, isFetching } = props.useQueryFn(toRef(props, "queryParams"));
+    const count = computed(() => data.value?.count);
+    const pagesCount = computed(() => data.value?.pages_count);
+    const nextPage = computed(() => data.value?.next);
+    const previousPage = computed(() => data.value?.previous);
+    const setItem = (index, newItem) => {
+      if (!data.value)
+        return;
+      const newData = {
+        ...data.value,
+        results: [...data.value.results]
+      };
+      if (newItem)
+        newData.results.splice(index, 1, newItem);
+      else
+        newData.results.splice(index, 1);
+      setData(newData);
+    };
+    const emitRefetch = () => {
+      emit("refetch");
+    };
+    const refetchPage = async () => {
+      await refetch();
+      if (props.lastPage && nextPage.value !== void 0)
+        emit("update:nextPage", nextPage.value);
+      if (props.firstPage && previousPage.value !== void 0)
+        emit("update:previousPage", previousPage.value);
+    };
+    const getFirst = () => {
+      if (!data.value)
+        return void 0;
+      return data.value.results[0];
+    };
+    const getLast = () => {
+      if (!data.value)
+        return void 0;
+      return data.value.results[data.value.results.length - 1];
+    };
+    watch(count, (value) => {
+      if (value !== void 0)
+        emit("update:count", value);
+    }, { immediate: true });
+    watch(pagesCount, (value) => {
+      if (value)
+        emit("update:pagesCount", value);
+    }, { immediate: true });
+    watch(nextPage, (value) => {
+      if (props.lastPage && value !== void 0)
+        emit("update:nextPage", value);
+    }, { immediate: true });
+    watch(previousPage, (value) => {
+      if (props.firstPage && value !== void 0)
+        emit("update:previousPage", value);
+    }, { immediate: true });
+    watch(error, (error2) => {
+      if (props.isInvalidPage(error2))
+        emit("error:invalidPage", props.queryParams.page);
+    }, { immediate: true });
+    watch(isFetching, (value) => {
+      if (value)
+        return;
+      emit("fetched");
+    });
+    let height = 0;
+    onMounted(() => {
+      height = element.value?.getBoundingClientRect()?.height ?? 0;
+      if (height === 0)
+        return;
+      if (!props.firstPage)
+        return;
+      if (props.lastPage) {
+        if (props.queryParams.page !== 1)
+          nextTick().then(() => emit("update-from-header:scroll"));
+        return;
+      }
+      emit("update:scroll", height);
+    });
+    watch(data, async (_, oldValue) => {
+      if (oldValue)
+        return;
+      await nextTick();
+      const newHeight = (element.value?.getBoundingClientRect().height ?? 0) - height;
+      if (newHeight === 0)
+        return;
+      if (!props.firstPage)
+        return;
+      if (props.lastPage)
+        return;
+      emit("update:scroll", newHeight);
+    });
+    __expose({
+      getFirst,
+      getLast,
+      refetch: refetchPage
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "element",
+        ref: element,
+        class: "relative"
+      }, [
+        _ctx.queryParams.page && unref(data)?.results.length !== 0 ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          createElementVNode("div", {
+            class: normalizeClass(["flex", {
+              "sm:pt-4": (_ctx.selected === void 0 || !_ctx.allowPageSelection) && _ctx.hidePageTitle && !_ctx.noGap
+            }])
+          }, [
+            _ctx.selected !== void 0 && _ctx.allowPageSelection ? (openBlock(), createBlock(_sfc_main$1, {
+              key: 0,
+              selected: _ctx.selected,
+              items: unref(data)?.results ?? [],
+              disabled: !unref(data)?.results,
+              "tooltip-text-persisted": _ctx.hidePageTitle,
+              "select-only": _ctx.selectOnly,
+              "unselect-only": _ctx.unselectOnly,
+              reverse: _ctx.reverseSelection,
+              class: "sm:w-list-row-item sm-not:px-[calc(var(--inner-margin)-2px)] pb-4 pt-6",
+              "onUpdate:selected": _cache[0] || (_cache[0] = ($event) => _ctx.$emit("update:selected", $event))
+            }, null, 8, ["selected", "items", "disabled", "tooltip-text-persisted", "select-only", "unselect-only", "reverse"])) : createCommentVNode("", true),
+            !_ctx.hidePageTitle ? (openBlock(), createBlock(_sfc_main$2, {
+              key: 1,
+              "query-params": _ctx.queryParams,
+              class: "pb-4 pt-6"
+            }, null, 8, ["query-params"])) : createCommentVNode("", true)
+          ], 2),
+          createElementVNode("div", {
+            class: normalizeClass(_ctx.pageClass)
+          }, [
+            unref(data)?.results ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+              _ctx.transition ? (openBlock(), createBlock(TransitionGroup, {
+                key: 0,
+                "enter-active-class": "transition-[grid-template-rows] overflow-hidden grid",
+                "enter-from-class": "grid-rows-[0fr]",
+                "enter-to-class": "grid-rows-[1fr]",
+                "leave-active-class": "transition-[grid-template-rows] overflow-hidden grid",
+                "leave-from-class": "grid-rows-[1fr]",
+                "leave-to-class": "grid-rows-[0fr]",
+                css: !_ctx.resetting
+              }, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(data).results, (item, index) => {
+                    return openBlock(), createElementBlock("div", {
+                      key: item.id,
+                      class: "w-full group"
+                    }, [
+                      createElementVNode("div", _hoisted_1, [
+                        renderSlot(_ctx.$slots, "default", {
+                          item,
+                          setter: (newItem) => setItem(index, newItem),
+                          refetch: emitRefetch,
+                          skeleton: false,
+                          next: unref(data)?.results[index + 1],
+                          previous: unref(data)?.results[index - 1],
+                          first: _ctx.firstPage && index === 0,
+                          last: _ctx.lastPage && index === unref(data).results.length - 1
+                        })
+                      ])
+                    ]);
+                  }), 128))
+                ]),
+                _: 3
+              }, 8, ["css"])) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(unref(data).results, (item, index) => {
+                return renderSlot(_ctx.$slots, "default", {
+                  key: item.id,
+                  item,
+                  setter: (newItem) => setItem(index, newItem),
+                  refetch: emitRefetch,
+                  skeleton: false,
+                  next: unref(data)?.results[index + 1],
+                  previous: unref(data)?.results[index - 1],
+                  first: _ctx.firstPage && index === 0,
+                  last: _ctx.lastPage && index === unref(data).results.length - 1
+                });
+              }), 128))
+            ], 64)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.skeletonLength, (index) => {
+              return renderSlot(_ctx.$slots, "default", {
+                key: index,
+                item: { id: index },
+                setter: (newItem) => setItem(index, newItem),
+                refetch: emitRefetch,
+                skeleton: true,
+                next: void 0,
+                previous: void 0,
+                first: _ctx.firstPage && index === 1,
+                last: _ctx.lastPage && index === _ctx.skeletonLength
+              });
+            }), 128))
+          ], 2)
+        ], 64)) : (openBlock(), createElementBlock("div", {
+          key: 1,
+          class: normalizeClass(["text-accent text-base font-normal", {
+            "py-16 px-8 text-center flex justify-center": !_ctx.minHeight,
+            "pt-4 pb-2 px-[1.0625rem]": _ctx.minHeight
+          }])
+        }, [
+          createElementVNode("div", _hoisted_2, toDisplayString(_ctx.emptyStub), 1)
+        ], 2))
+      ], 512);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListPage.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './InfiniteListPage.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListPageSelection.vue.d.ts

@@ -0,0 +1,57 @@
+declare const _default: <Data extends DefaultData>(__VLS_props: {
+    selected: number[];
+    items: Data[];
+    disabled?: boolean | undefined;
+    tooltipTextPersisted?: boolean | undefined;
+    selectOnly?: boolean | undefined;
+    unselectOnly?: boolean | undefined;
+    reverse?: boolean | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: Pick<{
+    props: {
+        selected: number[];
+        items: Data[];
+        disabled?: boolean | undefined;
+        tooltipTextPersisted?: boolean | undefined;
+        selectOnly?: boolean | undefined;
+        unselectOnly?: boolean | undefined;
+        reverse?: boolean | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {};
+    emit: (e: 'update:selected', values: number[]) => void;
+}, "attrs" | "slots" | "emit"> | undefined, __VLS_setup?: {
+    props: {
+        selected: number[];
+        items: Data[];
+        disabled?: boolean | undefined;
+        tooltipTextPersisted?: boolean | undefined;
+        selectOnly?: boolean | undefined;
+        unselectOnly?: boolean | undefined;
+        reverse?: boolean | undefined;
+    };
+    expose(exposed: {}): void;
+    attrs: any;
+    slots: {};
+    emit: (e: 'update:selected', values: number[]) => void;
+}) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            selected: number[];
+            items: Data[];
+            disabled?: boolean | undefined;
+            tooltipTextPersisted?: boolean | undefined;
+            selectOnly?: boolean | undefined;
+            unselectOnly?: boolean | undefined;
+            reverse?: boolean | undefined;
+        };
+        expose(exposed: {}): void;
+        attrs: any;
+        slots: {};
+        emit: (e: 'update:selected', values: number[]) => void;
+    } | undefined;
+};
+export default _default;
+//# sourceMappingURL=InfiniteListPageSelection.vue.d.ts.map

package/dist/components/InfiniteList/components/InfiniteListPageSelection.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfiniteListPageSelection.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/components/InfiniteListPageSelection.vue.ts"],"names":[],"mappings":";cAsIY,MAAM,EAAE;;;;;;;;;kBAAR,MAAM,EAAE;;;;;;;;yBAamB,IAAI;WACpC,GAAG;;cALJ,iBAAiB,UAAU,MAAM,EAAE,KAAG,IAAI;;;kBATpC,MAAM,EAAE;;;;;;;;yBAamB,IAAI;WACpC,GAAG;;cALJ,iBAAiB,UAAU,MAAM,EAAE,KAAG,IAAI;;;;;;sBATpC,MAAM,EAAE;;;;;;;;6BAamB,IAAI;eACpC,GAAG;;kBALJ,iBAAiB,UAAU,MAAM,EAAE,KAAG,IAAI;;;AA1IhD,wBAmJkE"}

package/dist/components/InfiniteList/components/InfiniteListPageSelection.vue.js

@@ -0,0 +1,66 @@
+import { defineComponent, computed, openBlock, createBlock, withCtx, createTextVNode, toDisplayString } from 'vue';
+import _sfc_main$1 from '../../Checkbox/WCheckbox.vue.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InfiniteListPageSelection",
+  props: {
+    selected: {},
+    items: {},
+    disabled: { type: Boolean },
+    tooltipTextPersisted: { type: Boolean },
+    selectOnly: { type: Boolean },
+    unselectOnly: { type: Boolean },
+    reverse: { type: Boolean }
+  },
+  emits: ["update:selected"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ids = computed(() => props.items.map((item) => item.id));
+    const selectedItems = computed(() => ids.value.filter((id) => props.selected.includes(id)));
+    const hasSelected = computed(() => selectedItems.value.length !== 0);
+    const chekboxValue = computed(() => {
+      if (props.selectOnly)
+        return false;
+      if (props.unselectOnly)
+        return true;
+      if (selectedItems.value.length === props.items.length) {
+        return hasSelected.value;
+      } else {
+        return hasSelected.value ? null : false;
+      }
+    });
+    const chekboxValueReversed = computed(() => props.disabled ? false : chekboxValue.value === null ? null : props.reverse ? !chekboxValue.value : chekboxValue.value);
+    const tooltipText = computed(() => `${chekboxValueReversed.value === true ? "Unselect" : "Select"} page (${props.items.length} item${props.items.length === 1 ? "" : "s"})`);
+    const selectOrUnselect = (isSelect) => {
+      if (props.reverse ? !isSelect : isSelect) {
+        emit("update:selected", [...props.selected, ...ids.value].filter((id, index, arr) => arr.indexOf(id) === index));
+      } else {
+        emit("update:selected", props.selected.filter((id) => !ids.value.includes(id)));
+      }
+    };
+    return (_ctx, _cache) => {
+      return _ctx.tooltipTextPersisted ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        "model-value": chekboxValueReversed.value,
+        disabled: _ctx.disabled,
+        intermediate: "",
+        class: "w-full",
+        "onUpdate:modelValue": selectOrUnselect
+      }, {
+        default: withCtx(() => [
+          createTextVNode(toDisplayString(tooltipText.value), 1)
+        ]),
+        _: 1
+      }, 8, ["model-value", "disabled"])) : (openBlock(), createBlock(_sfc_main$1, {
+        key: 1,
+        "model-value": chekboxValueReversed.value,
+        disabled: _ctx.disabled,
+        "tooltip-text": tooltipText.value,
+        intermediate: "",
+        "onUpdate:modelValue": selectOrUnselect
+      }, null, 8, ["model-value", "disabled", "tooltip-text"]));
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListPageSelection.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './InfiniteListPageSelection.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListPageTitle.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import("vue").DefineComponent<{
+    queryParams: {
+        type: import("vue").PropType<Partial<Record<string, string | number> & {
+            page?: number | undefined;
+        }>>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selected": (value: boolean) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    queryParams: {
+        type: import("vue").PropType<Partial<Record<string, string | number> & {
+            page?: number | undefined;
+        }>>;
+        required: true;
+    };
+}>> & {
+    "onUpdate:selected"?: ((value: boolean) => any) | undefined;
+}, {}, {}>;
+export default _default;
+//# sourceMappingURL=InfiniteListPageTitle.vue.d.ts.map

package/dist/components/InfiniteList/components/InfiniteListPageTitle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfiniteListPageTitle.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/components/InfiniteListPageTitle.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAuFA,wBAAkD"}

package/dist/components/InfiniteList/components/InfiniteListPageTitle.vue.js

@@ -0,0 +1,35 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, withCtx, createTextVNode, toDisplayString } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { Notify } from '../../../utils/Notify.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InfiniteListPageTitle",
+  props: {
+    queryParams: {}
+  },
+  emits: ["update:selected"],
+  setup(__props) {
+    const props = __props;
+    const route = useRoute();
+    const router = useRouter();
+    const copyRoute = () => {
+      navigator.clipboard.writeText(location.origin + router.resolve({ query: props.queryParams, hash: route.hash }).href).then(() => Notify.success({ title: "Page url copied" }));
+    };
+    return (_ctx, _cache) => {
+      const _component_RouterLink = resolveComponent("RouterLink");
+      return openBlock(), createBlock(_component_RouterLink, {
+        class: "block text-description text-base font-normal no-underline hover:underline sm-not:first:-mx--inner-margin",
+        to: { query: _ctx.queryParams, hash: _ctx.$route.hash },
+        replace: "",
+        onClick: copyRoute
+      }, {
+        default: withCtx(() => [
+          createTextVNode(" Page: " + toDisplayString(_ctx.queryParams.page), 1)
+        ]),
+        _: 1
+      }, 8, ["to"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListPageTitle.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './InfiniteListPageTitle.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListScroll.vue.d.ts

@@ -0,0 +1,29 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    scrollingElement: {
+        type: import("vue").PropType<Element | null>;
+        required: true;
+    };
+}, {
+    checkIsScrollUp: () => void;
+    checkIsScrollDown: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "scroll:up": () => void;
+    "scroll:down": () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    scrollingElement: {
+        type: import("vue").PropType<Element | null>;
+        required: true;
+    };
+}>> & {
+    "onScroll:up"?: (() => any) | undefined;
+    "onScroll:down"?: (() => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=InfiniteListScroll.vue.d.ts.map

package/dist/components/InfiniteList/components/InfiniteListScroll.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfiniteListScroll.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/components/InfiniteListScroll.vue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA+HA,wBAA8G;AAmB9G,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}

package/dist/components/InfiniteList/components/InfiniteListScroll.vue.js

@@ -0,0 +1,56 @@
+import { defineComponent, computed, watch, onMounted, onUnmounted, openBlock, createElementBlock, renderSlot } from 'vue';
+import { getIsScrollUp, getIsScrollDown } from '../models/utils.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InfiniteListScroll",
+  props: {
+    scrollingElement: {}
+  },
+  emits: ["scroll:up", "scroll:down"],
+  setup(__props, { expose: __expose, emit }) {
+    const props = __props;
+    const element = computed(() => props.scrollingElement ?? document);
+    const listener = (event) => {
+      if (event.target !== element.value)
+        return;
+      if (getIsScrollUp(props.scrollingElement ?? document.scrollingElement)) {
+        emit("scroll:up");
+        return;
+      }
+      if (getIsScrollDown(props.scrollingElement ?? document.scrollingElement)) {
+        emit("scroll:down");
+      }
+    };
+    const checkIsScrollUp = () => {
+      if (getIsScrollDown(props.scrollingElement ?? document.scrollingElement)) {
+        emit("scroll:down");
+      }
+    };
+    const checkIsScrollDown = () => {
+      if (getIsScrollDown(props.scrollingElement ?? document.scrollingElement)) {
+        emit("scroll:down");
+      }
+    };
+    watch(element, (newValue, oldValue) => {
+      oldValue?.removeEventListener("scroll", listener);
+      newValue?.addEventListener("scroll", listener);
+    }, { immediate: true });
+    onMounted(() => {
+      emit("scroll:up");
+    });
+    onUnmounted(() => {
+      element.value.removeEventListener("scroll", listener);
+    });
+    __expose({
+      checkIsScrollUp,
+      checkIsScrollDown
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        renderSlot(_ctx.$slots, "default")
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/components/InfiniteListScroll.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './InfiniteListScroll.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/components/InfiniteList/models/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const getIsScrollUp: (element: Element | null) => boolean;
+export declare const getIsScrollDown: (element: Element | null) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/InfiniteList/models/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/models/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,YAAa,OAAO,GAAG,IAAI,KAAG,OAIvD,CAAA;AAED,eAAO,MAAM,eAAe,YAAa,OAAO,GAAG,IAAI,KAAG,OAIzD,CAAA"}

package/dist/components/InfiniteList/models/utils.js

@@ -0,0 +1,13 @@
+const TRIGGER_FACTOR = 200;
+const getIsScrollUp = (element) => {
+  if (!element)
+    return false;
+  return element.scrollTop < TRIGGER_FACTOR;
+};
+const getIsScrollDown = (element) => {
+  if (!element)
+    return false;
+  return element.scrollTop > element.scrollHeight - element.clientHeight - TRIGGER_FACTOR;
+};
+
+export { getIsScrollDown, getIsScrollUp };

package/dist/components/InfiniteList/use/useInfiniteListHeader.d.ts

@@ -0,0 +1,8 @@
+export declare const useInfiniteListHeader: (scrollingElement?: Element | null) => {
+    indicator: import("vue").Ref<HTMLDivElement | undefined>;
+    header: import("vue").Ref<HTMLDivElement | undefined>;
+    headerHeight: import("vue").Ref<number>;
+    headerTop: import("vue").Ref<number>;
+    isIntersecting: import("vue").Ref<boolean>;
+};
+//# sourceMappingURL=useInfiniteListHeader.d.ts.map

package/dist/components/InfiniteList/use/useInfiniteListHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteListHeader.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/use/useInfiniteListHeader.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,qBAAqB,sBAAsB,OAAO,GAAG,IAAI;;;;;;CAgDrE,CAAA"}

package/dist/components/InfiniteList/use/useInfiniteListHeader.js

@@ -0,0 +1,61 @@
+import { ref, onMounted, onBeforeUnmount } from 'vue';
+import '../../Button/WButton.vue.js';
+import '../../Button/WButtonAction.vue.js';
+import { isClientSide } from '../../../utils/utils.js';
+import '../../../utils/supportsPassive.js';
+import '../../Dropdown/utils/DropdownStyle.js';
+import 'vue-router';
+import '../../../utils/Modal.js';
+import '../../Link/WLink.vue.js';
+
+const headerElementHeight = 60;
+const observerOptions = {
+  root: null,
+  rootMargin: `-${headerElementHeight}px 100% 0px 0px`,
+  threshold: 1
+};
+const useInfiniteListHeader = (scrollingElement = document.scrollingElement) => {
+  const indicator = ref();
+  const header = ref();
+  const headerHeight = ref(0);
+  const headerTop = ref(0);
+  const isIntersecting = ref(true);
+  let observer = null;
+  let isFirst = true;
+  const observerCb = (entries) => {
+    if (isFirst) {
+      isFirst = false;
+      return;
+    }
+    isIntersecting.value = entries.some((entry) => {
+      if (entry.target === indicator.value) {
+        return entry.isIntersecting || entry.boundingClientRect.top > window.innerHeight;
+      }
+    });
+  };
+  onMounted(() => {
+    if (!isClientSide)
+      return;
+    if (header.value) {
+      const rect = header.value.getBoundingClientRect();
+      headerHeight.value = rect.height;
+      headerTop.value = rect.top + (scrollingElement?.scrollTop ?? 0) - headerElementHeight;
+    }
+    if (indicator.value) {
+      observer = new IntersectionObserver(observerCb, observerOptions);
+      observer.observe(indicator.value);
+    }
+  });
+  onBeforeUnmount(() => {
+    observer?.disconnect();
+  });
+  return {
+    indicator,
+    header,
+    headerHeight,
+    headerTop,
+    isIntersecting
+  };
+};
+
+export { useInfiniteListHeader };

package/dist/components/InfiniteList/use/useRefetchNextPages.d.ts

@@ -0,0 +1,5 @@
+export declare const useRefetchNextPages: () => {
+    pageComponent: import("vue").Ref<any[]>;
+    refetchNextPages: (index: number) => void;
+};
+//# sourceMappingURL=useRefetchNextPages.d.ts.map

package/dist/components/InfiniteList/use/useRefetchNextPages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRefetchNextPages.d.ts","sourceRoot":"","sources":["../../../../../src/components/InfiniteList/use/useRefetchNextPages.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;;8BAoBG,MAAM,KAAG,IAAI;CAY/C,CAAA"}