@leavepulse/ui 0.78.0 → 0.78.2

package/dist/chunks/{DropzoneLinkField-DXIr0eFz.js → DropzoneLinkField-CyE7TJ5f.js}

@@ -1,6 +1,6 @@
 import { defineComponent, useModel, ref, openBlock, createElementBlock, createElementVNode, createVNode, withCtx, createTextVNode, toDisplayString, normalizeClass, mergeModels } from "vue";
 import { _ as _sfc_main$2 } from "./LpButton-DSHioIfD.js";
-import { _ as _sfc_main$1 } from "./LpInput-DL6HEJdi.js";
+import { _ as _sfc_main$1 } from "./LpInput-CbI7z5fQ.js";
 const _hoisted_1 = { class: "flex w-full flex-col gap-1.5" };
 const _hoisted_2 = { class: "flex items-center gap-2" };
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/dist/chunks/FieldLeading-mr81aEAP.js

@@ -0,0 +1,27 @@
+import { defineComponent, openBlock, createElementBlock, renderSlot, createVNode, createCommentVNode } from "vue";
+import { _ as _sfc_main$1 } from "./LpIcon-C6JpQ5td.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "flex shrink-0 items-center text-muted"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "FieldLeading",
+  props: {
+    icon: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return _ctx.$slots.default || __props.icon ? (openBlock(), createElementBlock("span", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default", {}, () => [
+          createVNode(_sfc_main$1, {
+            name: __props.icon,
+            size: 16
+          }, null, 8, ["name"])
+        ])
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/chunks/LpAddressInput-ft8fQOGx.js

@@ -0,0 +1,401 @@
+import { defineComponent, defineAsyncComponent, computed, watch, ref, onMounted, openBlock, createBlock, normalizeProps, guardReactiveProps, unref, withCtx, createElementVNode, mergeProps, createVNode, createCommentVNode, createElementBlock, createTextVNode, toDisplayString, renderSlot, normalizeClass } from "vue";
+import { _ as _sfc_main$1 } from "./FieldWrapper-DnuMTrqW.js";
+import { useAsyncTask } from "../composables/useAsyncTask.js";
+import { OSM_TILES, createNominatimProvider, emptyAddress, formatAddress } from "../components/address.js";
+import { flagEmoji, loadCountries } from "../components/countries.js";
+import { _ as _sfc_main$3 } from "./LpAutocomplete-CrZbd0uv.js";
+import { _ as _sfc_main$4 } from "./LpButton-DSHioIfD.js";
+import { _ as _sfc_main$2 } from "./LpFormField-BKYn9dyP.js";
+import { _ as _sfc_main$5 } from "./LpIcon-C6JpQ5td.js";
+import { _ as _sfc_main$6 } from "./LpInput-CbI7z5fQ.js";
+import { _ as _sfc_main$8 } from "./LpModal-DDvrSAnf.js";
+import { _ as _sfc_main$7 } from "./LpSelect-JFZehOkd.js";
+import { useOwnField, mergeDescribedBy } from "../composables/useField.js";
+import { useLabels } from "../composables/useLpConfig.js";
+import { useMergedAttrs } from "../composables/useMergedClass.js";
+const _hoisted_1 = ["aria-labelledby", "aria-invalid", "aria-describedby"];
+const _hoisted_2 = { class: "flex items-stretch gap-2" };
+const _hoisted_3 = { class: "grid gap-3 sm:grid-cols-[minmax(0,1fr)_10rem]" };
+const _hoisted_4 = {
+  key: 1,
+  class: "flex items-center gap-2"
+};
+const _hoisted_5 = {
+  key: 0,
+  class: "text-xs text-muted"
+};
+const __default__ = { inheritAttrs: false };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "LpAddressInput",
+  props: {
+    modelValue: {},
+    provider: {},
+    tiles: { default: () => OSM_TILES },
+    only: {},
+    secondLine: { type: Boolean },
+    minChars: { default: 3 },
+    debounce: { default: 350 },
+    language: {},
+    disabled: { type: Boolean },
+    invalid: { type: Boolean },
+    error: {},
+    size: { default: "md" },
+    hideMap: { type: Boolean },
+    labels: {}
+  },
+  emits: ["update:modelValue", "pick"],
+  setup(__props, { emit: __emit }) {
+    const LpMapPicker = defineAsyncComponent(() => import("../components/LpMapPicker.vue.js"));
+    const props = __props;
+    const emit = __emit;
+    const DEFAULT_LABELS = {
+      line: "Street and number",
+      linePlaceholder: "Baker Street 221B",
+      secondLine: "Apartment, suite (optional)",
+      secondLinePlaceholder: "Flat 4",
+      city: "City",
+      cityPlaceholder: "London",
+      postalCode: "Postcode",
+      postalCodePlaceholder: "NW1 6XE",
+      country: "Country",
+      countryPlaceholder: "Select country…",
+      countrySearch: "Search country…",
+      pickOnMap: "Pick on map",
+      mapTitle: "Pick a location",
+      mapHint: "Click the map to drop a pin, drag to move around.",
+      use: "Use this address",
+      cancel: "Cancel",
+      searching: "Searching…",
+      noSuggestions: "No suggestions",
+      nothingHere: "No address found here"
+    };
+    const text = useLabels("addressInput", DEFAULT_LABELS, () => props.labels);
+    const fallbackProvider = createNominatimProvider();
+    const geocoder = computed(() => props.provider ?? fallbackProvider);
+    const value = computed(() => props.modelValue ?? emptyAddress());
+    let latest;
+    watch(
+      () => props.modelValue,
+      () => latest = void 0
+    );
+    function patch(changes) {
+      latest = { ...latest ?? value.value, ...changes };
+      emit("update:modelValue", latest);
+    }
+    function edit(changes) {
+      patch({ ...changes, lat: void 0, lon: void 0 });
+    }
+    const allCountries = ref([]);
+    const countries = computed(() => {
+      const only = props.only?.map((code) => code.toUpperCase());
+      return only?.length ? allCountries.value.filter((c) => only.includes(c.iso2)) : allCountries.value;
+    });
+    const countryOptions = computed(
+      () => countries.value.map((country) => ({
+        value: country.iso2,
+        label: `${flagEmoji(country.iso2)} ${country.name}`
+      }))
+    );
+    onMounted(async () => {
+      allCountries.value = await loadCountries();
+    });
+    function useSuggestions(field2) {
+      const options = ref([]);
+      const task = useAsyncTask();
+      function query(term) {
+        if (term.trim().length < props.minChars) {
+          task.cancel();
+          options.value = [];
+          return;
+        }
+        task.run(
+          (signal) => geocoder.value.search(term.trim(), field2, {
+            country: value.value.country || void 0,
+            language: props.language,
+            signal
+          }),
+          {
+            delay: props.debounce,
+            apply: (found) => options.value = found,
+            // Network failure: leave the field usable as free text.
+            fail: () => options.value = []
+          }
+        );
+      }
+      return { options, loading: task.pending, query };
+    }
+    const lineSuggestions = useSuggestions("line");
+    const citySuggestions = useSuggestions("city");
+    function applySuggestion(suggestion, keep) {
+      const parsed = suggestion.address;
+      const changes = { lat: suggestion.lat, lon: suggestion.lon };
+      if (parsed.line && keep !== "line") changes.line = parsed.line;
+      if (parsed.city) changes.city = parsed.city;
+      if (parsed.postalCode) changes.postalCode = parsed.postalCode;
+      if (parsed.country) changes.country = parsed.country;
+      patch(changes);
+    }
+    function onLineSelect(chosen) {
+      const suggestion = lineSuggestions.options.value.find((option) => option.value === chosen);
+      if (suggestion) applySuggestion(suggestion, "line");
+    }
+    function onCitySelect(chosen) {
+      const suggestion = citySuggestions.options.value.find((option) => option.value === chosen);
+      if (suggestion) applySuggestion(suggestion, "city");
+    }
+    const mapOpen = ref(false);
+    const point = ref();
+    const resolved = ref();
+    const resolving = ref(false);
+    computed(
+      () => countries.value.find((c) => c.iso2 === value.value.country)?.name
+    );
+    const preview = computed(() => {
+      if (resolving.value) return text.value.searching;
+      if (!point.value) return text.value.mapHint;
+      if (!resolved.value) return text.value.nothingHere;
+      const parsed = resolved.value.address;
+      return formatAddress(
+        {
+          line: parsed.line ?? "",
+          city: parsed.city ?? "",
+          postalCode: parsed.postalCode ?? "",
+          country: parsed.country ?? ""
+        },
+        countries.value.find((c) => c.iso2 === parsed.country)?.name
+      );
+    });
+    watch(mapOpen, (open) => {
+      if (!open) return;
+      point.value = value.value.lat != null && value.value.lon != null ? { lat: value.value.lat, lon: value.value.lon } : void 0;
+      resolved.value = void 0;
+    });
+    const reverse = useAsyncTask();
+    watch(reverse.pending, (busy) => resolving.value = busy);
+    function onPick(next) {
+      point.value = next;
+      resolved.value = void 0;
+      reverse.run(
+        () => geocoder.value.reverse(next.lat, next.lon, { language: props.language }),
+        {
+          apply: (found) => resolved.value = found,
+          fail: () => resolved.value = void 0
+        }
+      );
+    }
+    function confirmPoint() {
+      if (!point.value) return;
+      const parsed = resolved.value?.address ?? {};
+      patch({
+        line: parsed.line ?? value.value.line,
+        city: parsed.city ?? value.value.city,
+        postalCode: parsed.postalCode ?? value.value.postalCode,
+        country: parsed.country ?? value.value.country,
+        lat: point.value.lat,
+        lon: point.value.lon
+      });
+      emit("pick", point.value);
+      mapOpen.value = false;
+    }
+    const { field, wrapper, ownAttrs } = useOwnField(() => ({ error: props.error, invalid: props.invalid, disabled: props.disabled }));
+    const { class: rootClass, attrs: rest } = useMergedAttrs(
+      "flex flex-col gap-3",
+      () => ownAttrs()
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, normalizeProps(guardReactiveProps(unref(wrapper))), {
+        default: withCtx(() => [
+          createElementVNode("div", mergeProps({
+            role: "group",
+            "aria-labelledby": unref(field).labelId,
+            "aria-invalid": unref(field).invalid || void 0,
+            class: unref(rootClass)
+          }, unref(rest), {
+            "aria-describedby": unref(mergeDescribedBy)(unref(rest)["aria-describedby"], unref(field).describedBy)
+          }), [
+            createVNode(_sfc_main$2, {
+              label: unref(text).line
+            }, {
+              default: withCtx(() => [
+                createElementVNode("div", _hoisted_2, [
+                  createVNode(_sfc_main$3, {
+                    class: "min-w-0 flex-1",
+                    "model-value": value.value.line,
+                    options: unref(lineSuggestions).options.value,
+                    loading: unref(lineSuggestions).loading.value,
+                    filter: false,
+                    "min-chars": __props.minChars,
+                    disabled: unref(field).disabled,
+                    invalid: unref(field).invalid,
+                    size: __props.size,
+                    placeholder: unref(text).linePlaceholder,
+                    "empty-text": unref(text).noSuggestions,
+                    "loading-text": unref(text).searching,
+                    icon: "lucide:map-pin",
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = (next) => {
+                      edit({ line: next });
+                      unref(lineSuggestions).query(next);
+                    }),
+                    onSelect: onLineSelect
+                  }, null, 8, ["model-value", "options", "loading", "min-chars", "disabled", "invalid", "size", "placeholder", "empty-text", "loading-text"]),
+                  !__props.hideMap ? (openBlock(), createBlock(_sfc_main$4, {
+                    key: 0,
+                    variant: "soft",
+                    size: __props.size,
+                    square: "",
+                    disabled: unref(field).disabled,
+                    title: unref(text).pickOnMap,
+                    "aria-label": unref(text).pickOnMap,
+                    onClick: _cache[1] || (_cache[1] = ($event) => mapOpen.value = true)
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(_sfc_main$5, {
+                        name: "lucide:map",
+                        size: 16
+                      })
+                    ]),
+                    _: 1
+                  }, 8, ["size", "disabled", "title", "aria-label"])) : createCommentVNode("", true)
+                ])
+              ]),
+              _: 1
+            }, 8, ["label"]),
+            __props.secondLine ? (openBlock(), createBlock(_sfc_main$6, {
+              key: 0,
+              "model-value": value.value.line2 ?? "",
+              label: unref(text).secondLine,
+              placeholder: unref(text).secondLinePlaceholder,
+              disabled: unref(field).disabled,
+              invalid: unref(field).invalid,
+              size: __props.size,
+              autocomplete: "address-line2",
+              "onUpdate:modelValue": _cache[2] || (_cache[2] = (next) => patch({ line2: next }))
+            }, null, 8, ["model-value", "label", "placeholder", "disabled", "invalid", "size"])) : createCommentVNode("", true),
+            createElementVNode("div", _hoisted_3, [
+              createVNode(_sfc_main$2, {
+                label: unref(text).city
+              }, {
+                default: withCtx(() => [
+                  createVNode(_sfc_main$3, {
+                    "model-value": value.value.city,
+                    options: unref(citySuggestions).options.value,
+                    loading: unref(citySuggestions).loading.value,
+                    filter: false,
+                    "min-chars": __props.minChars,
+                    disabled: unref(field).disabled,
+                    invalid: unref(field).invalid,
+                    size: __props.size,
+                    placeholder: unref(text).cityPlaceholder,
+                    "empty-text": unref(text).noSuggestions,
+                    "loading-text": unref(text).searching,
+                    "onUpdate:modelValue": _cache[3] || (_cache[3] = (next) => {
+                      edit({ city: next });
+                      unref(citySuggestions).query(next);
+                    }),
+                    onSelect: onCitySelect
+                  }, null, 8, ["model-value", "options", "loading", "min-chars", "disabled", "invalid", "size", "placeholder", "empty-text", "loading-text"])
+                ]),
+                _: 1
+              }, 8, ["label"]),
+              createVNode(_sfc_main$6, {
+                "model-value": value.value.postalCode,
+                label: unref(text).postalCode,
+                placeholder: unref(text).postalCodePlaceholder,
+                disabled: unref(field).disabled,
+                invalid: unref(field).invalid,
+                size: __props.size,
+                autocomplete: "postal-code",
+                "onUpdate:modelValue": _cache[4] || (_cache[4] = (next) => edit({ postalCode: next }))
+              }, null, 8, ["model-value", "label", "placeholder", "disabled", "invalid", "size"])
+            ]),
+            createVNode(_sfc_main$2, {
+              label: unref(text).country
+            }, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$7, {
+                  "model-value": value.value.country,
+                  options: countryOptions.value,
+                  placeholder: unref(text).countryPlaceholder,
+                  "search-placeholder": unref(text).countrySearch,
+                  disabled: unref(field).disabled,
+                  invalid: unref(field).invalid,
+                  size: __props.size,
+                  searchable: "",
+                  "onUpdate:modelValue": _cache[5] || (_cache[5] = (next) => edit({ country: String(next ?? "") }))
+                }, null, 8, ["model-value", "options", "placeholder", "search-placeholder", "disabled", "invalid", "size"])
+              ]),
+              _: 1
+            }, 8, ["label"]),
+            !__props.hideMap ? (openBlock(), createElementBlock("div", _hoisted_4, [
+              createVNode(_sfc_main$4, {
+                variant: "soft",
+                size: __props.size === "lg" ? "md" : "sm",
+                disabled: unref(field).disabled,
+                onClick: _cache[6] || (_cache[6] = ($event) => mapOpen.value = true)
+              }, {
+                default: withCtx(() => [
+                  createVNode(_sfc_main$5, {
+                    name: "lucide:map",
+                    size: 15
+                  }),
+                  createTextVNode(" " + toDisplayString(unref(text).pickOnMap), 1)
+                ]),
+                _: 1
+              }, 8, ["size", "disabled"]),
+              value.value.lat != null && value.value.lon != null ? (openBlock(), createElementBlock("span", _hoisted_5, toDisplayString(value.value.lat.toFixed(5)) + ", " + toDisplayString(value.value.lon.toFixed(5)), 1)) : createCommentVNode("", true)
+            ])) : createCommentVNode("", true),
+            createVNode(_sfc_main$8, {
+              open: mapOpen.value,
+              "onUpdate:open": _cache[8] || (_cache[8] = ($event) => mapOpen.value = $event),
+              title: unref(text).mapTitle,
+              size: "2xl"
+            }, {
+              footer: withCtx(() => [
+                createVNode(_sfc_main$4, {
+                  variant: "ghost",
+                  onClick: _cache[7] || (_cache[7] = ($event) => mapOpen.value = false)
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref(text).cancel), 1)
+                  ]),
+                  _: 1
+                }),
+                createVNode(_sfc_main$4, {
+                  disabled: !point.value,
+                  onClick: confirmPoint
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(unref(text).use), 1)
+                  ]),
+                  _: 1
+                }, 8, ["disabled"])
+              ]),
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "map", {
+                  point: point.value,
+                  setPoint: onPick,
+                  tiles: __props.tiles
+                }, () => [
+                  createVNode(unref(LpMapPicker), {
+                    "model-value": point.value,
+                    tiles: __props.tiles,
+                    "onUpdate:modelValue": onPick
+                  }, null, 8, ["model-value", "tiles"])
+                ]),
+                createElementVNode("p", {
+                  class: normalizeClass(["mt-3 min-h-5 text-sm", resolved.value || resolving.value ? "text-ink" : "text-muted"])
+                }, toDisplayString(preview.value), 3)
+              ]),
+              _: 3
+            }, 8, ["open", "title"])
+          ], 16, _hoisted_1)
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/chunks/{LpAppShell-BNAVTQsY.js → LpAppShell-DkvU6IBB.js}

@@ -5,13 +5,14 @@ import { useScrollMemory } from "../composables/scrollMemory.js";
 import { useView, viewWindow } from "../composables/useView.js";
 import { _ as _sfc_main$6 } from "./AppShellContextNav-C6Ho2mof.js";
 import { DENSITY_CLASS, resolveNavMode, NAV_BREAKPOINT_PX, contextNavItems, headerCollapsedAfter } from "../components/appShell.js";
-import { _ as _sfc_main$8 } from "./LpBottomNav-zxLGGbjm.js";
+import { _ as _sfc_main$9 } from "./LpBottomNav-zxLGGbjm.js";
 import { _ as _sfc_main$2 } from "./LpContextSwitcher-1C1tExdl.js";
 import { _ as _sfc_main$3 } from "./LpButton-DSHioIfD.js";
 import { _ as _sfc_main$4 } from "./LpIcon-C6JpQ5td.js";
-import { _ as _sfc_main$7 } from "./LpScrollArea-ay4Xo_hg.js";
+import { _ as _sfc_main$8 } from "./LpPageScrollbar-D2O0xhJw.js";
+import { _ as _sfc_main$7 } from "./LpScrollArea-CqvwfZs2.js";
 import { _ as _sfc_main$5 } from "./LpShift-DAgS_d2x.js";
-import { _ as _sfc_main$1 } from "./LpSidebar-kSkpPh3-.js";
+import { _ as _sfc_main$1 } from "./LpSidebar-CvRvVBTt.js";
 import { mergeClass, useMergedAttrs } from "../composables/useMergedClass.js";
 import { nodeWindow } from "../composables/realm.js";
 const _hoisted_1 = ["href"];
@@ -37,6 +38,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     contentClass: { default: "mx-auto w-full max-w-6xl" },
     fullBleed: { type: Boolean },
     scroll: { default: "document" },
+    pageScrollbar: { type: Boolean, default: true },
     loading: { type: Boolean },
     labels: {},
     compact: { type: Boolean, default: void 0 },
@@ -176,6 +178,16 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         void nextTick(() => view2.scrollTo({ top, behavior: "instant" }));
       }
     });
+    const bottomBarEl = ref(null);
+    const bottomBarHeight = ref(0);
+    let bottomBarSize;
+    onMounted(() => {
+      const el = bottomBarEl.value?.$el;
+      if (!el || el.nodeType !== 1) return;
+      bottomBarSize = new (nodeWindow(el)).ResizeObserver(() => bottomBarHeight.value = el.offsetHeight);
+      bottomBarSize.observe(el);
+    });
+    onBeforeUnmount(() => bottomBarSize?.disconnect());
     let releaseDocument;
     onMounted(() => {
       if (!documentScroll || !pageEl.value) return;
@@ -560,8 +572,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               _: 3
             }, 512)
           ], 10, _hoisted_4)) : createCommentVNode("", true),
-          __props.bottomNav ? (openBlock(), createBlock(_sfc_main$8, {
+          windowScrolls.value && __props.pageScrollbar ? (openBlock(), createBlock(_sfc_main$8, {
             key: 2,
+            top: "var(--lp-shell-top)",
+            bottom: `${bottomBarHeight.value}px`
+          }, null, 8, ["bottom"])) : createCommentVNode("", true),
+          __props.bottomNav ? (openBlock(), createBlock(_sfc_main$9, {
+            key: 3,
+            ref_key: "bottomBarEl",
+            ref: bottomBarEl,
             class: normalizeClass([burgerHidden[__props.mobileBreakpoint], spanClass.value, windowScrolls.value && `${STICKY} bottom-0`]),
             items: bottomItems.value,
             "is-active": activeTest.value,