vlite3 1.4.28 → 1.4.31

package/components/Form/index.vue.d.ts

@@ -35,11 +35,11 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     size: InputSize;
     rounded: InputRounded;
     readonly: boolean;
+    draggable: boolean;
     disabled: boolean;
     layout: "table" | "accordion";
     isUpdate: boolean;
     modelValue: Record<string, any>[];
-    draggable: boolean;
     errors: Record<string, string>;
     showRowNumbers: boolean;
     accordionTitleKey: string;

package/components/GoogleMap.vue.d.ts

@@ -0,0 +1,48 @@
+import { GoogleMapClickEvent, GoogleMapCoordinate, GoogleMapError, GoogleMapMarker, GoogleMapMarkerClickEvent, GoogleMapProps, GoogleMapReadyEvent } from '../types/GoogleMap.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        loading?(_: {}): any;
+        error?(_: {
+            error: GoogleMapError;
+        }): any;
+    };
+    refs: {
+        mapElement: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<GoogleMapProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (error: GoogleMapError) => any;
+    click: (event: GoogleMapClickEvent) => any;
+    ready: (event: GoogleMapReadyEvent) => any;
+    "center-changed": (center: GoogleMapCoordinate) => any;
+    "zoom-changed": (zoom: number) => any;
+    "marker-click": (event: GoogleMapMarkerClickEvent) => any;
+}, string, import('vue').PublicProps, Readonly<GoogleMapProps> & Readonly<{
+    onError?: (error: GoogleMapError) => any;
+    onClick?: (event: GoogleMapClickEvent) => any;
+    onReady?: (event: GoogleMapReadyEvent) => any;
+    "onCenter-changed"?: (center: GoogleMapCoordinate) => any;
+    "onZoom-changed"?: (zoom: number) => any;
+    "onMarker-click"?: (event: GoogleMapMarkerClickEvent) => any;
+}>, {
+    width: string | number;
+    height: string | number;
+    options: import('..').GoogleMapOptions;
+    zoom: number;
+    markers: GoogleMapMarker[];
+    ariaLabel: string;
+    loadingText: string;
+    errorText: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    mapElement: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/GoogleMap.vue.js

@@ -0,0 +1,7 @@
+import o from "./GoogleMap.vue2.js";
+/* empty css               */
+import t from "../_virtual/_plugin-vue_export-helper.js";
+const c = /* @__PURE__ */ t(o, [["__scopeId", "data-v-0cfbb6c9"]]);
+export {
+  c as default
+};

package/components/GoogleMap.vue2.js

@@ -0,0 +1,164 @@
+import { defineComponent as P, shallowRef as i, computed as u, watch as f, onMounted as Z, onBeforeUnmount as j, openBlock as h, createElementBlock as k, normalizeStyle as q, createElementVNode as D, renderSlot as N, createTextVNode as S, toDisplayString as c, createCommentVNode as L, markRaw as M, nextTick as H } from "vue";
+import { useVLiteConfig as U } from "../core/config.js";
+import { onGoogleMapsAuthFailure as J, loadGoogleMaps as Q } from "../utils/GoogleMapLoader.js";
+const W = ["aria-label", "aria-busy"], X = {
+  key: 0,
+  class: "vlite-google-map__state",
+  role: "status",
+  "aria-live": "polite"
+}, Y = {
+  key: 1,
+  class: "vlite-google-map__state vlite-google-map__state--error",
+  role: "alert"
+}, ee = {
+  key: 2,
+  class: "vlite-google-map__notice",
+  "aria-live": "polite"
+}, oe = /* @__PURE__ */ P({
+  __name: "GoogleMap",
+  props: {
+    apiKey: {},
+    center: {},
+    markers: { default: () => [] },
+    zoom: { default: 12 },
+    height: { default: "400px" },
+    width: { default: "100%" },
+    options: { default: () => ({}) },
+    ariaLabel: { default: "Interactive Google map" },
+    loadingText: { default: "Loading map…" },
+    errorText: { default: "The map is unavailable." }
+  },
+  emits: ["ready", "click", "center-changed", "zoom-changed", "marker-click", "error"],
+  setup(d, { emit: F }) {
+    const l = d, n = F, K = U(), v = i(null), a = i(null), o = i(null), y = i([]), w = [], x = [], s = i(!0), r = i(null);
+    let b = null, _ = !1;
+    const O = J((e) => {
+      _ || g(e);
+    }), C = u(() => l.apiKey?.trim() || K.components?.googleMap?.apiKey?.trim()), R = u(() => ({
+      height: A(l.height),
+      width: A(l.width)
+    }));
+    function A(e) {
+      return typeof e == "number" ? `${e}px` : e;
+    }
+    function E(e) {
+      if (!e || typeof e != "object") return !1;
+      const t = e;
+      return Number.isFinite(t.lat) && Number.isFinite(t.lng) && t.lat >= -90 && t.lat <= 90 && t.lng >= -180 && t.lng <= 180;
+    }
+    const m = u(
+      () => l.markers.filter((e) => E(e))
+    ), z = u(() => l.markers.length - m.value.length), p = u(() => E(l.center) ? l.center : m.value[0] ?? null);
+    function g(e) {
+      r.value = e, s.value = !1, n("error", e);
+    }
+    function T() {
+      x.splice(0).forEach((e) => e.remove()), y.value.forEach((e) => {
+        o.value?.maps.event.clearInstanceListeners(e), e.setMap(null);
+      }), y.value = [];
+    }
+    function G() {
+      !a.value || !o.value || (T(), y.value = m.value.map((e, t) => {
+        const I = M(
+          new o.value.maps.Marker({
+            map: a.value,
+            position: { lat: e.lat, lng: e.lng },
+            title: e.title,
+            label: e.label
+          })
+        );
+        return x.push(
+          I.addListener(
+            "click",
+            ($) => n("marker-click", { marker: e, index: t, nativeEvent: $ })
+          )
+        ), I;
+      }));
+    }
+    function V() {
+      a.value && w.push(
+        a.value.addListener("click", (e) => {
+          const t = e?.latLng;
+          n("click", {
+            coordinate: t ? { lat: t.lat(), lng: t.lng() } : null,
+            nativeEvent: e
+          });
+        }),
+        a.value.addListener("center_changed", () => {
+          const e = a.value?.getCenter();
+          e && n("center-changed", { lat: e.lat(), lng: e.lng() });
+        }),
+        a.value.addListener("zoom_changed", () => {
+          const e = a.value?.getZoom();
+          typeof e == "number" && n("zoom-changed", e);
+        })
+      );
+    }
+    async function B() {
+      if (!C.value) {
+        g({ code: "invalid-api-key", message: "A Google Maps API key is required." });
+        return;
+      }
+      if (!p.value) {
+        g({
+          code: l.center == null ? "invalid-markers" : "invalid-center",
+          message: "Provide a valid center or at least one valid marker coordinate."
+        });
+        return;
+      }
+      s.value = !0, r.value = null;
+      try {
+        const e = await Q(C.value);
+        if (await H(), _ || !v.value || !p.value) return;
+        o.value = M(e), a.value = M(
+          new e.maps.Map(v.value, {
+            ...l.options,
+            center: p.value,
+            zoom: l.zoom
+          })
+        ), V(), G(), s.value = !1, n("ready", { map: a.value }), typeof ResizeObserver < "u" && (b = new ResizeObserver(() => {
+          a.value && o.value && o.value.maps.event.trigger(a.value, "resize");
+        }), b.observe(v.value));
+      } catch (e) {
+        const t = e;
+        g(
+          t?.code ? t : { code: "load-failed", message: "Google Maps could not be initialized.", cause: e }
+        );
+      }
+    }
+    return f(p, (e) => {
+      e && a.value && a.value.setCenter(e);
+    }), f(() => l.zoom, (e) => a.value?.setZoom(e)), f(() => l.options, (e) => a.value?.setOptions(e), {
+      deep: !0
+    }), f(m, G, { deep: !0 }), Z(B), j(() => {
+      _ = !0, O(), b?.disconnect(), T(), w.splice(0).forEach((e) => e.remove()), a.value && o.value?.maps.event.clearInstanceListeners(a.value), a.value = null, o.value = null;
+    }), (e, t) => (h(), k("div", {
+      class: "vlite-google-map",
+      style: q(R.value),
+      "aria-label": d.ariaLabel,
+      "aria-busy": s.value,
+      role: "region"
+    }, [
+      D("div", {
+        ref_key: "mapElement",
+        ref: v,
+        class: "vlite-google-map__canvas",
+        tabindex: "0"
+      }, null, 512),
+      s.value && !r.value ? (h(), k("div", X, [
+        N(e.$slots, "loading", {}, () => [
+          S(c(d.loadingText), 1)
+        ], !0)
+      ])) : L("", !0),
+      r.value ? (h(), k("div", Y, [
+        N(e.$slots, "error", { error: r.value }, () => [
+          S(c(d.errorText) + " " + c(r.value.message), 1)
+        ], !0)
+      ])) : L("", !0),
+      z.value ? (h(), k("p", ee, c(z.value) + " invalid marker" + c(z.value === 1 ? "" : "s") + " omitted. ", 1)) : L("", !0)
+    ], 12, W));
+  }
+});
+export {
+  oe as default
+};

package/components/NavbarCommandPalette.vue.js

@@ -3,7 +3,7 @@ import L from "./Icon.vue.js";
 import v from "./Modal.vue.js";
 import N from "./CommandPalette/CommandPaletteContent.vue.js";
 import { $t as U } from "../utils/i18n.js";
-/* empty css                                      */
+/* empty css                                       */
 const V = { class: "block truncate -text-fs-1.5" }, S = { class: "ml-auto inline-flex items-center gap-0.5 px-1.5 py-0.5 rounded text-[10px] font-mono font-medium border border-border/80 bg-background text-muted-foreground ml-1" }, A = /* @__PURE__ */ x({
   __name: "NavbarCommandPalette",
   props: {

package/components/Screen/ScreenFilter.vue.js

@@ -16,7 +16,7 @@ import "v-datepicker-lite/style.css";
 /* empty css                      */
 import "@jaames/iro";
 import "@vueuse/core";
-/* empty css                          */
+/* empty css                           */
 import "iconify-icon-picker";
 import "iconify-icon-picker/style.css";
 /* empty css                                 */

package/components/Tabes/Tabes.vue.d.ts

@@ -1,4 +1,4 @@
-import { TabesOption, TabesSize, TabesVariant } from './types';
+import { TabesMenuSelectPayload, TabesOption, TabesSize, TabesVariant } from './types';
 interface Props {
     options: TabesOption[];
     modelValue: string | number;
@@ -12,17 +12,26 @@ interface Props {
      */
     wrap?: boolean;
     tabClass?: string;
+    /** Text direction forwarded to menu dropdowns (LTR/RTL). */
+    direction?: 'ltr' | 'rtl';
 }
 declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     change: (value: string | number) => any;
     "update:modelValue": (value: string | number) => any;
+    "menu-select": (payload: TabesMenuSelectPayload) => any;
+    "menu-open": (tab: TabesOption) => any;
+    "menu-close": (tab: TabesOption) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
     onChange?: (value: string | number) => any;
     "onUpdate:modelValue"?: (value: string | number) => any;
+    "onMenu-select"?: (payload: TabesMenuSelectPayload) => any;
+    "onMenu-open"?: (tab: TabesOption) => any;
+    "onMenu-close"?: (tab: TabesOption) => any;
 }>, {
     variant: TabesVariant;
     size: TabesSize;
     block: boolean;
+    direction: "ltr" | "rtl";
     wrap: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     scrollRef: HTMLDivElement;

package/components/Tabes/Tabes.vue.js

@@ -1,7 +1,7 @@
 import o from "./Tabes.vue2.js";
 /* empty css           */
 import t from "../../_virtual/_plugin-vue_export-helper.js";
-const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-2e086e79"]]);
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-cdf6b045"]]);
 export {
   m as default
 };