@indielayer/ui 1.18.1 → 2.0.0

package/lib/tailwind.preset.js

@@ -1,40 +0,0 @@
-function getColorVar(color, level) {
-  if (level) return `rgb(var(--${color}-color-${level}))`
-
-  return `rgb(var(--${color}-color))`
-}
-
-function getColorVarPallete(color) {
-  return {
-    50: getColorVar(color, 50),
-    100: getColorVar(color, 100),
-    200: getColorVar(color, 200),
-    300: getColorVar(color, 300),
-    400: getColorVar(color, 400),
-    500: getColorVar(color, 500),
-    600: getColorVar(color, 600),
-    700: getColorVar(color, 700),
-    800: getColorVar(color, 800),
-    900: getColorVar(color, 900),
-    950: getColorVar(color, 950),
-  }
-}
-
-module.exports = () => ({
-  theme: {
-    extend: {
-      colors: {
-        primary: getColorVarPallete('primary'),
-        secondary: getColorVarPallete('secondary'),
-        success: getColorVarPallete('success'),
-        warning: getColorVarPallete('warning'),
-        error: getColorVarPallete('error'),
-      },
-      borderColor: getColorVar('border'),
-      fontFamily: {
-        sans: 'var(--font-family-sans)',
-        mono: 'var(--font-family-mono)',
-      },
-    },
-  },
-})

package/lib/virtual/components/infiniteLoader/InfiniteLoader.vue.js

@@ -1,21 +0,0 @@
-import { defineComponent as r, renderSlot as s, unref as d } from "vue";
-import { useInfiniteLoader as i } from "../../composables/infinite-loader/useInfiniteLoader.js";
-const a = {
-  name: "XInfiniteLoader"
-}, f = /* @__PURE__ */ r({
-  ...a,
-  props: {
-    isRowLoaded: { type: Function },
-    loadMoreRows: { type: Function },
-    minimumBatchSize: {},
-    threshold: {},
-    rowCount: {}
-  },
-  setup(e) {
-    const o = e, { onRowsRendered: n } = i(o);
-    return (t, u) => s(t.$slots, "default", { onRowsRendered: d(n) });
-  }
-});
-export {
-  f as default
-};

package/lib/virtual/components/infiniteLoader/InfiniteLoader.vue2.js

@@ -1,4 +0,0 @@
-import f from "./InfiniteLoader.vue.js";
-export {
-  f as default
-};

package/lib/virtual/components/virtualGrid/VirtualGrid.vue.js

@@ -1,241 +0,0 @@
-import { defineComponent as G, ref as D, computed as y, watch as F, openBlock as c, createBlock as N, resolveDynamicComponent as X, normalizeClass as j, normalizeStyle as m, withCtx as q, createElementBlock as p, Fragment as z, renderList as R, renderSlot as T, createElementVNode as J, unref as b } from "vue";
-import { useIsRtl as K } from "../../core/useIsRtl.js";
-import { useVirtualizer as O } from "../../core/useVirtualizer.js";
-const M = ["aria-rowindex"], Q = {
-  name: "XVirtualGrid"
-}, ee = /* @__PURE__ */ G({
-  ...Q,
-  props: {
-    cellProps: {},
-    class: {},
-    columnCount: {},
-    columnWidth: {},
-    defaultHeight: { default: 0 },
-    defaultWidth: { default: 0 },
-    dir: {},
-    onCellsRendered: {},
-    onResize: {},
-    overscanCount: { default: 3 },
-    rowCount: {},
-    rowHeight: {},
-    style: {},
-    tag: { default: "div" }
-  },
-  setup(V, { expose: k }) {
-    const o = V, r = D(null), f = y(() => o.cellProps || {}), u = K(r, o.dir), {
-      getCellBounds: B,
-      getEstimatedSize: $,
-      startIndexOverscan: x,
-      startIndexVisible: E,
-      scrollToIndex: v,
-      stopIndexOverscan: I,
-      stopIndexVisible: H
-    } = O({
-      containerElement: r,
-      containerStyle: o.style,
-      defaultContainerSize: o.defaultWidth,
-      direction: "horizontal",
-      isRtl: u.value,
-      itemCount: o.columnCount,
-      itemProps: f.value,
-      itemSize: o.columnWidth,
-      onResize: o.onResize,
-      overscanCount: o.overscanCount
-    }), {
-      getCellBounds: W,
-      getEstimatedSize: P,
-      startIndexOverscan: w,
-      startIndexVisible: _,
-      scrollToIndex: C,
-      stopIndexOverscan: h,
-      stopIndexVisible: A
-    } = O({
-      containerElement: r,
-      containerStyle: o.style,
-      defaultContainerSize: o.defaultHeight,
-      direction: "vertical",
-      itemCount: o.rowCount,
-      itemProps: f.value,
-      itemSize: o.rowHeight,
-      onResize: o.onResize,
-      overscanCount: o.overscanCount
-    });
-    k({
-      get element() {
-        return r.value;
-      },
-      scrollToCell({
-        behavior: e = "auto",
-        columnAlign: n = "auto",
-        columnIndex: s,
-        rowAlign: t = "auto",
-        rowIndex: l
-      }) {
-        var d, S, g;
-        const i = v({
-          align: n,
-          containerScrollOffset: ((d = r.value) == null ? void 0 : d.scrollLeft) ?? 0,
-          index: s
-        }), a = C({
-          align: t,
-          containerScrollOffset: ((S = r.value) == null ? void 0 : S.scrollTop) ?? 0,
-          index: l
-        });
-        typeof ((g = r.value) == null ? void 0 : g.scrollTo) == "function" && i !== void 0 && a !== void 0 && r.value.scrollTo({
-          behavior: e,
-          left: i,
-          top: a
-        });
-      },
-      scrollToColumn({
-        align: e = "auto",
-        behavior: n = "auto",
-        index: s
-      }) {
-        var l, i;
-        const t = v({
-          align: e,
-          containerScrollOffset: ((l = r.value) == null ? void 0 : l.scrollLeft) ?? 0,
-          index: s
-        });
-        typeof ((i = r.value) == null ? void 0 : i.scrollTo) == "function" && t !== void 0 && r.value.scrollTo({
-          behavior: n,
-          left: t
-        });
-      },
-      scrollToRow({
-        align: e = "auto",
-        behavior: n = "auto",
-        index: s
-      }) {
-        var l, i;
-        const t = C({
-          align: e,
-          containerScrollOffset: ((l = r.value) == null ? void 0 : l.scrollTop) ?? 0,
-          index: s
-        });
-        typeof ((i = r.value) == null ? void 0 : i.scrollTo) == "function" && t !== void 0 && r.value.scrollTo({
-          behavior: n,
-          top: t
-        });
-      }
-    }), F(
-      [
-        x,
-        E,
-        I,
-        H,
-        w,
-        _,
-        h,
-        A
-      ],
-      ([
-        e,
-        n,
-        s,
-        t,
-        l,
-        i,
-        a,
-        d
-      ]) => {
-        e >= 0 && s >= 0 && l >= 0 && a >= 0 && o.onCellsRendered && o.onCellsRendered(
-          {
-            columnStartIndex: n,
-            columnStopIndex: t,
-            rowStartIndex: i,
-            rowStopIndex: d
-          },
-          {
-            columnStartIndex: e,
-            columnStopIndex: s,
-            rowStartIndex: l,
-            rowStopIndex: a
-          }
-        );
-      }
-    );
-    const L = y(() => {
-      const e = [];
-      if (o.columnCount > 0 && o.rowCount > 0)
-        for (let n = w.value; n <= h.value; n++) {
-          const s = W(n), t = [];
-          for (let l = x.value; l <= I.value; l++) {
-            const i = B(l), a = {
-              position: "absolute",
-              left: u.value ? void 0 : 0,
-              right: u.value ? 0 : void 0,
-              transform: `translate(${u.value ? -i.scrollOffset : i.scrollOffset}px, ${s.scrollOffset}px)`,
-              height: `${s.size}px`,
-              width: `${i.size}px`
-            };
-            t.push({
-              key: l,
-              columnIndex: l,
-              rowIndex: n,
-              style: a,
-              ariaAttributes: {
-                "aria-colindex": l + 1,
-                role: "gridcell"
-              }
-            });
-          }
-          e.push({
-            key: n,
-            rowIndex: n,
-            columns: t,
-            ariaRowIndex: n + 1
-          });
-        }
-      return e;
-    });
-    return (e, n) => (c(), N(X(e.tag), {
-      ref_key: "element",
-      ref: r,
-      class: j(e.$props.class),
-      style: m({
-        position: "relative",
-        maxHeight: "100%",
-        maxWidth: "100%",
-        flexGrow: 1,
-        overflow: "auto",
-        ...e.style
-      }),
-      dir: e.dir,
-      role: "grid",
-      "aria-colcount": e.columnCount,
-      "aria-rowcount": e.rowCount
-    }, {
-      default: q(() => [
-        (c(!0), p(z, null, R(L.value, (s) => (c(), p("div", {
-          key: s.key,
-          role: "row",
-          "aria-rowindex": s.ariaRowIndex
-        }, [
-          (c(!0), p(z, null, R(s.columns, (t) => T(e.$slots, "cell", {
-            key: t.key,
-            columnIndex: t.columnIndex,
-            rowIndex: t.rowIndex,
-            style: m(t.style),
-            ariaAttributes: t.ariaAttributes,
-            props: f.value
-          })), 128))
-        ], 8, M))), 128)),
-        T(e.$slots, "default"),
-        J("div", {
-          "aria-hidden": "",
-          style: m({
-            height: `${b(P)}px`,
-            width: `${b($)}px`,
-            zIndex: -1
-          })
-        }, null, 4)
-      ]),
-      _: 3
-    }, 8, ["class", "style", "dir", "aria-colcount", "aria-rowcount"]));
-  }
-});
-export {
-  ee as default
-};

package/lib/virtual/components/virtualGrid/VirtualGrid.vue2.js

@@ -1,4 +0,0 @@
-import f from "./VirtualGrid.vue.js";
-export {
-  f as default
-};

package/lib/virtual/components/virtualList/VirtualList.vue.js

@@ -1,159 +0,0 @@
-import { defineComponent as k, ref as E, computed as i, watch as h, openBlock as w, createBlock as B, resolveDynamicComponent as D, normalizeClass as V, normalizeStyle as f, withCtx as P, createElementBlock as L, Fragment as N, renderList as O, renderSlot as g, createElementVNode as X, unref as Y } from "vue";
-import { useVirtualizer as F } from "../../core/useVirtualizer.js";
-import { isDynamicRowHeight as G } from "./isDynamicRowHeight.js";
-import { DATA_ATTRIBUTE_LIST_INDEX as U } from "./useDynamicRowHeight.js";
-const j = {
-  name: "XVirtualList"
-}, Q = /* @__PURE__ */ k({
-  ...j,
-  props: {
-    class: {},
-    defaultHeight: { default: 0 },
-    onResize: {},
-    onRowsRendered: {},
-    overscanCount: { default: 3 },
-    rowCount: {},
-    rowHeight: {},
-    rowProps: {},
-    style: {},
-    tag: { default: "div" }
-  },
-  setup(v, { expose: y }) {
-    const t = v, n = E(null), p = i(() => t.rowProps || {}), x = i(() => t.rowCount), a = i(() => G(t.rowHeight)), H = i(() => {
-      if (a.value) {
-        const e = t.rowHeight, o = e.getAverageRowHeight();
-        return (r) => e.getRowHeight(r) ?? o;
-      }
-      return t.rowHeight;
-    }), {
-      getCellBounds: R,
-      getEstimatedSize: C,
-      scrollToIndex: I,
-      startIndexOverscan: u,
-      startIndexVisible: z,
-      stopIndexOverscan: c,
-      stopIndexVisible: b
-    } = F({
-      containerElement: n,
-      containerStyle: t.style,
-      defaultContainerSize: t.defaultHeight,
-      direction: "vertical",
-      itemCount: x,
-      itemProps: p,
-      itemSize: H,
-      onResize: t.onResize,
-      overscanCount: t.overscanCount
-    });
-    y({
-      get element() {
-        return n.value;
-      },
-      scrollToRow({
-        align: e = "auto",
-        behavior: o = "auto",
-        index: r
-      }) {
-        var d, l;
-        const s = I({
-          align: e,
-          containerScrollOffset: ((d = n.value) == null ? void 0 : d.scrollTop) ?? 0,
-          index: r
-        });
-        typeof ((l = n.value) == null ? void 0 : l.scrollTo) == "function" && s !== void 0 && n.value.scrollTo({
-          behavior: o,
-          top: s
-        });
-      }
-    }), h(
-      [n, u, c, a, () => t.rowHeight],
-      ([e, o, r, s], d, l) => {
-        if (!e || !s)
-          return;
-        const T = Array.from(e.children).filter((m, _) => {
-          if (m.hasAttribute("aria-hidden"))
-            return !1;
-          const $ = `${o + _}`;
-          return m.setAttribute(U, $), !0;
-        }), S = t.rowHeight;
-        l(S.observeRowElements(T));
-      },
-      { flush: "post" }
-      // Run after DOM updates
-    ), h(
-      [u, z, c, b],
-      ([e, o, r, s]) => {
-        e >= 0 && r >= 0 && t.onRowsRendered && t.onRowsRendered(
-          {
-            startIndex: o,
-            stopIndex: s
-          },
-          {
-            startIndex: e,
-            stopIndex: r
-          }
-        );
-      }
-    );
-    const A = i(() => {
-      const e = [];
-      if (t.rowCount > 0)
-        for (let o = u.value; o <= c.value; o++) {
-          const r = R(o), s = {
-            position: "absolute",
-            left: 0,
-            transform: `translateY(${r.scrollOffset}px)`,
-            // In case of dynamic row heights, don't specify a height style
-            height: a.value ? void 0 : `${r.size}px`,
-            width: "100%"
-          };
-          e.push({
-            key: o,
-            index: o,
-            style: s,
-            ariaAttributes: {
-              "aria-posinset": o + 1,
-              "aria-setsize": t.rowCount,
-              role: "listitem"
-            }
-          });
-        }
-      return e;
-    });
-    return (e, o) => (w(), B(D(e.tag), {
-      ref_key: "element",
-      ref: n,
-      class: V(e.$props.class),
-      style: f({
-        position: "relative",
-        maxHeight: "100%",
-        flexGrow: 1,
-        overflowY: "auto",
-        ...e.style
-      }),
-      role: "list"
-    }, {
-      default: P(() => [
-        (w(!0), L(N, null, O(A.value, (r) => g(e.$slots, "row", {
-          key: r.key,
-          index: r.index,
-          style: f(r.style),
-          ariaAttributes: r.ariaAttributes,
-          props: p.value
-        })), 128)),
-        g(e.$slots, "default"),
-        X("div", {
-          "aria-hidden": "",
-          style: f({
-            height: `${Y(C)}px`,
-            width: "100%",
-            zIndex: -1
-          })
-        }, null, 4)
-      ]),
-      _: 3
-    }, 8, ["class", "style"]));
-  }
-});
-export {
-  Q as default
-};

package/lib/virtual/components/virtualList/VirtualList.vue2.js

@@ -1,4 +0,0 @@
-import f from "./VirtualList.vue.js";
-export {
-  f as default
-};