@ulu/frontend-vue 0.2.0-beta.11 → 0.2.0-beta.13

package/dist/components/collapsible/UluAccordionGroup.vue.d.ts

@@ -14,7 +14,7 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         readonly items?: unknown[] | undefined;
         readonly modifiers?: string | unknown[] | undefined;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 type __VLS_TemplateResult = {
     attrs: Partial<{}>;
     slots: {
@@ -36,6 +36,6 @@ type __VLS_TemplateResult = {
         }): any;
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 //# sourceMappingURL=UluAccordionGroup.vue.d.ts.map

package/dist/components/collapsible/UluAccordionGroup.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluAccordionGroup.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordionGroup.vue"],"names":[],"mappings":"AA6BA;wBA8QqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;sPAQG"}
+{"version":3,"file":"UluAccordionGroup.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/collapsible/UluAccordionGroup.vue"],"names":[],"mappings":"AAgCA;wBAkRqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;2OAOG"}

package/dist/components/collapsible/UluAccordionGroup.vue.js

@@ -1,6 +1,9 @@
-import { ref as f, watch as p, createElementBlock as g, openBlock as o, Fragment as y, renderList as O, createBlock as v, createSlots as h, withCtx as l, renderSlot as m, createTextVNode as k, toDisplayString as $ } from "vue";
-import S from "./UluAccordion.vue.js";
-const B = { class: "accordion-group" }, x = {
+import { ref as f, watch as p, createElementBlock as g, createCommentVNode as y, openBlock as s, Fragment as O, renderList as h, createBlock as k, createSlots as v, withCtx as l, renderSlot as m, createTextVNode as $, toDisplayString as S } from "vue";
+import B from "./UluAccordion.vue.js";
+const E = {
+  key: 0,
+  class: "accordion-group"
+}, x = {
   __name: "UluAccordionGroup",
   props: {
     /**
@@ -33,30 +36,30 @@ const B = { class: "accordion-group" }, x = {
       default: !0
     }
   },
-  setup(i) {
-    const u = i, s = f([]);
+  setup(a) {
+    const u = a, o = f([]);
     p(() => u.items, (e) => {
-      s.value = e.map((a) => ({
-        ...a,
-        isOpen: a.isOpen || !1
+      o.value = e.map((i) => ({
+        ...i,
+        isOpen: i.isOpen || !1
       }));
     }, { immediate: !0, deep: !0 });
-    function c(e, a) {
-      a ? s.value.forEach((t, r) => {
+    function c(e, i) {
+      i ? o.value.forEach((t, r) => {
         t.isOpen = r === e;
-      }) : s.value[e].isOpen = !1;
+      }) : o.value[e].isOpen = !1;
     }
-    return (e, a) => (o(), g("div", B, [
-      (o(!0), g(y, null, O(s.value, (t, r) => (o(), v(S, {
+    return (e, i) => a.items?.length ? (s(), g("div", E, [
+      (s(!0), g(O, null, h(o.value, (t, r) => (s(), k(B, {
         key: r,
         "model-value": t.isOpen,
         "onUpdate:modelValue": (n) => c(r, n),
         "trigger-text": t.title,
         classes: t.classes,
-        "trigger-text-element": i.triggerTextElement,
-        modifiers: i.modifiers,
-        animate: i.animate
-      }, h({
+        "trigger-text-element": a.triggerTextElement,
+        modifiers: a.modifiers,
+        animate: a.animate
+      }, v({
         default: l(({ isOpen: n, toggle: d }) => [
           m(e.$slots, "item", {
             item: t,
@@ -64,7 +67,7 @@ const B = { class: "accordion-group" }, x = {
             isOpen: n,
             toggle: d
           }, () => [
-            k($(t.content), 1)
+            $(S(t.content), 1)
           ])
         ]),
         _: 2
@@ -92,7 +95,7 @@ const B = { class: "accordion-group" }, x = {
           key: "1"
         } : void 0
       ]), 1032, ["model-value", "onUpdate:modelValue", "trigger-text", "classes", "trigger-text-element", "modifiers", "animate"]))), 128))
-    ]));
+    ])) : y("", !0);
   }
 };
 export {

package/dist/components/elements/UluBadgeStack.vue.d.ts

@@ -3,6 +3,6 @@ declare const _default: import('vue').DefineComponent<{}, {
     $props: {
         readonly items?: unknown[] | undefined;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLUListElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
 //# sourceMappingURL=UluBadgeStack.vue.d.ts.map

package/dist/components/elements/UluBadgeStack.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluBadgeStack.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluBadgeStack.vue"],"names":[],"mappings":"AAWA;"}
+{"version":3,"file":"UluBadgeStack.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluBadgeStack.vue"],"names":[],"mappings":"AAcA;"}

package/dist/components/elements/UluBadgeStack.vue.js

@@ -1,6 +1,9 @@
-import { createElementBlock as e, openBlock as r, Fragment as c, renderList as o, createVNode as n, mergeProps as l } from "vue";
-import m from "./UluBadge.vue.js";
-const _ = { class: "badge-stack" }, f = {
+import { createElementBlock as e, createCommentVNode as c, openBlock as t, Fragment as m, renderList as n, createVNode as o, mergeProps as l } from "vue";
+import u from "./UluBadge.vue.js";
+const i = {
+  key: 0,
+  class: "badge-stack"
+}, g = {
   __name: "UluBadgeStack",
   props: {
     /**
@@ -8,17 +11,17 @@ const _ = { class: "badge-stack" }, f = {
      */
     items: Array
   },
-  setup(t) {
-    return (u, i) => (r(), e("ul", _, [
-      (r(!0), e(c, null, o(t.items, (a, s) => (r(), e("li", {
+  setup(r) {
+    return (_, d) => r.items?.length ? (t(), e("ul", i, [
+      (t(!0), e(m, null, n(r.items, (a, s) => (t(), e("li", {
         class: "badge-stack__item",
         key: s
       }, [
-        n(m, l({ ref_for: !0 }, a), null, 16)
+        o(u, l({ ref_for: !0 }, a), null, 16)
       ]))), 128))
-    ]));
+    ])) : c("", !0);
   }
 };
 export {
-  f as default
+  g as default
 };

package/dist/components/elements/UluDefinitionList.vue.d.ts

@@ -26,7 +26,7 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
         readonly modifiers?: string | unknown[] | undefined;
         readonly items?: unknown[] | undefined;
     };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDListElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 type __VLS_TemplateResult = {
     attrs: Partial<{}>;
     slots: {
@@ -40,6 +40,6 @@ type __VLS_TemplateResult = {
         }): any;
     };
     refs: {};
-    rootEl: HTMLDListElement;
+    rootEl: any;
 };
 //# sourceMappingURL=UluDefinitionList.vue.d.ts.map

package/dist/components/elements/UluDefinitionList.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluDefinitionList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluDefinitionList.vue"],"names":[],"mappings":"AAqBA;wBAqOqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;;;;;;;;;;;;;wPAQG"}
+{"version":3,"file":"UluDefinitionList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluDefinitionList.vue"],"names":[],"mappings":"AAyBA;wBA0OqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}

package/dist/components/elements/UluDefinitionList.vue.js

@@ -1,5 +1,5 @@
-import { computed as u, createElementBlock as l, openBlock as n, normalizeClass as a, unref as B, Fragment as b, renderList as y, createElementVNode as o, renderSlot as c, createTextVNode as d, toDisplayString as m } from "vue";
-import { useModifiers as A } from "../../composables/useModifiers.js";
+import { computed as u, createElementBlock as l, createCommentVNode as B, openBlock as n, normalizeClass as a, unref as y, Fragment as b, renderList as g, createElementVNode as o, renderSlot as c, createTextVNode as d, toDisplayString as m } from "vue";
+import { useModifiers as k } from "../../composables/useModifiers.js";
 const F = {
   __name: "UluDefinitionList",
   props: {
@@ -57,15 +57,16 @@ const F = {
       "separated-first": e.separatedFirst,
       "separated-last": e.separatedLast,
       compact: e.compact
-    })), { resolvedModifiers: f } = A({
+    })), { resolvedModifiers: f } = k({
       props: e,
       internal: p,
       baseClass: "definition-list"
     });
-    return (r, L) => (n(), l("dl", {
-      class: a(["definition-list", [B(f), t.classes.list]])
+    return (r, A) => t.items?.length ? (n(), l("dl", {
+      key: 0,
+      class: a(["definition-list", [y(f), t.classes.list]])
     }, [
-      (n(!0), l(b, null, y(t.items, (s, i) => (n(), l("div", {
+      (n(!0), l(b, null, g(t.items, (s, i) => (n(), l("div", {
         key: i,
         class: a(t.classes.item)
       }, [
@@ -90,7 +91,7 @@ const F = {
           ])
         ], 2)
       ], 2))), 128))
-    ], 2));
+    ], 2)) : B("", !0);
   }
 };
 export {

package/dist/components/elements/UluList.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluList.vue"],"names":[],"mappings":"AA6BA;wBA0OqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAXjC;;;;;;;;;;;;;;;;;;;;;;;2OAQG"}
+{"version":3,"file":"UluList.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/elements/UluList.vue"],"names":[],"mappings":"AA8BA;wBA2OqB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;;6BAEtE,CAAC,EAAE,CAAC;;;AAVjC;;;;;;;;;;;;;;;;;;;;;;;2OAOG"}

package/dist/components/elements/UluList.vue.js

@@ -1,5 +1,5 @@
-import { computed as o, createBlock as u, openBlock as t, resolveDynamicComponent as m, normalizeStyle as y, normalizeClass as n, withCtx as B, createElementBlock as d, Fragment as f, renderList as v, renderSlot as S, createTextVNode as g, toDisplayString as k } from "vue";
-const x = {
+import { computed as n, createBlock as m, createCommentVNode as u, openBlock as t, resolveDynamicComponent as y, normalizeStyle as B, normalizeClass as o, withCtx as f, createElementBlock as d, Fragment as v, renderList as S, renderSlot as g, createTextVNode as k, toDisplayString as C } from "vue";
+const h = {
   __name: "UluList",
   props: {
     /**
@@ -49,9 +49,10 @@ const x = {
     listStyleType: String
   },
   setup(e) {
-    const l = e, r = o(() => l.ordered || l.forceOrdered), c = o(() => r.value ? "ol" : "ul");
-    return (i, O) => (t(), u(m(c.value), {
-      class: n([
+    const l = e, r = n(() => l.ordered || l.forceOrdered), c = n(() => r.value ? "ol" : "ul");
+    return (i, O) => e.items?.length ? (t(), m(y(c.value), {
+      key: 0,
+      class: o([
         {
           "list-ordered": e.ordered,
           "list-unordered": e.unordered,
@@ -60,29 +61,29 @@ const x = {
         },
         e.classes.list
       ]),
-      style: y({
+      style: B({
         listStyleType: e.listStyleType
       }),
       reversed: r.value ? e.reversed : null,
       start: e.start
     }, {
-      default: B(() => [
-        (t(!0), d(f, null, v(e.items, (s, a) => (t(), d("li", {
+      default: f(() => [
+        (t(!0), d(v, null, S(e.items, (s, a) => (t(), d("li", {
           key: a,
-          class: n(e.classes.listItem)
+          class: o(e.classes.listItem)
         }, [
-          S(i.$slots, "default", {
+          g(i.$slots, "default", {
             item: s,
             index: a
           }, () => [
-            g(k(s), 1)
+            k(C(s), 1)
           ])
         ], 2))), 128))
       ]),
       _: 3
-    }, 8, ["class", "style", "reversed", "start"]));
+    }, 8, ["class", "style", "reversed", "start"])) : u("", !0);
   }
 };
 export {
-  x as default
+  h as default
 };

package/dist/components/navigation/UluMenu.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluMenu.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenu.vue"],"names":[],"mappings":"AAmDA;;IAoIM;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IA3BH;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG"}
+{"version":3,"file":"UluMenu.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenu.vue"],"names":[],"mappings":"AAsDA;;IAuIM;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG;;;;;IA3BH;;;;;;;;;;;OAWG;;IAEH;;;OAGG;;;;;IAKH;;OAEG;;IAEH;;OAEG"}

package/dist/components/navigation/UluMenuStack.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluMenuStack.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenuStack.vue"],"names":[],"mappings":"AAqBA;"}
+{"version":3,"file":"UluMenuStack.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluMenuStack.vue"],"names":[],"mappings":"AAsBA;"}

package/dist/components/navigation/UluMenuStack.vue.js

@@ -1,7 +1,7 @@
-import { computed as i, createBlock as o, openBlock as r, resolveDynamicComponent as s, normalizeClass as c, unref as m, withCtx as l, createVNode as u } from "vue";
-import k from "./UluMenu.vue.js";
-import { useModifiers as f } from "../../composables/useModifiers.js";
-const C = {
+import { computed as i, createBlock as o, createCommentVNode as r, openBlock as s, resolveDynamicComponent as m, normalizeClass as c, unref as l, withCtx as u, createVNode as k } from "vue";
+import f from "./UluMenu.vue.js";
+import { useModifiers as d } from "../../composables/useModifiers.js";
+const B = {
   __name: "UluMenuStack",
   props: {
     /**
@@ -33,19 +33,20 @@ const C = {
     modifiers: [String, Array]
   },
   setup(e) {
-    const n = e, t = i(() => ({
-      hanging: n.hanging,
-      compact: n.compact
-    })), { resolvedModifiers: a } = f({
-      props: n,
-      internal: t,
+    const t = e, n = i(() => ({
+      hanging: t.hanging,
+      compact: t.compact
+    })), { resolvedModifiers: a } = d({
+      props: t,
+      internal: n,
       baseClass: "menu-stack"
     });
-    return (_, d) => (r(), o(s(e.containerElement), {
-      class: c(["menu-stack", m(a)])
+    return (_, p) => e.items?.length ? (s(), o(m(e.containerElement), {
+      key: 0,
+      class: c(["menu-stack", l(a)])
     }, {
-      default: l(() => [
-        u(k, {
+      default: u(() => [
+        k(f, {
           items: e.items,
           classes: {
             list: "menu-stack__list",
@@ -60,9 +61,9 @@ const C = {
         }, null, 8, ["items", "noChildren"])
       ]),
       _: 1
-    }, 8, ["class"]));
+    }, 8, ["class"])) : r("", !0);
   }
 };
 export {
-  C as default
+  B as default
 };

package/dist/components/navigation/UluNavStrip.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UluNavStrip.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluNavStrip.vue"],"names":[],"mappings":"AAoBA;;IAwDM;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;IAdH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG"}
+{"version":3,"file":"UluNavStrip.vue.d.ts","sourceRoot":"","sources":["../../../lib/components/navigation/UluNavStrip.vue"],"names":[],"mappings":"AAqBA;;IAyDM;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;IAdH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG"}

package/dist/components/navigation/UluNavStrip.vue.js

@@ -1,7 +1,7 @@
 import n from "./UluMenu.vue.js";
-import { resolveComponent as r, createElementBlock as i, openBlock as o, normalizeClass as s, createVNode as a } from "vue";
-import l from "../../_virtual/_plugin-vue_export-helper.js";
-const c = {
+import { resolveComponent as r, createElementBlock as i, createCommentVNode as o, openBlock as a, normalizeClass as s, createVNode as l } from "vue";
+import c from "../../_virtual/_plugin-vue_export-helper.js";
+const m = {
   name: "UluNavStrip",
   components: {
     UluMenu: n
@@ -25,16 +25,17 @@ const c = {
     rule: Boolean
   }
 };
-function m(p, u, e, _, v, f) {
+function u(_, p, e, v, f, d) {
   const t = r("UluMenu");
-  return o(), i("nav", {
+  return e.items?.length ? (a(), i("nav", {
+    key: 0,
     class: s(["nav-strip", {
       "nav-strip--rule": e.rule,
       "nav-strip--center": e.center,
       "nav-strip--right": e.right
     }])
   }, [
-    a(t, {
+    l(t, {
       items: e.items,
       classes: {
         list: "nav-strip__list",
@@ -43,9 +44,9 @@ function m(p, u, e, _, v, f) {
         linkExactActive: "is-active"
       }
     }, null, 8, ["items"])
-  ], 2);
+  ], 2)) : o("", !0);
 }
-const U = /* @__PURE__ */ l(c, [["render", m]]);
+const U = /* @__PURE__ */ c(m, [["render", u]]);
 export {
   U as default
 };

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

@@ -14,6 +14,7 @@
  * @param {Object} [options.urlSync] - Optional configuration to sync state with URL.
  * @param {import('vue-router').Router} [options.urlSync.router] - The Vue Router instance.
  * @param {import('vue-router').RouteLocationNormalizedLoaded} [options.urlSync.route] - The current route instance.
+ * @param {Function} [options.isPinned] - A function that receives an item and returns true if it should be pinned to the top of the results.
  */
 export function useFacets(allItems: import('vue').Ref<Array<Object>>, options?: {
     initialFacets?: any[] | undefined;
@@ -29,6 +30,7 @@ export function useFacets(allItems: import('vue').Ref<Array<Object>>, options?:
         router?: import('vue-router').Router | undefined;
         route?: import('vue-router').RouteLocationNormalizedLoadedGeneric | undefined;
     } | undefined;
+    isPinned?: Function | undefined;
 }): {
     facets: import('vue').Ref<never[], never[]>;
     searchValue: import('vue').Ref<string, string>;
@@ -51,6 +53,7 @@ export function useFacets(allItems: import('vue').Ref<Array<Object>>, options?:
         } | undefined;
     }>;
     displayItems: import('vue').ComputedRef<any>;
+    pinnedItems: import('vue').ComputedRef<any[] | never[]>;
     selectedFacets: import('vue').ComputedRef<any[]>;
     clearFilters: () => void;
     handleFacetChange: ({ groupUid, facetUid, selected }: {

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

@@ -1 +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"}
+{"version":3,"file":"useFacets.d.ts","sourceRoot":"","sources":["../../../../lib/components/systems/facets/useFacets.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAhBW,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;;;;IAGL,QAAQ;CACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+WA"}

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

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

package/lib/components/collapsible/UluAccordionGroup.vue

@@ -1,5 +1,8 @@
 <template>
-  <div class="accordion-group">
+  <div  
+    v-if="items?.length"
+    class="accordion-group"
+  >
     <UluAccordion
       v-for="(item, index) in internalItems"
       :key="index"

package/lib/components/elements/UluBadgeStack.vue

@@ -1,5 +1,8 @@
 <template>
-  <ul class="badge-stack">
+  <ul 
+    v-if="items?.length"
+    class="badge-stack" 
+  >
     <li
       class="badge-stack__item"
       v-for="(item, index) in items"

package/lib/components/elements/UluDefinitionList.vue

@@ -1,5 +1,9 @@
 <template>
-  <dl class="definition-list" :class="[resolvedModifiers, classes.list]">
+  <dl 
+    v-if="items?.length"
+    class="definition-list" 
+    :class="[resolvedModifiers, classes.list]"
+  >
     <div 
       v-for="(item, index) in items" 
       :key="index"

package/lib/components/elements/UluList.vue

@@ -1,5 +1,6 @@
 <template>
   <component 
+    v-if="items?.length"
     :is="listElement"
     :class="[
       {

package/lib/components/navigation/UluMenu.vue

@@ -1,5 +1,8 @@
 <template>
-  <ul v-if="items?.length" :class="classes.list">
+  <ul 
+    v-if="items?.length" 
+    :class="classes.list"
+  >
     <li 
       v-for="(item, index) in items" 
       :key="index" 

package/lib/components/navigation/UluMenuStack.vue

@@ -1,5 +1,6 @@
 <template>
   <component
+    v-if="items?.length"
     class="menu-stack"
     :is="containerElement" 
     :class="resolvedModifiers"

package/lib/components/navigation/UluNavStrip.vue

@@ -1,5 +1,6 @@
 <template>
   <nav 
+    v-if="items?.length"
     class="nav-strip"
     :class="{
       'nav-strip--rule' : rule,

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

@@ -1,5 +1,7 @@
-import { ref, computed, watch, nextTick, watchPostEffect } from 'vue';
-import Fuse from 'fuse.js';
+import { ref, computed, watch, watchPostEffect } from "vue";
+import Fuse from "fuse.js";
+
+const isFunction = v => typeof v === "function";
 
 /**
  * Helper function to create a union of multiple Sets.
@@ -58,7 +60,7 @@ function getFilteredSetFromIndex(selected, index, allItemsSet) {
     });
 
     // For 'all' (AND), intersect the sets within the group.
-    if (group.match === 'all') {
+    if (group.match === "all") {
       return intersectSets(childSets);
     }
     // For 'some' (OR), union the sets within the group.
@@ -125,19 +127,21 @@ function generateInitialFacets(allItems, facetFields) {
  * @param {Object} [options.urlSync] - Optional configuration to sync state with URL.
  * @param {import('vue-router').Router} [options.urlSync.router] - The Vue Router instance.
  * @param {import('vue-router').RouteLocationNormalizedLoaded} [options.urlSync.route] - The current route instance.
+ * @param {Function} [options.isPinned] - A function that receives an item and returns true if it should be pinned to the top of the results.
  */
 export function useFacets(allItems, options = {}) {
   const {
     initialFacets,
     facetFields,
-    initialSearchValue = '',
-    initialSortType = 'az',
+    initialSearchValue = "",
+    initialSortType = "az",
     noDefaultSorts = false,
     extraSortTypes = {},
     searchOptions: initialSearchOptions = {},
     getSortValue = item => (item.title || item.label || ""),
-    countMode = 'none', // 'none', 'simple', 'intuitive'
-    urlSync: urlSyncOptions
+    countMode = "none", // 'none', 'simple', 'intuitive'
+    urlSync: urlSyncOptions,
+    isPinned
   } = options;
 
   const sortAlpha = items => {
@@ -261,14 +265,22 @@ export function useFacets(allItems, options = {}) {
     return result;
   });
 
-  const displayItems = computed(() => {
+  const displayItemsGrouped = computed(() => {
     const sortFn = sortTypes.value[selectedSort.value]?.sort;
-    if (typeof sortFn !== 'function') {
-      return filteredItems.value;
+    let sorted = isFunction(sortFn) ? sortFn([...filteredItems.value]) : [...filteredItems.value];
+    
+    if (isFunction(isPinned)) {
+      const pinned = [];
+      const unpinned = [];
+      sorted.forEach(item => isPinned(item) ? pinned.push(item) : unpinned.push(item));
+      return { pinned, unpinned, all: [...pinned, ...unpinned] };
     }
-    return sortFn([...filteredItems.value]);
+    return { pinned: [], unpinned: sorted, all: sorted };
   });
 
+  const displayItems = computed(() => displayItemsGrouped.value.all);
+  const pinnedItems = computed(() => displayItemsGrouped.value.pinned);
+
   // --- Methods ---
   function clearFilters() {
     facets.value.forEach(group => {
@@ -309,12 +321,12 @@ export function useFacets(allItems, options = {}) {
   }, { immediate: true });
 
   watch([selectedFacets, searchedItems], ([currentSelected, currentSearchedItems], [prevSelected, prevSearchedItems]) => {
-    if (countMode === 'none' || !facets.value.length) return;
+    if (countMode === "none" || !facets.value.length) return;
 
     // A simple optimization to prevent re-calculating counts if the actual data hasn't changed.
     if (currentSelected === prevSelected && currentSearchedItems === prevSearchedItems) return;
 
-    if (countMode === 'simple') {
+    if (countMode === "simple") {
       const index = facetIndex.value;
       if (index.size === 0 && searchedItems.value.length > 0 && facetFields?.length > 0) {
         return; // Index not ready
@@ -337,7 +349,7 @@ export function useFacets(allItems, options = {}) {
           child.count = intersection.size;
         });
       });
-    } else if (countMode === 'intuitive') {
+    } else if (countMode === "intuitive") {
       const index = facetIndex.value;
       if (index.size === 0 && searchedItems.value.length > 0 && facetFields?.length > 0) {
         // Index might not be ready yet.
@@ -348,7 +360,7 @@ export function useFacets(allItems, options = {}) {
 
       facets.value.forEach(group => {
         group.children.forEach(child => {
-          const key = `${group.uid}:${child.uid}`;
+          const key = `${ group.uid }:${ child.uid }`;
           const childSet = index.get(key) || new Set();
 
           if (child.selected) {
@@ -438,7 +450,7 @@ export function useFacets(allItems, options = {}) {
   
       const selectionsFromUrl = new Map();
       facets.value.forEach(group => {
-        const selectedUids = query[group.uid] ? query[group.uid].split(',') : [];
+        const selectedUids = query[group.uid] ? query[group.uid].split(",") : [];
         selectionsFromUrl.set(group.uid, new Set(selectedUids));
       });
   
@@ -463,7 +475,10 @@ export function useFacets(allItems, options = {}) {
     });
 
     // Sync state changes TO the URL
-    watch([selectedSort, searchValue, selectedFacets], updateUrlFromState, { deep: true });
+    watch(
+      [selectedSort, searchValue, selectedFacets], updateUrlFromState, 
+      { deep: true }
+    );
 
     // Sync URL changes TO the state
     watch(() => route.query, updateStateFromUrl);
@@ -475,6 +490,7 @@ export function useFacets(allItems, options = {}) {
     selectedSort,
     sortTypes,
     displayItems,
+    pinnedItems,
     selectedFacets,
     clearFilters,
     handleFacetChange

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ulu/frontend-vue",
-  "version": "0.2.0-beta.11",
+  "version": "0.2.0-beta.13",
   "description": "A modular and tree-shakeable Vue 3 component library for the Ulu frontend",
   "type": "module",
   "files": [
@@ -45,7 +45,8 @@
     "design-system",
     "ulu",
     "frontend",
-    "scss"
+    "scss",
+    "theme"
   ],
   "author": "Joseph Scherben <jscherbe@gmail.com>",
   "license": "MIT",