@indielayer/ui 1.16.0 → 1.17.0

package/lib/virtual/core/createCachedBounds.js

@@ -0,0 +1,55 @@
+import { assert as f } from "../utils/assert.js";
+function d({
+  itemCount: u,
+  itemProps: a,
+  itemSize: r
+}) {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    get(s) {
+      for (f(s < u, `Invalid index ${s}`); e.size - 1 < s; ) {
+        const t = e.size;
+        let c;
+        switch (typeof r) {
+          case "function": {
+            c = r(t, a);
+            break;
+          }
+          case "number": {
+            c = r;
+            break;
+          }
+        }
+        if (t === 0)
+          e.set(t, {
+            size: c,
+            scrollOffset: 0
+          });
+        else {
+          const n = e.get(t - 1);
+          f(
+            n !== void 0,
+            `Unexpected bounds cache miss for index ${s}`
+          ), e.set(t, {
+            scrollOffset: n.scrollOffset + n.size,
+            size: c
+          });
+        }
+      }
+      const o = e.get(s);
+      return f(
+        o !== void 0,
+        `Unexpected bounds cache miss for index ${s}`
+      ), o;
+    },
+    set(s, o) {
+      e.set(s, o);
+    },
+    get size() {
+      return e.size;
+    }
+  };
+}
+export {
+  d as createCachedBounds
+};

package/lib/virtual/core/getEstimatedSize.d.ts

@@ -0,0 +1,6 @@
+import type { CachedBounds, SizeFunction } from './types';
+export declare function getEstimatedSize<Props extends object>({ cachedBounds, itemCount, itemSize, }: {
+    cachedBounds: CachedBounds;
+    itemCount: number;
+    itemSize: number | SizeFunction<Props>;
+}): number;

package/lib/virtual/core/getEstimatedSize.js

@@ -0,0 +1,22 @@
+import { assert as f } from "../utils/assert.js";
+function o({
+  cachedBounds: e,
+  itemCount: s,
+  itemSize: t
+}) {
+  if (s === 0)
+    return 0;
+  if (typeof t == "number")
+    return s * t;
+  {
+    const r = e.get(
+      e.size === 0 ? 0 : e.size - 1
+    );
+    f(r !== void 0, "Unexpected bounds cache miss");
+    const i = (r.scrollOffset + r.size) / e.size;
+    return s * i;
+  }
+}
+export {
+  o as getEstimatedSize
+};

package/lib/virtual/core/getOffsetForIndex.d.ts

@@ -0,0 +1,11 @@
+import type { Align } from '../types';
+import type { CachedBounds, SizeFunction } from './types';
+export declare function getOffsetForIndex<Props extends object>({ align, cachedBounds, index, itemCount, itemSize, containerScrollOffset, containerSize, }: {
+    align: Align;
+    cachedBounds: CachedBounds;
+    index: number;
+    itemCount: number;
+    itemSize: number | SizeFunction<Props>;
+    containerScrollOffset: number;
+    containerSize: number;
+}): number;

package/lib/virtual/core/getOffsetForIndex.js

@@ -0,0 +1,40 @@
+import { getEstimatedSize as o } from "./getEstimatedSize.js";
+function p({
+  align: u,
+  cachedBounds: l,
+  index: r,
+  itemCount: a,
+  itemSize: d,
+  containerScrollOffset: e,
+  containerSize: t
+}) {
+  if (r < 0 || r >= a)
+    throw new RangeError(
+      `Invalid index specified: ${r}. Index ${r} is not within the range of 0 - ${a - 1}`
+    );
+  const h = o({
+    cachedBounds: l,
+    itemCount: a,
+    itemSize: d
+  }), s = l.get(r), m = Math.max(
+    0,
+    Math.min(h - t, s.scrollOffset)
+  ), f = Math.max(
+    0,
+    s.scrollOffset - t + s.size
+  );
+  switch (u === "smart" && (e >= f && e <= m ? u = "auto" : u = "center"), u) {
+    case "start":
+      return m;
+    case "end":
+      return f;
+    case "center":
+      return s.scrollOffset <= t / 2 ? 0 : s.scrollOffset + s.size / 2 >= h - t / 2 ? h - t : s.scrollOffset + s.size / 2 - t / 2;
+    case "auto":
+    default:
+      return e >= f && e <= m ? e : e < f ? f : m;
+  }
+}
+export {
+  p as getOffsetForIndex
+};

package/lib/virtual/core/getStartStopIndices.d.ts

@@ -0,0 +1,13 @@
+import type { CachedBounds } from './types';
+export declare function getStartStopIndices({ cachedBounds, containerScrollOffset, containerSize, itemCount, overscanCount, }: {
+    cachedBounds: CachedBounds;
+    containerScrollOffset: number;
+    containerSize: number;
+    itemCount: number;
+    overscanCount: number;
+}): {
+    startIndexVisible: number;
+    stopIndexVisible: number;
+    startIndexOverscan: number;
+    stopIndexOverscan: number;
+};

package/lib/virtual/core/getStartStopIndices.js

@@ -0,0 +1,31 @@
+function f({
+  cachedBounds: a,
+  containerScrollOffset: x,
+  containerSize: b,
+  itemCount: d,
+  overscanCount: I
+}) {
+  const i = d - 1;
+  let t = 0, n = -1, l = 0, r = -1, e = 0;
+  for (; e < i; ) {
+    const s = a.get(e);
+    if (s.scrollOffset + s.size > x)
+      break;
+    e++;
+  }
+  for (t = e, l = Math.max(0, t - I); e < i; ) {
+    const s = a.get(e);
+    if (s.scrollOffset + s.size >= x + b)
+      break;
+    e++;
+  }
+  return n = Math.min(i, e), r = Math.min(d - 1, n + I), t < 0 && (t = 0, n = -1, l = 0, r = -1), {
+    startIndexVisible: t,
+    stopIndexVisible: n,
+    startIndexOverscan: l,
+    stopIndexOverscan: r
+  };
+}
+export {
+  f as getStartStopIndices
+};

package/lib/virtual/core/getStartStopIndices.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/virtual/core/types.d.ts

@@ -0,0 +1,11 @@
+export type Bounds = {
+    size: number;
+    scrollOffset: number;
+};
+export type CachedBounds = {
+    get(index: number): Bounds;
+    set(index: number, bounds: Bounds): void;
+    size: number;
+};
+export type Direction = 'horizontal' | 'vertical';
+export type SizeFunction<Props extends object> = (index: number, props: Props) => number;

package/lib/virtual/core/useCachedBounds.d.ts

@@ -0,0 +1,7 @@
+import { type ComputedRef } from 'vue';
+import type { CachedBounds, SizeFunction } from './types';
+export declare function useCachedBounds<Props extends object>({ itemCount, itemProps, itemSize, }: {
+    itemCount: number;
+    itemProps: Props;
+    itemSize: number | SizeFunction<Props>;
+}): ComputedRef<CachedBounds>;

package/lib/virtual/core/useCachedBounds.js

@@ -0,0 +1,18 @@
+import { computed as t } from "vue";
+import { createCachedBounds as u } from "./createCachedBounds.js";
+function m({
+  itemCount: o,
+  itemProps: e,
+  itemSize: r
+}) {
+  return t(
+    () => u({
+      itemCount: o,
+      itemProps: e,
+      itemSize: r
+    })
+  );
+}
+export {
+  m as useCachedBounds
+};

package/lib/virtual/core/useIsRtl.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare function useIsRtl(element: Ref<HTMLElement | null>, dir?: 'ltr' | 'rtl' | 'auto'): Ref<boolean, boolean>;

package/lib/virtual/core/useIsRtl.js

@@ -0,0 +1,15 @@
+import { ref as a, watch as f } from "vue";
+import { isRtl as m } from "../utils/isRtl.js";
+function i(l, r) {
+  const t = a(r === "rtl");
+  return f(
+    [l, () => r],
+    ([u, e]) => {
+      u && (!e || e === "auto" ? t.value = m(u) : t.value = e === "rtl");
+    },
+    { immediate: !0 }
+  ), t;
+}
+export {
+  i as useIsRtl
+};

package/lib/virtual/core/useItemSize.d.ts

@@ -0,0 +1,5 @@
+import type { SizeFunction } from './types';
+export declare function useItemSize<Props extends object>({ containerSize, itemSize: itemSizeProp, }: {
+    containerSize: number;
+    itemSize: number | string | SizeFunction<Props>;
+}): number | SizeFunction<Props>;

package/lib/virtual/core/useItemSize.js

@@ -0,0 +1,27 @@
+import { assert as i } from "../utils/assert.js";
+function n({
+  containerSize: t,
+  itemSize: e
+}) {
+  let s;
+  switch (typeof e) {
+    case "string": {
+      i(
+        e.endsWith("%"),
+        `Invalid item size: "${e}"; string values must be percentages (e.g. "100%")`
+      ), i(
+        t !== void 0,
+        "Container size must be defined if a percentage item size is specified"
+      ), s = t * parseInt(e) / 100;
+      break;
+    }
+    default: {
+      s = e;
+      break;
+    }
+  }
+  return s;
+}
+export {
+  n as useItemSize
+};

package/lib/virtual/core/useVirtualizer.d.ts

@@ -0,0 +1,33 @@
+import { type ComputedRef, type CSSProperties, type Ref } from 'vue';
+import type { Align } from '../types';
+import type { Direction, SizeFunction } from './types';
+export declare function useVirtualizer<Props extends object>({ containerElement, containerStyle, defaultContainerSize, direction, isRtl, itemCount: itemCountInput, itemProps: itemPropsInput, itemSize: itemSizeProp, onResize, overscanCount, }: {
+    containerElement: Ref<HTMLElement | null>;
+    containerStyle?: CSSProperties;
+    defaultContainerSize?: number;
+    direction: Direction;
+    isRtl?: boolean;
+    itemCount: number | Ref<number> | ComputedRef<number>;
+    itemProps: Props | ComputedRef<Props>;
+    itemSize: number | string | SizeFunction<Props> | Ref<number | string | SizeFunction<Props>> | ComputedRef<number | string | SizeFunction<Props>>;
+    onResize: ((size: {
+        height: number;
+        width: number;
+    }, prevSize: {
+        height: number;
+        width: number;
+    }) => void) | undefined;
+    overscanCount: number;
+}): {
+    getCellBounds: (index: number) => import("./types").Bounds;
+    getEstimatedSize: ComputedRef<number>;
+    scrollToIndex: ({ align, containerScrollOffset, index, }: {
+        align?: Align | undefined;
+        containerScrollOffset: number;
+        index: number;
+    }) => number | undefined;
+    startIndexOverscan: ComputedRef<number>;
+    startIndexVisible: ComputedRef<number>;
+    stopIndexOverscan: ComputedRef<number>;
+    stopIndexVisible: ComputedRef<number>;
+};

package/lib/virtual/core/useVirtualizer.js

@@ -0,0 +1,171 @@
+import { computed as t, isRef as w, ref as b, watch as N } from "vue";
+import { useResizeObserver as q, useEventListener as A } from "../../node_modules/.pnpm/@vueuse_core@11.1.0_vue@3.5.10_typescript@5.2.2_/node_modules/@vueuse/core/index.js";
+import { parseNumericStyleValue as $ } from "../utils/parseNumericStyleValue.js";
+import { adjustScrollOffsetForRtl as V } from "../utils/adjustScrollOffsetForRtl.js";
+import { shallowCompare as j } from "../utils/shallowCompare.js";
+import { getEstimatedSize as G } from "./getEstimatedSize.js";
+import { getOffsetForIndex as J } from "./getOffsetForIndex.js";
+import { getStartStopIndices as B } from "./getStartStopIndices.js";
+import { useCachedBounds as K } from "./useCachedBounds.js";
+import { useItemSize as Q } from "./useItemSize.js";
+function ie({
+  containerElement: u,
+  containerStyle: n,
+  defaultContainerSize: d = 0,
+  direction: i,
+  isRtl: p = !1,
+  itemCount: g,
+  itemProps: x,
+  itemSize: I,
+  onResize: T,
+  overscanCount: z
+}) {
+  const l = t(() => w(g) ? g.value : g), D = t(() => w(x) ? x.value : x), H = t(() => w(I) ? I.value : I), C = t(() => $(n == null ? void 0 : n.height)), M = t(() => $(n == null ? void 0 : n.width)), f = b({
+    height: i === "vertical" ? d : void 0,
+    width: i === "horizontal" ? d : void 0
+  }), R = t(
+    () => i === "vertical" && C.value !== void 0 || i === "horizontal" && M.value !== void 0
+  );
+  q(
+    u,
+    (e) => {
+      if (!R.value)
+        for (const s of e) {
+          const { contentRect: a } = s, o = f.value;
+          if (o.height === a.height && o.width === a.width)
+            return;
+          f.value = {
+            height: a.height,
+            width: a.width
+          };
+        }
+    }
+  );
+  const O = t(() => ({
+    height: C.value ?? f.value.height,
+    width: M.value ?? f.value.width
+  })), L = b({
+    height: 0,
+    width: 0
+  });
+  N(
+    O,
+    (e) => {
+      if (typeof T == "function") {
+        const s = L.value, a = e.height ?? 0, o = e.width ?? 0;
+        (s.height !== a || s.width !== o) && (T({ height: a, width: o }, { ...s }), L.value = { height: a, width: o });
+      }
+    },
+    { immediate: !0 }
+  );
+  const h = t(
+    () => i === "vertical" ? O.value.height ?? d : O.value.width ?? d
+  ), S = t(
+    () => Q({ containerSize: h.value, itemSize: H.value })
+  ), r = t(
+    () => K({
+      itemCount: l.value,
+      itemProps: D.value,
+      itemSize: S.value
+    }).value
+  ), W = (e) => r.value.get(e), v = b(
+    B({
+      cachedBounds: r.value,
+      containerScrollOffset: 0,
+      containerSize: h.value,
+      itemCount: l.value,
+      overscanCount: z
+    })
+  ), m = t(() => {
+    const e = v.value;
+    return {
+      startIndexVisible: Math.min(l.value - 1, e.startIndexVisible),
+      startIndexOverscan: Math.min(l.value - 1, e.startIndexOverscan),
+      stopIndexVisible: Math.min(l.value - 1, e.stopIndexVisible),
+      stopIndexOverscan: Math.min(l.value - 1, e.stopIndexOverscan)
+    };
+  }), k = t(
+    () => G({
+      cachedBounds: r.value,
+      itemCount: l.value,
+      itemSize: S.value
+    })
+  ), E = (e) => {
+    const s = V({
+      containerElement: u.value,
+      direction: i,
+      isRtl: p,
+      scrollOffset: e
+    });
+    return B({
+      cachedBounds: r.value,
+      containerScrollOffset: s,
+      containerSize: h.value,
+      itemCount: l.value,
+      overscanCount: z
+    });
+  };
+  return N(
+    [u, () => i, () => r.value],
+    ([e]) => {
+      const s = (i === "vertical" ? e == null ? void 0 : e.scrollTop : e == null ? void 0 : e.scrollLeft) ?? 0;
+      v.value = E(s);
+    },
+    { immediate: !0 }
+  ), A(u, "scroll", () => {
+    const e = u.value;
+    if (!e)
+      return;
+    const { scrollLeft: s, scrollTop: a } = e, o = V({
+      containerElement: e,
+      direction: i,
+      isRtl: p,
+      scrollOffset: i === "vertical" ? a : s
+    }), c = B({
+      cachedBounds: r.value,
+      containerScrollOffset: o,
+      containerSize: h.value,
+      itemCount: l.value,
+      overscanCount: z
+    });
+    j(c, v.value) || (v.value = c);
+  }), {
+    getCellBounds: W,
+    getEstimatedSize: k,
+    scrollToIndex: ({
+      align: e = "auto",
+      containerScrollOffset: s,
+      index: a
+    }) => {
+      let o = J({
+        align: e,
+        cachedBounds: r.value,
+        containerScrollOffset: s,
+        containerSize: h.value,
+        index: a,
+        itemCount: l.value,
+        itemSize: S.value
+      });
+      const c = u.value;
+      if (c) {
+        if (o = V({
+          containerElement: c,
+          direction: i,
+          isRtl: p,
+          scrollOffset: o
+        }), typeof c.scrollTo != "function") {
+          const F = E(o);
+          j(v.value, F) || (v.value = F);
+        }
+        return o;
+      }
+    },
+    startIndexOverscan: t(() => m.value.startIndexOverscan),
+    startIndexVisible: t(() => m.value.startIndexVisible),
+    stopIndexOverscan: t(() => m.value.stopIndexOverscan),
+    stopIndexVisible: t(() => m.value.stopIndexVisible)
+  };
+}
+export {
+  ie as useVirtualizer
+};

package/lib/virtual/index.d.ts

@@ -0,0 +1,9 @@
+export { default as XVirtualGrid } from './components/virtualGrid/VirtualGrid.vue';
+export type { CellSlotProps, VirtualGridImperativeAPI, VirtualGridProps, } from './components/virtualGrid/types';
+export { default as XVirtualList } from './components/virtualList/VirtualList.vue';
+export { useDynamicRowHeight } from './components/virtualList/useDynamicRowHeight';
+export type { DynamicRowHeight, VirtualListImperativeAPI, VirtualListProps, RowSlotProps, } from './components/virtualList/types';
+export { default as XInfiniteLoader } from './components/infiniteLoader/InfiniteLoader.vue';
+export { useInfiniteLoader } from './composables/infinite-loader/useInfiniteLoader';
+export type { Indices, OnRowsRendered, InfiniteLoaderProps, } from './composables/infinite-loader/types';
+export { getScrollbarSize } from './utils/getScrollbarSize';

package/lib/virtual/test-utils/mockResizeObserver.d.ts

@@ -0,0 +1,15 @@
+type GetDOMRect = (element: HTMLElement) => DOMRectReadOnly | undefined | void;
+export declare function disableResizeObserverForCurrentTest(): void;
+export declare function setDefaultElementSize({ height, width, }: {
+    height: number;
+    width: number;
+}): void;
+export declare function setElementSizeFunction(value: GetDOMRect): void;
+export declare function setElementSize({ element, height, width, }: {
+    element: HTMLElement;
+    height: number;
+    width: number;
+}): void;
+export declare function simulateUnsupportedEnvironmentForTest(): void;
+export declare function mockResizeObserver(): () => void;
+export {};

package/lib/virtual/types.d.ts

@@ -0,0 +1,2 @@
+export type Align = 'auto' | 'center' | 'end' | 'smart' | 'start';
+export type TagNames = keyof HTMLElementTagNameMap;

package/lib/virtual/utils/adjustScrollOffsetForRtl.d.ts

@@ -0,0 +1,7 @@
+import type { Direction } from '../core/types';
+export declare function adjustScrollOffsetForRtl({ containerElement, direction, isRtl, scrollOffset, }: {
+    containerElement: HTMLElement | null;
+    direction: Direction;
+    isRtl: boolean;
+    scrollOffset: number;
+}): number;

package/lib/virtual/utils/adjustScrollOffsetForRtl.js

@@ -0,0 +1,24 @@
+import { getRTLOffsetType as f } from "./getRTLOffsetType.js";
+function l({
+  containerElement: t,
+  direction: i,
+  isRtl: r,
+  scrollOffset: e
+}) {
+  if (i === "horizontal" && r)
+    switch (f()) {
+      case "negative":
+        return -e;
+      case "positive-descending": {
+        if (t) {
+          const { clientWidth: o, scrollLeft: s, scrollWidth: c } = t;
+          return c - o - s;
+        }
+        break;
+      }
+    }
+  return e;
+}
+export {
+  l as adjustScrollOffsetForRtl
+};

package/lib/virtual/utils/areArraysEqual.d.ts

@@ -0,0 +1 @@
+export declare function areArraysEqual(a: unknown[], b: unknown[]): boolean;

package/lib/virtual/utils/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(expectedCondition: unknown, message?: string): asserts expectedCondition;

package/lib/virtual/utils/assert.js

@@ -0,0 +1,7 @@
+function t(o, r = "Assertion error") {
+  if (!o)
+    throw console.error(r), Error(r);
+}
+export {
+  t as assert
+};

package/lib/virtual/utils/getRTLOffsetType.d.ts

@@ -0,0 +1,2 @@
+export type RTLOffsetType = 'negative' | 'positive-descending' | 'positive-ascending';
+export declare function getRTLOffsetType(recalculate?: boolean): RTLOffsetType;

package/lib/virtual/utils/getRTLOffsetType.js

@@ -0,0 +1,13 @@
+let t = null;
+function c(o = !1) {
+  if (t === null || o) {
+    const e = document.createElement("div"), l = e.style;
+    l.width = "50px", l.height = "50px", l.overflow = "scroll", l.direction = "rtl";
+    const n = document.createElement("div"), i = n.style;
+    return i.width = "100px", i.height = "100px", e.appendChild(n), document.body.appendChild(e), e.scrollLeft > 0 ? t = "positive-descending" : (e.scrollLeft = 1, e.scrollLeft === 0 ? t = "negative" : t = "positive-ascending"), document.body.removeChild(e), t;
+  }
+  return t;
+}
+export {
+  c as getRTLOffsetType
+};

package/lib/virtual/utils/getScrollbarSize.d.ts

@@ -0,0 +1,2 @@
+export declare function getScrollbarSize(recalculate?: boolean): number;
+export declare function setScrollbarSizeForTests(value: number): void;

package/lib/virtual/utils/getScrollbarSize.js

@@ -0,0 +1,11 @@
+let o = -1;
+function i(d = !1) {
+  if (o === -1 || d) {
+    const e = document.createElement("div"), t = e.style;
+    t.width = "50px", t.height = "50px", t.overflow = "scroll", document.body.appendChild(e), o = e.offsetWidth - e.clientWidth, document.body.removeChild(e);
+  }
+  return o;
+}
+export {
+  i as getScrollbarSize
+};

package/lib/virtual/utils/isRtl.d.ts

@@ -0,0 +1 @@
+export declare function isRtl(element: HTMLElement): boolean;

package/lib/virtual/utils/isRtl.js

@@ -0,0 +1,12 @@
+function t(r) {
+  let e = r;
+  for (; e; ) {
+    if (e.dir)
+      return e.dir === "rtl";
+    e = e.parentElement;
+  }
+  return !1;
+}
+export {
+  t as isRtl
+};

package/lib/virtual/utils/parseNumericStyleValue.d.ts

@@ -0,0 +1,2 @@
+import type { CSSProperties } from 'vue';
+export declare function parseNumericStyleValue(value: CSSProperties['height']): number | undefined;

package/lib/virtual/utils/parseNumericStyleValue.js

@@ -0,0 +1,15 @@
+function e(r) {
+  if (r !== void 0)
+    switch (typeof r) {
+      case "number":
+        return r;
+      case "string": {
+        if (r.endsWith("px"))
+          return parseFloat(r);
+        break;
+      }
+    }
+}
+export {
+  e as parseNumericStyleValue
+};

package/lib/virtual/utils/shallowCompare.d.ts

@@ -0,0 +1 @@
+export declare function shallowCompare<Type extends object>(a: Type | undefined, b: Type | undefined): boolean;

package/lib/virtual/utils/shallowCompare.js

@@ -0,0 +1,14 @@
+import { assert as n } from "./assert.js";
+function i(e, r) {
+  if (e === r)
+    return !0;
+  if (!!e != !!r || (n(e !== void 0), n(r !== void 0), Object.keys(e).length !== Object.keys(r).length))
+    return !1;
+  for (const t in e)
+    if (!Object.is(r[t], e[t]))
+      return !1;
+  return !0;
+}
+export {
+  i as shallowCompare
+};