@ulu/frontend-vue 0.2.0-beta.2 → 0.2.0-beta.4

package/dist/components/systems/facets/UluFacetsResults.vue.js

@@ -0,0 +1,56 @@
+import { createElementBlock as s, openBlock as t, createBlock as m, TransitionGroup as u, normalizeClass as n, withCtx as o, Fragment as d, renderList as f, renderSlot as c, createElementVNode as y } from "vue";
+/* empty css                      */
+const g = { class: "facets-results" }, k = {
+  key: 1,
+  class: "facets-results__empty"
+}, N = {
+  __name: "UluFacetsResults",
+  props: {
+    items: {
+      type: Array,
+      required: !0
+    },
+    tag: {
+      type: String,
+      default: "ul"
+    },
+    transitionName: {
+      type: String,
+      default: "facets-fade"
+    },
+    classes: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(e) {
+    return (a, l) => (t(), s("div", g, [
+      e.items.length ? (t(), m(u, {
+        key: 0,
+        tag: e.tag,
+        name: e.transitionName,
+        class: n(["facets-results__list", e.classes.list])
+      }, {
+        default: o(() => [
+          (t(!0), s(d, null, f(e.items, (i, r) => (t(), s("li", {
+            class: n(["facets-results__item", e.classes.item]),
+            key: i.id || r
+          }, [
+            c(a.$slots, "item", {
+              item: i,
+              index: r
+            })
+          ], 2))), 128))
+        ]),
+        _: 3
+      }, 8, ["tag", "name", "class"])) : (t(), s("div", k, [
+        c(a.$slots, "empty", {}, () => [
+          l[0] || (l[0] = y("p", null, "No matching items found.", -1))
+        ])
+      ]))
+    ]));
+  }
+};
+export {
+  N as default
+};

package/dist/components/systems/facets/UluFacetsSearch.vue.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "update:modelValue", ...args: any[]) => void;
+    classes: Record<string, any>;
+    placeholder: string;
+    modelValue?: string | undefined;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly placeholder?: string | undefined;
+        readonly modelValue?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;
+//# sourceMappingURL=UluFacetsSearch.vue.d.ts.map

package/dist/components/systems/facets/UluFacetsSearch.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluFacetsSearch.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/UluFacetsSearch.vue"],"names":[],"mappings":"AAcA;"}

package/dist/components/systems/facets/UluFacetsSearch.vue.js

@@ -0,0 +1,49 @@
+import { computed as m, createElementBlock as p, openBlock as f, normalizeClass as l, createElementVNode as a, withDirectives as h, unref as r, vModelText as V } from "vue";
+import { newId as v } from "../../../utils/dom.js";
+const w = ["for"], y = ["id", "placeholder"], S = {
+  __name: "UluFacetsSearch",
+  props: {
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    modelValue: String,
+    placeholder: {
+      type: String,
+      default: "Keywords…"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: n }) {
+    const d = e, u = n, s = v("facet-view-keyword"), o = m({
+      get() {
+        return d.modelValue;
+      },
+      set(c) {
+        u("update:modelValue", c);
+      }
+    });
+    return (c, t) => (f(), p("div", {
+      class: l(["facets-search", e.classes.container])
+    }, [
+      a("label", {
+        class: l(e.classes.label),
+        for: r(s)
+      }, [...t[1] || (t[1] = [
+        a("strong", null, "Search", -1)
+      ])], 10, w),
+      h(a("input", {
+        id: r(s),
+        class: l(e.classes.input),
+        "onUpdate:modelValue": t[0] || (t[0] = (i) => o.value = i),
+        type: "text",
+        placeholder: e.placeholder
+      }, null, 10, y), [
+        [V, o.value]
+      ])
+    ], 2));
+  }
+};
+export {
+  S as default
+};

package/dist/components/systems/facets/UluFacetsSidebarLayout.vue.d.ts

@@ -0,0 +1,30 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    classes: Record<string, any>;
+    mobileButtonText: string;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly mobileButtonText?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    desktopTarget: HTMLDivElement;
+    mobileTarget: HTMLDivElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        main?(_: {}): any;
+        sidebar?(_: {}): any;
+    };
+    refs: {
+        desktopTarget: HTMLDivElement;
+        mobileTarget: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluFacetsSidebarLayout.vue.d.ts.map

package/dist/components/systems/facets/UluFacetsSidebarLayout.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluFacetsSidebarLayout.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/UluFacetsSidebarLayout.vue"],"names":[],"mappings":"AAwCA;wBAoPqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;mBASG"}

package/dist/components/systems/facets/UluFacetsSidebarLayout.vue.js

@@ -0,0 +1,78 @@
+import { ref as r, inject as h, computed as y, createElementBlock as g, openBlock as i, normalizeClass as m, unref as l, createElementVNode as e, withDirectives as _, createBlock as v, createCommentVNode as p, renderSlot as n, toDisplayString as T, vShow as k, withCtx as B, Teleport as S } from "vue";
+import w from "../../collapsible/UluModal.vue.js";
+const V = { class: "facets-sidebar__header" }, C = { class: "facets-sidebar__mobile-controls" }, F = { class: "facets-sidebar__body" }, M = { class: "facets-sidebar__main" }, j = {
+  __name: "UluFacetsSidebarLayout",
+  props: {
+    mobileButtonText: {
+      type: String,
+      default: "Filters & Sort"
+    },
+    /**
+     * Classes for elements. See UluCollapsible for all available class keys (trigger, content, etc).
+     * The 'icon' key is also available for the icon span.
+     * - Any valid class binding value per element
+     */
+    classes: {
+      type: Object,
+      default: () => ({
+        mobileButton: "button"
+      })
+    }
+  },
+  setup(d) {
+    const o = r(!1), t = h("uluIsMobile"), u = r(null), c = r(null), b = y(() => t.value ? c.value : u.value);
+    return (a, s) => (i(), g("div", {
+      class: m(["facets-sidebar", { "facets-sidebar--filters-hidden": l(t) }])
+    }, [
+      e("div", V, [
+        n(a.$slots, "header")
+      ]),
+      _(e("div", C, [
+        e("button", {
+          class: m(d.classes.mobileButton),
+          onClick: s[0] || (s[0] = (f) => o.value = !0)
+        }, T(d.mobileButtonText), 3)
+      ], 512), [
+        [k, l(t)]
+      ]),
+      e("div", F, [
+        _(e("div", {
+          class: "facets-sidebar__sidebar",
+          ref_key: "desktopTarget",
+          ref: u
+        }, null, 512), [
+          [k, !l(t)]
+        ]),
+        e("div", M, [
+          n(a.$slots, "main")
+        ])
+      ]),
+      l(t) ? (i(), v(w, {
+        key: 0,
+        modelValue: o.value,
+        "onUpdate:modelValue": s[1] || (s[1] = (f) => o.value = f),
+        position: "right",
+        title: "Filters & Sort",
+        allowResize: ""
+      }, {
+        default: B(() => [
+          e("div", {
+            class: "facets-sidebar__sidebar",
+            ref_key: "mobileTarget",
+            ref: c
+          }, null, 512)
+        ]),
+        _: 1
+      }, 8, ["modelValue"])) : p("", !0),
+      b.value ? (i(), v(S, {
+        key: 1,
+        to: b.value
+      }, [
+        n(a.$slots, "sidebar")
+      ], 8, ["to"])) : p("", !0)
+    ], 2));
+  }
+};
+export {
+  j as default
+};

package/dist/components/systems/facets/UluFacetsSort.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "update:modelValue", ...args: any[]) => void;
+    classes: Record<string, any>;
+    modelValue: string;
+    sortTypes: Record<string, any>;
+    $props: {
+        readonly classes?: Record<string, any> | undefined;
+        readonly modelValue?: string | undefined;
+        readonly sortTypes?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluFacetsSort.vue.d.ts.map

package/dist/components/systems/facets/UluFacetsSort.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluFacetsSort.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/UluFacetsSort.vue"],"names":[],"mappings":"AAoBA;wBA4IqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAZjC;;;;;;;;;;sPASG"}

package/dist/components/systems/facets/UluFacetsSort.vue.js

@@ -0,0 +1,49 @@
+import { createElementBlock as l, openBlock as a, normalizeClass as o, createElementVNode as u, unref as d, renderSlot as f, createTextVNode as p, Fragment as v, renderList as y, toDisplayString as V } from "vue";
+import { newId as g } from "../../../utils/dom.js";
+const S = ["for"], b = ["value", "id"], x = ["value"], k = {
+  __name: "UluFacetsSort",
+  props: {
+    classes: {
+      type: Object,
+      default: () => ({})
+    },
+    sortTypes: {
+      type: Object,
+      default: () => ({})
+    },
+    modelValue: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: c }) {
+    const i = c, r = g("ulu-facet-sort");
+    return (m, t) => (a(), l("div", {
+      class: o(["facets-sort", e.classes.container])
+    }, [
+      u("label", {
+        for: d(r),
+        class: o(e.classes.label)
+      }, [
+        f(m.$slots, "default", {}, () => [
+          t[1] || (t[1] = p("Sort:", -1))
+        ])
+      ], 10, S),
+      u("select", {
+        value: e.modelValue,
+        onChange: t[0] || (t[0] = (s) => i("update:modelValue", s.target.value)),
+        id: d(r),
+        class: o(e.classes.select)
+      }, [
+        (a(!0), l(v, null, y(e.sortTypes, (s, n) => (a(), l("option", {
+          value: n,
+          key: n
+        }, V(s.text), 9, x))), 128))
+      ], 42, b)
+    ], 2));
+  }
+};
+export {
+  k as default
+};

package/dist/components/systems/facets/_mock-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_mock-data.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/_mock-data.js"],"names":[],"mappings":"AAAA;;;;;;;;IAwBE;AAEF;;;;;;;IAaE"}

package/dist/{types/components → components}/systems/facets/useFacets.d.ts

@@ -15,7 +15,7 @@
  * @param {import('vue-router').Router} [options.urlSync.router] - The Vue Router instance.
  * @param {import('vue-router').RouteLocationNormalizedLoaded} [options.urlSync.route] - The current route instance.
  */
-export function useFacets(allItems: import("vue").Ref<Array<Object>>, options?: {
+export function useFacets(allItems: import('vue').Ref<Array<Object>>, options?: {
     initialFacets?: any[] | undefined;
     facetFields?: any[] | undefined;
     initialSearchValue?: string | undefined;
@@ -26,14 +26,14 @@ export function useFacets(allItems: import("vue").Ref<Array<Object>>, options?:
     getSortValue?: Function | undefined;
     countMode?: string | undefined;
     urlSync?: {
-        router?: import("vue-router").Router | undefined;
-        route?: import("vue-router").RouteLocationNormalizedLoadedGeneric | undefined;
+        router?: import('vue-router').Router | undefined;
+        route?: import('vue-router').RouteLocationNormalizedLoadedGeneric | undefined;
     } | undefined;
 }): {
-    facets: import("vue").Ref<never[], never[]>;
-    searchValue: import("vue").Ref<string, string>;
-    selectedSort: import("vue").Ref<string, string>;
-    sortTypes: import("vue").ComputedRef<{
+    facets: import('vue').Ref<never[], never[]>;
+    searchValue: import('vue').Ref<string, string>;
+    selectedSort: import('vue').Ref<string, string>;
+    sortTypes: import('vue').ComputedRef<{
         constructor: Function;
         toString(): string;
         toLocaleString(): string;
@@ -50,8 +50,8 @@ export function useFacets(allItems: import("vue").Ref<Array<Object>>, options?:
             sort: (items: any) => any;
         } | undefined;
     }>;
-    displayItems: import("vue").ComputedRef<any>;
-    selectedFacets: import("vue").ComputedRef<any[]>;
+    displayItems: import('vue').ComputedRef<any>;
+    selectedFacets: import('vue').ComputedRef<any[]>;
     clearFilters: () => void;
     handleFacetChange: ({ groupUid, facetUid, selected }: {
         groupUid: any;

package/dist/components/systems/facets/useFacets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFacets.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/useFacets.js"],"names":[],"mappings":"AA+GA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAfW,OAAO,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,YAExC;IAAwB,aAAa;IACb,WAAW;IACV,kBAAkB;IAClB,eAAe;IACd,cAAc;IACf,cAAc;IACd,aAAa;IACX,YAAY;IACd,SAAS;IACT,OAAO;;;;CAGlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkWA"}

package/dist/components/systems/facets/useFacets.js

@@ -0,0 +1,226 @@
+import { ref as T, computed as F, watch as $, watchPostEffect as G } from "vue";
+import H from "fuse.js";
+function K(u) {
+  const h = /* @__PURE__ */ new Set();
+  for (const d of u)
+    for (const c of d)
+      h.add(c);
+  return h;
+}
+function k(u) {
+  if (!u || u.length === 0) return /* @__PURE__ */ new Set();
+  const h = u.sort((c, S) => c.size - S.size), d = new Set(h[0]);
+  for (let c = 1; c < h.length; c++) {
+    for (const S of d)
+      h[c].has(S) || d.delete(S);
+    if (d.size === 0) break;
+  }
+  return d;
+}
+function O(u, h, d) {
+  if (!u || u.length === 0)
+    return d;
+  const c = u.map((S) => {
+    const z = S.children.map((b) => {
+      const v = `${S.uid}:${b.uid}`;
+      return h.get(v) || /* @__PURE__ */ new Set();
+    });
+    return S.match === "all" ? k(z) : K(z);
+  });
+  return k(c);
+}
+function Q(u, h) {
+  return !h || !Array.isArray(h) ? [] : h.map((d) => {
+    const c = /* @__PURE__ */ new Set(), S = d.getValue || ((v) => v[d.uid]);
+    u.forEach((v) => {
+      const E = S(v);
+      Array.isArray(E) ? E.forEach((I) => I && c.add(I)) : E && c.add(E);
+    });
+    const z = d.getLabel || ((v) => v), b = [...c].map((v) => ({
+      uid: v,
+      label: z(v),
+      selected: !1
+    }));
+    return b.sort((v, E) => String(v.label).localeCompare(String(E.label))), {
+      ...d,
+      children: b
+    };
+  });
+}
+function ee(u, h = {}) {
+  const {
+    initialFacets: d,
+    facetFields: c,
+    initialSearchValue: S = "",
+    initialSortType: z = "az",
+    noDefaultSorts: b = !1,
+    extraSortTypes: v = {},
+    searchOptions: E = {},
+    getSortValue: I = (e) => e.title || e.label || "",
+    countMode: q = "none",
+    // 'none', 'simple', 'intuitive'
+    urlSync: U
+  } = h, B = (e) => e.sort((t, a) => {
+    const n = I(t), s = I(a);
+    return n && s ? String(n).localeCompare(String(s)) : n ? -1 : s ? 1 : 0;
+  }), N = {
+    az: { text: "A-Z", sort: B },
+    za: { text: "Z-A", sort: (e) => B(e).reverse() }
+  };
+  function Z(e) {
+    return (e || []).map((t) => ({
+      ...t,
+      open: t.open || !1,
+      children: t.children.map((a) => ({
+        ...a,
+        selected: a.selected || !1
+      })),
+      selectedCount: 0
+    }));
+  }
+  const f = T([]), x = T(S), V = T(z), j = F(() => !c || !u.value?.length ? null : Q(u.value, c)), _ = F(() => ({
+    ...b ? {} : N,
+    ...v
+  })), M = F(() => {
+    const e = /* @__PURE__ */ new Map(), t = y.value;
+    if (!t || !c) return e;
+    const a = new Map(c.map((n) => {
+      const s = n.getValue || ((o) => o[n.uid]);
+      return [n.uid, s];
+    }));
+    for (let n = 0; n < t.length; n++) {
+      const s = t[n];
+      for (const o of c) {
+        const r = a.get(o.uid)(s), i = Array.isArray(r) ? r : r ? [r] : [];
+        for (const m of i) {
+          const p = `${o.uid}:${m}`;
+          e.has(p) || e.set(p, /* @__PURE__ */ new Set()), e.get(p).add(n);
+        }
+      }
+    }
+    return e;
+  }), D = F(() => ({
+    shouldSort: !0,
+    keys: ["title", "label", "description", "author"],
+    ...E
+  })), y = F(() => x.value?.length ? new H(u.value, D.value).search(x.value).map((t) => t.item) : u.value), A = F(() => {
+    const e = [];
+    return f.value.forEach((t) => {
+      const a = t.children.filter((n) => n.selected);
+      a.length > 0 && e.push({ ...t, children: a });
+    }), e;
+  }), J = F(() => {
+    if (!A.value.length)
+      return y.value;
+    const e = M.value;
+    if (e.size === 0 && y.value.length > 0 && c?.length > 0)
+      return [];
+    const t = new Set(y.value.map((s, o) => o)), a = O(A.value, e, t), n = [];
+    for (const s of a)
+      n.push(y.value[s]);
+    return n;
+  }), P = F(() => {
+    const e = _.value[V.value]?.sort;
+    return typeof e != "function" ? J.value : e([...J.value]);
+  });
+  function R() {
+    f.value.forEach((e) => {
+      e.children && e.children.forEach((t) => t.selected = !1), e.selectedCount = 0;
+    });
+  }
+  function L({ groupUid: e, facetUid: t, selected: a }) {
+    const n = f.value.find((s) => s.uid === e);
+    if (n) {
+      !n.multiple && a && n.children.forEach((o) => {
+        o.uid !== t && (o.selected = !1);
+      });
+      const s = n.children.find((o) => o.uid === t);
+      s && (s.selected = a), n.selectedCount = n.children.filter((o) => o.selected).length;
+    }
+  }
+  if ($(j, (e) => {
+    const t = Z(d || e);
+    t.forEach((a) => {
+      a.selectedCount = a.children.filter((n) => n.selected).length;
+    }), f.value = t;
+  }, { immediate: !0 }), $([A, y], ([e, t], [a, n]) => {
+    if (!(q === "none" || !f.value.length) && !(e === a && t === n)) {
+      if (q === "simple") {
+        const s = M.value;
+        if (s.size === 0 && y.value.length > 0 && c?.length > 0)
+          return;
+        const o = new Set(y.value.map((l, r) => r));
+        f.value.forEach((l) => {
+          const r = e.filter((m) => m.uid !== l.uid), i = O(r, s, o);
+          l.children.forEach((m) => {
+            const p = `${l.uid}:${m.uid}`, g = s.get(p) || /* @__PURE__ */ new Set(), w = k([i, g]);
+            m.count = w.size;
+          });
+        });
+      } else if (q === "intuitive") {
+        const s = M.value;
+        if (s.size === 0 && y.value.length > 0 && c?.length > 0)
+          return;
+        const o = new Set(y.value.map((r, i) => i)), l = O(e, s, o);
+        f.value.forEach((r) => {
+          r.children.forEach((i) => {
+            const m = `${r.uid}:${i.uid}`, p = s.get(m) || /* @__PURE__ */ new Set();
+            if (i.selected)
+              if (r.multiple) {
+                const g = k([l, p]);
+                i.count = g.size;
+              } else
+                i.count = l.size;
+            else {
+              const g = [];
+              for (const C of e)
+                g.push({ ...C, children: [...C.children] });
+              let w = g.find((C) => C.uid === r.uid);
+              w || (w = { ...r, children: [] }, g.push(w)), r.multiple ? w.children.push(i) : w.children = [i];
+              const W = O(g, s, o);
+              i.count = W.size;
+            }
+          });
+        });
+      }
+    }
+  }, { deep: !0, immediate: !0 }), U?.router && U?.route) {
+    const { router: e, route: t } = U, a = () => f.value && f.value.length > 0, n = () => {
+      if (!a()) return;
+      const l = { ...t.query };
+      delete l.sort, delete l.search, f.value.forEach((r) => delete l[r.uid]), V.value && V.value !== z && (l.sort = V.value), x.value && (l.search = x.value), A.value.forEach((r) => {
+        r.children.length > 0 && (l[r.uid] = r.children.map((i) => i.uid).join(","));
+      }), JSON.stringify(l) !== JSON.stringify(t.query) && e.push({ query: l });
+    }, s = () => {
+      const l = t.query;
+      l.sort && (V.value = l.sort), l.search && (x.value = l.search);
+      const r = /* @__PURE__ */ new Map();
+      f.value.forEach((i) => {
+        const m = l[i.uid] ? l[i.uid].split(",") : [];
+        r.set(i.uid, new Set(m));
+      }), f.value.forEach((i) => {
+        const m = r.get(i.uid) || /* @__PURE__ */ new Set();
+        i.children.forEach((p) => {
+          const g = p.selected, w = m.has(p.uid);
+          g !== w && L({ groupUid: i.uid, facetUid: p.uid, selected: w });
+        });
+      });
+    }, o = G(() => {
+      f.value && f.value.length > 0 && (s(), o());
+    });
+    $([V, x, A], n, { deep: !0 }), $(() => t.query, s);
+  }
+  return {
+    facets: f,
+    searchValue: x,
+    selectedSort: V,
+    sortTypes: _,
+    displayItems: P,
+    selectedFacets: A,
+    clearFilters: R,
+    handleFacetChange: L
+  };
+}
+export {
+  ee as useFacets
+};

package/dist/components/systems/index.d.ts

@@ -0,0 +1,31 @@
+export { useFacets } from './facets/useFacets.js';
+export { default as UluFacetsActiveFilters } from './facets/UluFacetsActiveFilters.vue';
+export { default as UluFacetsFilterLists } from './facets/UluFacetsFilterLists.vue';
+export { default as UluFacetsFilterAccordions } from './facets/UluFacetsFilterAccordions.vue';
+export { default as UluFacetsFilterPopovers } from './facets/UluFacetsFilterPopovers.vue';
+export { default as UluFacetsFilterSelects } from './facets/UluFacetsFilterSelects.vue';
+export { default as UluFacetsHeaderLayout } from './facets/UluFacetsHeaderLayout.vue';
+export { default as UluFacetsResults } from './facets/UluFacetsResults.vue';
+export { default as UluFacetsSearch } from './facets/UluFacetsSearch.vue';
+export { default as UluFacetsSidebarLayout } from './facets/UluFacetsSidebarLayout.vue';
+export { default as UluFacetsSort } from './facets/UluFacetsSort.vue';
+export { default as UluFacetsList } from './facets/UluFacetsList.vue';
+export { useScrollAnchors } from './scroll-anchors/useScrollAnchors.js';
+export { useScrollAnchorSection } from './scroll-anchors/useScrollAnchorSection.js';
+export { useScrollAnchorSections } from './scroll-anchors/useScrollAnchorSections.js';
+export { default as UluScrollAnchors } from './scroll-anchors/UluScrollAnchors.vue';
+export { default as UluScrollAnchorsNav } from './scroll-anchors/UluScrollAnchorsNav.vue';
+export { default as UluScrollAnchorsNavAnimated } from './scroll-anchors/UluScrollAnchorsNavAnimated.vue';
+export { default as UluScrollAnchorsSection } from './scroll-anchors/UluScrollAnchorsSection.vue';
+export { default as UluScrollAnchorsHeadlessSection } from './scroll-anchors/UluScrollAnchorsHeadlessSection.vue';
+export { default as UluShowSkeleton } from './skeleton/UluShowSkeleton.vue';
+export { default as UluSkeletonContent } from './skeleton/UluSkeletonContent.vue';
+export { default as UluSkeletonMedia } from './skeleton/UluSkeletonMedia.vue';
+export { default as UluSkeletonText } from './skeleton/UluSkeletonText.vue';
+export { default as UluImageSlideShow } from './slider/UluImageSlideShow.vue';
+export { default as UluSlideShow } from './slider/UluSlideShow.vue';
+export { default as UluSlideShowSlide } from './slider/UluSlideShowSlide.vue';
+export { default as UluTableSticky } from './table-sticky/UluTableSticky.vue';
+export { default as UluTableStickyRows } from './table-sticky/UluTableStickyRows.vue';
+export { default as UluTableStickyTable } from './table-sticky/UluTableStickyTable.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/systems/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/components/systems/index.js"],"names":[],"mappings":""}

package/dist/components/systems/scroll-anchors/UluScrollAnchors.vue.d.ts

@@ -0,0 +1,29 @@
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    $emit: (event: "section-change", ...args: any[]) => void;
+    firstItemActive: boolean;
+    observerOptions: Record<string, any>;
+    debug: boolean;
+    $props: {
+        readonly firstItemActive?: boolean | undefined;
+        readonly observerOptions?: Record<string, any> | undefined;
+        readonly debug?: boolean | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    componentEl: HTMLDivElement;
+}, HTMLDivElement>;
+type __VLS_TemplateResult = {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        componentEl: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+//# sourceMappingURL=UluScrollAnchors.vue.d.ts.map

package/dist/components/systems/scroll-anchors/UluScrollAnchors.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UluScrollAnchors.vue.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/scroll-anchors/UluScrollAnchors.vue"],"names":[],"mappings":"AAKA;wBAiKqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAbjC;;;;;;;;;;;;mBAUG"}