@gluhar/app 5.1.5 → 5.2.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.2.0](https://github.com/gluharco/gluhar/compare/@gluhar/app@5.1.5...@gluhar/app@5.2.0) (2026-04-28)
+
+
+### 🚀 Enhancements
+
+- Bump minor ([97ce7ec](https://github.com/gluharco/gluhar/commit/97ce7ece5e0d16846269319bdce425d497895ff1))
+
+
+
+
+
 ## [5.1.5](https://github.com/gluharco/gluhar/compare/@gluhar/app@5.1.4...@gluhar/app@5.1.5) (2026-03-23)
 
 **📝 Note:** Version bump only for package @gluhar/app

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,21 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { GluharI18nOptions } from '@gluhar/i18n';
+import { GluharThemeOptions } from '@gluhar/theme';
+import { GluharSanityOptions } from '@gluhar/sanity';
+import { ModuleOptions } from 'v-gsap-nuxt';
+import { ModuleOptions as ModuleOptions$1 } from '@nuxt/image';
+import { ModuleOptions as ModuleOptions$2 } from 'dayjs-nuxt';
+
+interface GluharAppOptions {
+    theme?: GluharThemeOptions | false;
+    i18n?: GluharI18nOptions | false;
+    sanity?: GluharSanityOptions | false;
+    vgsap?: (ModuleOptions & {
+        dev?: boolean;
+    }) | false;
+    image?: ModuleOptions$1 | false;
+    dayjs?: ModuleOptions$2 | false;
+}
+declare const _default: _nuxt_schema.NuxtModule<GluharAppOptions, GluharAppOptions, false>;
+
+export { type GluharAppOptions, _default as default };

package/dist/module.d.ts

@@ -0,0 +1,21 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { GluharI18nOptions } from '@gluhar/i18n';
+import { GluharThemeOptions } from '@gluhar/theme';
+import { GluharSanityOptions } from '@gluhar/sanity';
+import { ModuleOptions } from 'v-gsap-nuxt';
+import { ModuleOptions as ModuleOptions$1 } from '@nuxt/image';
+import { ModuleOptions as ModuleOptions$2 } from 'dayjs-nuxt';
+
+interface GluharAppOptions {
+    theme?: GluharThemeOptions | false;
+    i18n?: GluharI18nOptions | false;
+    sanity?: GluharSanityOptions | false;
+    vgsap?: (ModuleOptions & {
+        dev?: boolean;
+    }) | false;
+    image?: ModuleOptions$1 | false;
+    dayjs?: ModuleOptions$2 | false;
+}
+declare const _default: _nuxt_schema.NuxtModule<GluharAppOptions, GluharAppOptions, false>;
+
+export { type GluharAppOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@gluhar/app",
+  "configKey": "gluhar",
+  "version": "5.2.0",
+  "builder": {
+    "@nuxt/module-builder": "0.8.3",
+    "unbuild": "2.0.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,59 @@
+import { defineNuxtModule, createResolver, installModule, addImportsDir, addComponentsDir } from '@nuxt/kit';
+import defu from 'defu';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@gluhar/app",
+    configKey: "gluhar"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {},
+  async setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const { theme, i18n, sanity, vgsap, image, dayjs } = options;
+    await installModule("@gluhar/core");
+    await installModule("@pinia/nuxt");
+    if (theme !== false) {
+      await installModule("@gluhar/theme", theme);
+    }
+    if (i18n !== false) {
+      await installModule("@gluhar/i18n", i18n);
+    }
+    if (sanity !== false && i18n !== false) {
+      await installModule("@gluhar/sanity", sanity);
+    }
+    if (vgsap !== false) {
+      if (vgsap?.dev) {
+        await installModule("@gluhar/v-gsap-nuxt", vgsap);
+      } else {
+        await installModule("v-gsap-nuxt", vgsap);
+      }
+    }
+    if (image !== false) {
+      await installModule("@nuxt/image", image);
+    }
+    if (dayjs !== false) {
+      await installModule("dayjs-nuxt", dayjs);
+    }
+    addImportsDir(resolve("runtime/composables"));
+    addComponentsDir({ path: resolve("runtime/components") });
+    addImportsDir(resolve("runtime/stores"));
+    addImportsDir(resolve("runtime/utils"));
+    nuxt.options.vite = defu(nuxt.options.vite, {
+      esbuild: {
+        legalComments: "none"
+      },
+      build: {
+        terserOptions: {
+          format: {
+            comments: false
+          }
+        }
+      }
+    });
+    nuxt.options.experimental.watcher = "parcel";
+    nuxt.options.devtools.enabled = false;
+  }
+});
+
+export { module as default };

package/dist/runtime/components/GContactLink.vue

@@ -0,0 +1,49 @@
+<script setup lang="ts">
+import { useResponsive, computed, ref } from "#imports";
+
+const props = defineProps<{
+  phone?: string;
+  email?: string;
+  onCopy?: () => void;
+}>();
+
+const defaultCursorText = "Copy to clipboard";
+const cursorText = ref(defaultCursorText);
+
+const { isMobile } = useResponsive();
+
+const href = computed(() => {
+  if (!isMobile.value) return undefined;
+  return props.phone ? `tel:${props.phone}` : `mailto:${props.email}`;
+});
+
+const handleClick = async (isPhone: boolean) => {
+  const value = isPhone ? props.phone : props.email;
+
+  if (isMobile.value) return;
+  cursorText.value = "Copied!";
+
+  await navigator.clipboard.writeText(value!);
+
+  props.onCopy?.();
+};
+
+const onMouseLeave = () => {
+  cursorText.value = defaultCursorText;
+};
+</script>
+
+<template>
+  <a :href v-bind="$attrs" v-if="isMobile">
+    <slot> {{ phone || email }} </slot>
+  </a>
+  <div
+    :data-cursor-text="cursorText"
+    @mousedown="handleClick(!!phone)"
+    @mouseleave="onMouseLeave"
+    v-bind="$attrs"
+    v-else
+  >
+    <slot> {{ phone || email }} </slot>
+  </div>
+</template>

package/dist/runtime/components/GLenisScroller.vue

@@ -0,0 +1,40 @@
+<script setup lang="ts">
+import { useResizeObserver } from "@vueuse/core";
+import { ref, type CSSProperties } from "vue";
+import { useLenis } from "#imports";
+
+defineProps<{
+  contentClass?: string;
+  contentStyle?: CSSProperties;
+}>();
+
+const scrollerRef = ref<HTMLDivElement>();
+const contentRef = ref<HTMLDivElement>();
+
+const { lenis } = useLenis(scrollerRef);
+
+const prevHeight = ref(0);
+
+useResizeObserver(contentRef, (entries) => {
+  const entry = entries[0];
+  const { height } = entry.contentRect;
+
+  if (height === prevHeight.value) return;
+
+  prevHeight.value = height;
+  lenis.value?.resize();
+});
+
+defineExpose({
+  lenis,
+  scrollerRef,
+});
+</script>
+
+<template>
+  <div class="lenis-scroller overflow-y-auto" ref="scrollerRef">
+    <div :class="contentClass" :style="contentStyle" ref="contentRef">
+      <slot />
+    </div>
+  </div>
+</template>

package/dist/runtime/components/GluharLogo.vue

@@ -0,0 +1,46 @@
+<script setup lang="ts"></script>
+
+<template>
+  <svg viewBox="0 0 262.1 89" class="fill-secondary-base">
+    <path
+      d="M229.5,28l-15.8-14.6l4.7-4.7l12.2,13.2L229.8,0h6.6l-0.9,21.9L249,6.8l4.7,4.7l-17,16.5l13.9,12.8l-4.7,4.7
+	l-12.8-13.9c-6.4,6.6-10.6,12.6-13.3,18.1c-2.9,6-4.2,12.8-4.2,23.3H209c0-11.1,1.3-19,4.9-26.2C217,40.3,222.9,34.7,229.5,28z
+	 M262.1,31.3l-14.9-0.9v-4.8l14.9-0.9V31.3z"
+    />
+    <path
+      d="M181.4,72.6V38.4h6.2l0.6,5c0.9-1.9,2.4-3.3,4.4-4.2c2-1,4.1-1.4,6.2-1.4c3.7,0,6.9,1.1,9.6,3.2l-2.9,5.6
+	c-1.9-1.6-4.1-2.4-6.7-2.4c-1.7,0-3.4,0.4-4.9,1.2s-2.7,1.9-3.7,3.4s-1.5,3.2-1.5,5.2v18.7L181.4,72.6L181.4,72.6z"
+    />
+    <path
+      d="M153.5,73.5c-4,0-7.4-0.9-10.3-2.7c-2.8-1.9-4.2-4.7-4.2-8.4s1.3-6.4,4-8c2.7-1.7,6.1-2.5,10.1-2.5h13.5
+	c-0.2-2.3-1.3-4.2-3.3-5.7c-2-1.4-4.4-2.2-7.2-2.2c-2.1,0-4,0.4-6,1.2c-1.9,0.8-3.4,2-4.4,3.4l-5.3-2.9c1.6-2.7,3.8-4.7,6.5-6.1
+	c2.8-1.4,5.9-2.2,9.1-2.2c3.1,0,6,0.6,8.7,1.7c2.8,1.1,5,2.8,6.7,5s2.6,4.8,2.6,7.8v14l0.3,6.5h-6.9l-0.6-5.2
+	c-1.1,2-2.9,3.5-5.2,4.6C159.4,73,156.7,73.5,153.5,73.5z M154.2,67c3.3,0,6.3-0.6,8.8-1.8c2.5-1.2,3.8-3.4,3.8-6.5v-1.1h-13.5
+	c-1.9,0-3.5,0.4-4.9,1.1c-1.3,0.8-2,1.9-2,3.5c0,1.7,0.8,2.9,2.4,3.7C150.4,66.7,152.2,67,154.2,67z"
+    />
+    <path
+      d="M98.8,72.6V22.3h7.4v21.1c1-1.9,2.5-3.3,4.4-4.2c1.9-1,4.1-1.4,6.5-1.4c4.7,0,8.8,1.4,12.1,4.2s5,7.2,5,13.2v17.4h-7.5V55
+	c0-3.8-0.9-6.7-2.7-8.5c-1.9-1.8-4.2-2.8-7-2.8c-1.8,0-3.5,0.4-5.2,1.3c-1.6,0.9-3,2.2-4,3.9s-1.5,3.9-1.5,6.4v17.2L98.8,72.6
+	L98.8,72.6z"
+    />
+    <path
+      d="M73.1,73.2c-4.7,0-8.8-1.4-12.1-4.2c-3.3-2.8-5-7.2-5-13.2V38.4h7.5v17.5c0,3.8,0.9,6.7,2.7,8.5c1.9,1.8,4.2,2.8,7,2.8
+	c1.8,0,3.5-0.4,5.2-1.3c1.6-0.9,2.9-2.2,3.9-3.9c1.1-1.8,1.6-3.9,1.6-6.5V38.4h7.4v34.2h-6.6l-0.6-5c-1,1.9-2.5,3.3-4.5,4.2
+	S75.5,73.2,73.1,73.2z"
+    />
+    <path d="M50,72.6h-7.4V22.3H50V72.6z" />
+    <path
+      d="M19.8,89c-4.1,0-7.7-0.4-10.6-1.3c-3-0.9-5.3-2.6-6.9-5.2c-1-1.6-1.5-3.4-1.5-5.3c0-1.5,0.3-2.8,0.9-4.1
+	c0.6-1.2,1.5-2.2,2.7-2.9c-1.4-0.5-2.5-1.3-3.3-2.4C0.4,66.7,0,65.4,0,63.9c0-1.6,0.5-3,1.4-4.2c1-1.2,2.3-2,3.9-2.4
+	c-1-0.9-1.7-1.9-2.2-3.2c-0.5-1.2-0.8-2.5-0.8-3.7c0-2.8,0.8-5.2,2.5-7.2c1.6-1.9,3.8-3.3,6.5-4.1c2.7-0.9,5.6-1.2,8.5-1.1L37,38.3
+	v0.8v3.7v0.9l-3.4-0.1l-1.9-0.1c1.3,0.8,2.3,1.8,3.1,3S36,49,36,50.4c0,2.8-0.8,5.1-2.4,7c-1.6,1.9-3.7,3.3-6.2,4.3
+	c-2.5,0.9-5.2,1.4-8,1.4c-2.4,0-4.8-0.3-7.2-1C11,61.8,9.9,61.6,9,61.6c-0.5,0-1,0.1-1.4,0.2c-0.5,0.2-0.8,0.5-1.1,0.9
+	c-0.2,0.3-0.4,0.7-0.4,1.1c0,0.6,0.3,1.2,0.9,1.7c0.7,0.5,1.6,0.7,2.8,0.7H19c5.5,0,10,0.7,13.6,2.1c3.7,1.3,5.5,4.1,5.5,8.3
+	c0,3-0.9,5.4-2.8,7.2c-1.9,1.9-4.2,3.2-7,4C25.6,88.6,22.7,89,19.8,89z M19.3,57.2c2.3,0,4.5-0.6,6.5-1.7c2-1.1,2.9-2.8,2.9-5
+	c0-2.1-0.9-3.7-2.8-4.9c-1.9-1.1-4.1-1.7-6.7-1.7s-4.9,0.6-6.7,1.7c-1.9,1.1-2.8,2.8-2.8,4.9c0,2.3,1,4,2.9,5.1
+	C14.6,56.6,16.9,57.2,19.3,57.2z M19.7,82.7c3.1,0,5.7-0.6,7.8-1.7c2.2-1.1,3.2-2.7,3.2-4.8c0-1.3-0.5-2.3-1.6-2.8s-2.4-0.9-4.1-1.1
+	c-0.8-0.1-2-0.1-3.5-0.1h-2.4h-9c-0.9,0.4-1.5,1-2,1.7s-0.7,1.5-0.7,2.3c0,1.1,0.4,2.1,1.1,3c0.9,1.1,2.4,2,4.5,2.6
+	C15.1,82.4,17.3,82.7,19.7,82.7z"
+    />
+  </svg>
+</template>

package/dist/runtime/components/SanityImg.vue

@@ -0,0 +1,68 @@
+<script setup lang="ts">
+import { computed, ref, useMessages } from "#imports";
+import type { LocaleString } from "@gluhar/i18n/types";
+import type { SanityImage } from "@gluhar/sanity/types";
+// @ts-ignore
+import imageUrlBuilder from "@sanity/image-url/lib/browser/image-url.esm"; // INFO this is a strange fix
+// import imageUrlBuilder from "@sanity/image-url";
+import type { CropMode, ImageFormat } from "@sanity/image-url/lib/types/types";
+import sanityConfig from "~/config/sanity.config";
+
+const props = defineProps<{
+  image?: SanityImage;
+  alt?: LocaleString;
+  by?: "width" | "height" | "both";
+  width?: number;
+  height?: number;
+  format?: ImageFormat | null;
+  crop?: CropMode;
+  dpr?: number;
+}>();
+
+const { l } = useMessages();
+
+const builder = imageUrlBuilder(sanityConfig);
+const urlFor = (source: SanityImage) => builder.image(source);
+
+const imgRef = ref<HTMLImageElement | null>(null);
+const src = computed(() => {
+  const { width, height } = imgRef.value?.getBoundingClientRect() || {
+    width: undefined,
+    height: undefined,
+  };
+
+  if (!props.image?.asset || (!width && !height)) return undefined;
+
+  let url = urlFor(props.image);
+
+  if (props.width) url = url.width(props.width);
+  else if (width && (props.by === "width" || !props.by))
+    url = url.width(Math.ceil(width));
+
+  if (props.height) url = url.height(props.height);
+  else if (height && (props.by === "height" || !props.by))
+    url = url.height(Math.ceil(height));
+
+  if (props.crop) url = url.fit("crop").crop(props.crop);
+
+  url = url.format(props.format ?? "webp");
+  url = url.quality(100);
+
+  url = url.dpr(
+    props.dpr || typeof window !== "undefined" ? window.devicePixelRatio : 1,
+  );
+
+  return url.url();
+});
+</script>
+
+<template>
+  <img
+    class="object-cover"
+    :style="{ aspectRatio: image?.asset?.metadata?.dimensions?.aspectRatio }"
+    :src
+    :alt="l(alt) || l(image.caption) || l(image.alt)"
+    ref="imgRef"
+    v-if="image"
+  />
+</template>

package/dist/runtime/composables/useLenis.d.ts

@@ -0,0 +1,370 @@
+import Lenis from "lenis";
+import { type Ref } from "vue";
+interface LenisOptions {
+    wrapper?: HTMLElement | string;
+    content?: HTMLElement;
+    lerp?: number;
+    duration?: number;
+    orientation?: "vertical" | "horizontal";
+    gestureOrientation?: "vertical" | "horizontal" | "both";
+    smoothWheel?: boolean;
+    smoothTouch?: boolean;
+    wheelMultiplier?: number;
+    touchMultiplier?: number;
+    normalizeWheel?: boolean;
+    easing?: (t: number) => number;
+}
+export declare const useLenis: (wrapperOrOptions?: string | HTMLElement | Ref<HTMLElement | undefined> | LenisOptions) => {
+    lenis: Ref<{
+        isTouching?: boolean | undefined;
+        time: number;
+        userData: import("lenis").UserData;
+        lastVelocity: number;
+        velocity: number;
+        direction: 1 | -1 | 0;
+        options: {
+            wrapper: Window | HTMLElement | Element;
+            content: HTMLElement | Element;
+            eventsTarget: Window | HTMLElement | Element;
+            smoothWheel: boolean;
+            syncTouch: boolean;
+            syncTouchLerp: number;
+            touchInertiaExponent: number;
+            lerp: number;
+            infinite: boolean;
+            orientation: import("lenis").Orientation;
+            gestureOrientation: import("lenis").GestureOrientation;
+            touchMultiplier: number;
+            wheelMultiplier: number;
+            autoResize: boolean;
+            overscroll: boolean;
+            autoRaf: boolean;
+            anchors: boolean | {
+                offset?: number | undefined;
+                immediate?: boolean | undefined;
+                lock?: boolean | undefined;
+                duration?: number | undefined;
+                easing?: import("lenis").EasingFunction | undefined;
+                lerp?: number | undefined;
+                onStart?: ((lenis: Lenis) => void) | undefined;
+                onComplete?: ((lenis: Lenis) => void) | undefined;
+                force?: boolean | undefined;
+                programmatic?: boolean | undefined;
+                userData?: import("lenis").UserData | undefined;
+            };
+            autoToggle: boolean;
+            allowNestedScroll: boolean;
+            __experimental__naiveDimensions: boolean;
+            virtualScroll?: ((data: import("lenis").VirtualScrollData) => boolean) | undefined;
+            duration?: number | undefined;
+            easing?: import("lenis").EasingFunction | undefined;
+            prevent?: ((node: HTMLElement) => boolean) | undefined;
+        };
+        targetScroll: number;
+        animatedScroll: number;
+        readonly dimensions: {
+            width: number;
+            height: number;
+            scrollHeight: number;
+            scrollWidth: number;
+            destroy: () => void;
+            resize: () => void;
+            onWrapperResize: () => void;
+            onContentResize: () => void;
+            readonly limit: {
+                x: number;
+                y: number;
+            };
+        };
+        destroy: () => void;
+        on: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): () => void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): () => void;
+        };
+        off: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): void;
+        };
+        resize: () => void;
+        start: () => void;
+        stop: () => void;
+        raf: (time: number) => void;
+        scrollTo: (target: number | string | HTMLElement, { offset, immediate, lock, duration, easing, lerp, onStart, onComplete, force, programmatic, userData, }?: import("lenis").ScrollToOptions) => void;
+        readonly rootElement: HTMLElement;
+        readonly limit: number;
+        readonly isHorizontal: boolean;
+        readonly actualScroll: number;
+        readonly scroll: number;
+        readonly progress: number;
+        isScrolling: import("lenis").Scrolling;
+        isStopped: boolean;
+        isLocked: boolean;
+        readonly isSmooth: boolean;
+        readonly className: string;
+    } | null, Lenis | {
+        isTouching?: boolean | undefined;
+        time: number;
+        userData: import("lenis").UserData;
+        lastVelocity: number;
+        velocity: number;
+        direction: 1 | -1 | 0;
+        options: {
+            wrapper: Window | HTMLElement | Element;
+            content: HTMLElement | Element;
+            eventsTarget: Window | HTMLElement | Element;
+            smoothWheel: boolean;
+            syncTouch: boolean;
+            syncTouchLerp: number;
+            touchInertiaExponent: number;
+            lerp: number;
+            infinite: boolean;
+            orientation: import("lenis").Orientation;
+            gestureOrientation: import("lenis").GestureOrientation;
+            touchMultiplier: number;
+            wheelMultiplier: number;
+            autoResize: boolean;
+            overscroll: boolean;
+            autoRaf: boolean;
+            anchors: boolean | {
+                offset?: number | undefined;
+                immediate?: boolean | undefined;
+                lock?: boolean | undefined;
+                duration?: number | undefined;
+                easing?: import("lenis").EasingFunction | undefined;
+                lerp?: number | undefined;
+                onStart?: ((lenis: Lenis) => void) | undefined;
+                onComplete?: ((lenis: Lenis) => void) | undefined;
+                force?: boolean | undefined;
+                programmatic?: boolean | undefined;
+                userData?: import("lenis").UserData | undefined;
+            };
+            autoToggle: boolean;
+            allowNestedScroll: boolean;
+            __experimental__naiveDimensions: boolean;
+            virtualScroll?: ((data: import("lenis").VirtualScrollData) => boolean) | undefined;
+            duration?: number | undefined;
+            easing?: import("lenis").EasingFunction | undefined;
+            prevent?: ((node: HTMLElement) => boolean) | undefined;
+        };
+        targetScroll: number;
+        animatedScroll: number;
+        readonly dimensions: {
+            width: number;
+            height: number;
+            scrollHeight: number;
+            scrollWidth: number;
+            destroy: () => void;
+            resize: () => void;
+            onWrapperResize: () => void;
+            onContentResize: () => void;
+            readonly limit: {
+                x: number;
+                y: number;
+            };
+        };
+        destroy: () => void;
+        on: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): () => void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): () => void;
+        };
+        off: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): void;
+        };
+        resize: () => void;
+        start: () => void;
+        stop: () => void;
+        raf: (time: number) => void;
+        scrollTo: (target: number | string | HTMLElement, { offset, immediate, lock, duration, easing, lerp, onStart, onComplete, force, programmatic, userData, }?: import("lenis").ScrollToOptions) => void;
+        readonly rootElement: HTMLElement;
+        readonly limit: number;
+        readonly isHorizontal: boolean;
+        readonly actualScroll: number;
+        readonly scroll: number;
+        readonly progress: number;
+        isScrolling: import("lenis").Scrolling;
+        isStopped: boolean;
+        isLocked: boolean;
+        readonly isSmooth: boolean;
+        readonly className: string;
+    } | null>;
+    destroy: () => void;
+    createInstance?: undefined;
+} | {
+    lenis: Ref<{
+        isTouching?: boolean | undefined;
+        time: number;
+        userData: import("lenis").UserData;
+        lastVelocity: number;
+        velocity: number;
+        direction: 1 | -1 | 0;
+        options: {
+            wrapper: Window | HTMLElement | Element;
+            content: HTMLElement | Element;
+            eventsTarget: Window | HTMLElement | Element;
+            smoothWheel: boolean;
+            syncTouch: boolean;
+            syncTouchLerp: number;
+            touchInertiaExponent: number;
+            lerp: number;
+            infinite: boolean;
+            orientation: import("lenis").Orientation;
+            gestureOrientation: import("lenis").GestureOrientation;
+            touchMultiplier: number;
+            wheelMultiplier: number;
+            autoResize: boolean;
+            overscroll: boolean;
+            autoRaf: boolean;
+            anchors: boolean | {
+                offset?: number | undefined;
+                immediate?: boolean | undefined;
+                lock?: boolean | undefined;
+                duration?: number | undefined;
+                easing?: import("lenis").EasingFunction | undefined;
+                lerp?: number | undefined;
+                onStart?: ((lenis: Lenis) => void) | undefined;
+                onComplete?: ((lenis: Lenis) => void) | undefined;
+                force?: boolean | undefined;
+                programmatic?: boolean | undefined;
+                userData?: import("lenis").UserData | undefined;
+            };
+            autoToggle: boolean;
+            allowNestedScroll: boolean;
+            __experimental__naiveDimensions: boolean;
+            virtualScroll?: ((data: import("lenis").VirtualScrollData) => boolean) | undefined;
+            duration?: number | undefined;
+            easing?: import("lenis").EasingFunction | undefined;
+            prevent?: ((node: HTMLElement) => boolean) | undefined;
+        };
+        targetScroll: number;
+        animatedScroll: number;
+        readonly dimensions: {
+            width: number;
+            height: number;
+            scrollHeight: number;
+            scrollWidth: number;
+            destroy: () => void;
+            resize: () => void;
+            onWrapperResize: () => void;
+            onContentResize: () => void;
+            readonly limit: {
+                x: number;
+                y: number;
+            };
+        };
+        destroy: () => void;
+        on: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): () => void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): () => void;
+        };
+        off: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): void;
+        };
+        resize: () => void;
+        start: () => void;
+        stop: () => void;
+        raf: (time: number) => void;
+        scrollTo: (target: number | string | HTMLElement, { offset, immediate, lock, duration, easing, lerp, onStart, onComplete, force, programmatic, userData, }?: import("lenis").ScrollToOptions) => void;
+        readonly rootElement: HTMLElement;
+        readonly limit: number;
+        readonly isHorizontal: boolean;
+        readonly actualScroll: number;
+        readonly scroll: number;
+        readonly progress: number;
+        isScrolling: import("lenis").Scrolling;
+        isStopped: boolean;
+        isLocked: boolean;
+        readonly isSmooth: boolean;
+        readonly className: string;
+    } | null, Lenis | {
+        isTouching?: boolean | undefined;
+        time: number;
+        userData: import("lenis").UserData;
+        lastVelocity: number;
+        velocity: number;
+        direction: 1 | -1 | 0;
+        options: {
+            wrapper: Window | HTMLElement | Element;
+            content: HTMLElement | Element;
+            eventsTarget: Window | HTMLElement | Element;
+            smoothWheel: boolean;
+            syncTouch: boolean;
+            syncTouchLerp: number;
+            touchInertiaExponent: number;
+            lerp: number;
+            infinite: boolean;
+            orientation: import("lenis").Orientation;
+            gestureOrientation: import("lenis").GestureOrientation;
+            touchMultiplier: number;
+            wheelMultiplier: number;
+            autoResize: boolean;
+            overscroll: boolean;
+            autoRaf: boolean;
+            anchors: boolean | {
+                offset?: number | undefined;
+                immediate?: boolean | undefined;
+                lock?: boolean | undefined;
+                duration?: number | undefined;
+                easing?: import("lenis").EasingFunction | undefined;
+                lerp?: number | undefined;
+                onStart?: ((lenis: Lenis) => void) | undefined;
+                onComplete?: ((lenis: Lenis) => void) | undefined;
+                force?: boolean | undefined;
+                programmatic?: boolean | undefined;
+                userData?: import("lenis").UserData | undefined;
+            };
+            autoToggle: boolean;
+            allowNestedScroll: boolean;
+            __experimental__naiveDimensions: boolean;
+            virtualScroll?: ((data: import("lenis").VirtualScrollData) => boolean) | undefined;
+            duration?: number | undefined;
+            easing?: import("lenis").EasingFunction | undefined;
+            prevent?: ((node: HTMLElement) => boolean) | undefined;
+        };
+        targetScroll: number;
+        animatedScroll: number;
+        readonly dimensions: {
+            width: number;
+            height: number;
+            scrollHeight: number;
+            scrollWidth: number;
+            destroy: () => void;
+            resize: () => void;
+            onWrapperResize: () => void;
+            onContentResize: () => void;
+            readonly limit: {
+                x: number;
+                y: number;
+            };
+        };
+        destroy: () => void;
+        on: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): () => void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): () => void;
+        };
+        off: {
+            (event: "scroll", callback: import("lenis").ScrollCallback): void;
+            (event: "virtual-scroll", callback: import("lenis").VirtualScrollCallback): void;
+        };
+        resize: () => void;
+        start: () => void;
+        stop: () => void;
+        raf: (time: number) => void;
+        scrollTo: (target: number | string | HTMLElement, { offset, immediate, lock, duration, easing, lerp, onStart, onComplete, force, programmatic, userData, }?: import("lenis").ScrollToOptions) => void;
+        readonly rootElement: HTMLElement;
+        readonly limit: number;
+        readonly isHorizontal: boolean;
+        readonly actualScroll: number;
+        readonly scroll: number;
+        readonly progress: number;
+        isScrolling: import("lenis").Scrolling;
+        isStopped: boolean;
+        isLocked: boolean;
+        readonly isSmooth: boolean;
+        readonly className: string;
+    } | null>;
+    createInstance: (customOptions?: LenisOptions) => Lenis | null;
+    destroy: () => void;
+};
+export {};

package/dist/runtime/composables/useLenis.js

@@ -0,0 +1,101 @@
+import Lenis from "lenis";
+import { ScrollTrigger } from "gsap/ScrollTrigger";
+import { computed, onMounted, onUnmounted, isRef, ref } from "vue";
+import { useClientOnly, useGSAP, watch } from "#imports";
+const globalLenis = ref(null);
+const globalDestroy = () => {
+  if (globalLenis.value) {
+    globalLenis.value.destroy();
+    globalLenis.value = null;
+  }
+};
+export const useLenis = (wrapperOrOptions) => {
+  const { isClient } = useClientOnly();
+  const gsap = useGSAP();
+  if (!wrapperOrOptions) {
+    return {
+      lenis: globalLenis,
+      destroy: globalDestroy
+    };
+  }
+  const lenis = ref(null);
+  const options = computed(() => {
+    if (!isClient.value) return {};
+    if (typeof wrapperOrOptions === "string" || wrapperOrOptions instanceof HTMLElement) {
+      return { wrapper: wrapperOrOptions };
+    }
+    if (isRef(wrapperOrOptions)) {
+      return { wrapper: wrapperOrOptions.value };
+    }
+    return wrapperOrOptions || {};
+  });
+  const initLenis = (customOptions = {}) => {
+    if (!isClient.value) return null;
+    const currentOptions = options.value;
+    if (currentOptions.wrapper === void 0) {
+      return null;
+    }
+    const lenisOptions = {
+      wrapper: window,
+      // Default to window/body instead of #scroller
+      ...currentOptions,
+      ...customOptions
+    };
+    let wrapper = lenisOptions.wrapper;
+    if (typeof wrapper === "string") {
+      wrapper = document.querySelector(wrapper) || window;
+    }
+    const lenisInstance = new Lenis({
+      ...lenisOptions,
+      wrapper
+    });
+    lenisInstance.on("scroll", ScrollTrigger.update);
+    gsap.ticker.add((time) => {
+      lenisInstance.raf(time * 1e3);
+    });
+    gsap.ticker.lagSmoothing(0);
+    return lenisInstance;
+  };
+  const createInstance = (customOptions = {}) => {
+    const instance = initLenis(customOptions);
+    if (!lenis.value) {
+      lenis.value = instance;
+    }
+    return instance;
+  };
+  const destroy = () => {
+    if (lenis.value) {
+      lenis.value.destroy();
+      lenis.value = null;
+    }
+  };
+  watch(
+    () => options.value.wrapper,
+    (newWrapper) => {
+      if (newWrapper && !lenis.value) {
+        lenis.value = initLenis();
+        if (newWrapper === "#scroller" || typeof newWrapper === "object" && newWrapper?.id === "scroller") {
+          globalLenis.value = lenis.value;
+        }
+      }
+    },
+    { immediate: true }
+  );
+  onMounted(() => {
+    if (!lenis.value) {
+      lenis.value = initLenis();
+      const currentWrapper = options.value.wrapper;
+      if (currentWrapper === "#scroller" || typeof currentWrapper === "object" && currentWrapper?.id === "scroller") {
+        globalLenis.value = lenis.value;
+      }
+    }
+  });
+  onUnmounted(() => {
+    destroy();
+  });
+  return {
+    lenis,
+    createInstance,
+    destroy
+  };
+};

package/dist/runtime/composables/useSanityPage.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncDataRequestStatus } from "#app";
+import type { KeysOf, PickFrom } from "#app/composables/asyncData";
+import type { SanityPage } from "@gluhar/sanity/types";
+interface Page extends SanityPage {
+    _type: "page";
+}
+type PageTypeKeys = "page" | string;
+type PageInterfaces = Record<PageTypeKeys, Page | SanityPage>;
+type PageTypes<PI extends PageInterfaces> = Record<keyof PI, {
+    query: string;
+    slug: string;
+    type?: string;
+}>;
+export declare const useSanityPage: <PI extends PageInterfaces = {
+    page: Page;
+}, PT extends PageTypes<PI> = PageTypes<PI>>(types?: PT, slug?: string | string[]) => Promise<{
+    page: import("vue").Ref<PickFrom<PI[Extract<keyof PT, string>], KeysOf<PI[Extract<keyof PT, string>]>> | null, PickFrom<PI[Extract<keyof PT, string>], KeysOf<PI[Extract<keyof PT, string>]>> | null>;
+    status: import("vue").Ref<AsyncDataRequestStatus, AsyncDataRequestStatus>;
+} | {
+    page: import("vue").Ref<Page | null, Page | null>;
+    status: import("vue").Ref<AsyncDataRequestStatus, AsyncDataRequestStatus>;
+}>;
+export {};

package/dist/runtime/composables/useSanityPage.js

@@ -0,0 +1,60 @@
+import {
+  getCanonicalUrl,
+  groq,
+  useHead,
+  useRoute,
+  useSanityQueryWithPreview
+} from "#imports";
+import { imageWithAsset, linkWithPage } from "@gluhar/sanity/query";
+export const useSanityPage = async (types, slug) => {
+  const route = useRoute();
+  const s = slug ? slug : route.params.slug;
+  const sl = Array.isArray(s) ? s : [s];
+  if (types && sl.length > 1) {
+    for (const type in types) {
+      const options = types[type];
+      if (sl[0] === options.slug) {
+        const query2 = groq`
+            *[_type == "${type}" && slug.current == "${sl[1]}"]{
+              ${options.query}
+            }[0]
+          `;
+        const { data: page2, status: status2 } = await useSanityQueryWithPreview(query2);
+        useHead({
+          link: [
+            {
+              rel: "canonical",
+              href: getCanonicalUrl(page2?.value)
+            }
+          ]
+        });
+        return { page: page2, status: status2 };
+      }
+    }
+  }
+  const pageQuery = groq`
+        ...,
+        content[]{
+          ...,
+          _ref != null => @-> {
+            ...,
+            button{ ${linkWithPage} },
+            thumbnail{ ${imageWithAsset} },
+            image{ ${imageWithAsset} },
+            images[]{ ${imageWithAsset} },
+            bckg{ ${imageWithAsset} },
+          }
+        }
+      `;
+  const query = groq`
+        *[_type == "page" && slug.current == "${sl[0] ? sl?.join("/") : "/"}"]{
+          ${types?.page?.query ?? pageQuery}
+        }[0]
+      `;
+  const { data: page, status } = await useSanityQueryWithPreview(query);
+  if (page.value) page.value._type = "page";
+  useHead({
+    link: [{ rel: "canonical", href: getCanonicalUrl(page.value) }]
+  });
+  return { page, status };
+};

package/dist/runtime/composables/useSeo.d.ts

@@ -0,0 +1,2 @@
+import type { Seo } from "@gluhar/sanity/types";
+export declare const useSeo: (seo?: Seo) => void;

package/dist/runtime/composables/useSeo.js

@@ -0,0 +1,34 @@
+import { useGStore } from "../stores/useGStore.js";
+import { useMessages } from "#imports";
+import {
+  useSeoMeta,
+  useServerSeoMeta
+} from "@unhead/vue";
+export const useSeo = (seo) => {
+  const store = useGStore();
+  const { l } = useMessages();
+  const meta = {
+    title: l(store.defaultSeo?.title),
+    ogTitle: l(store.defaultSeo?.title),
+    description: l(store.defaultSeo?.description),
+    ogDescription: l(store.defaultSeo?.description),
+    ogImage: store.defaultSeo?.ogImage?.asset?.url,
+    twitterCard: "summary_large_image"
+  };
+  if (seo) {
+    const { title, description, ogImage } = seo;
+    if (title && l(title)) {
+      meta.title = l(title);
+      meta.ogTitle = l(title);
+    }
+    if (description && l(description)) {
+      meta.description = l(description);
+      meta.ogDescription = l(description);
+    }
+    if (ogImage && ogImage.asset?.url) {
+      meta.ogImage = ogImage.asset?.url;
+    }
+  }
+  useServerSeoMeta(meta);
+  useSeoMeta(meta);
+};

package/dist/runtime/stores/useGStore.d.ts

@@ -0,0 +1,80 @@
+import type { Seo } from "@gluhar/sanity/types";
+export declare const useGStore: import("pinia").StoreDefinition<"gluhar", Pick<{
+    defaultSeo: import("vue").Ref<{
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }, Seo | {
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }>;
+    setDefaultSeo: (seo: Seo) => void;
+    mobileMenuActive: import("vue").Ref<boolean, boolean>;
+    toggleMobileMenu: () => void;
+    closeMobileMenu: () => void;
+}, "defaultSeo" | "mobileMenuActive">, Pick<{
+    defaultSeo: import("vue").Ref<{
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }, Seo | {
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }>;
+    setDefaultSeo: (seo: Seo) => void;
+    mobileMenuActive: import("vue").Ref<boolean, boolean>;
+    toggleMobileMenu: () => void;
+    closeMobileMenu: () => void;
+}, never>, Pick<{
+    defaultSeo: import("vue").Ref<{
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }, Seo | {
+        title?: import("@gluhar/i18n/types").LocaleString | undefined;
+        description?: import("@gluhar/i18n/types").LocaleString | undefined;
+        ogImage?: {
+            asset?: {
+                url: string;
+            } | undefined;
+            caption?: import("@gluhar/i18n/types").LocaleString | undefined;
+            alt?: import("@gluhar/i18n/types").LocaleString | undefined;
+        } | undefined;
+    }>;
+    setDefaultSeo: (seo: Seo) => void;
+    mobileMenuActive: import("vue").Ref<boolean, boolean>;
+    toggleMobileMenu: () => void;
+    closeMobileMenu: () => void;
+}, "setDefaultSeo" | "toggleMobileMenu" | "closeMobileMenu">>;

package/dist/runtime/stores/useGStore.js

@@ -0,0 +1,21 @@
+import { defineStore, ref } from "#imports";
+export const useGStore = defineStore("gluhar", () => {
+  const defaultSeo = ref({});
+  const setDefaultSeo = (seo) => {
+    defaultSeo.value = seo;
+  };
+  const mobileMenuActive = ref(false);
+  const toggleMobileMenu = () => {
+    mobileMenuActive.value = !mobileMenuActive.value;
+  };
+  const closeMobileMenu = () => {
+    mobileMenuActive.value = false;
+  };
+  return {
+    defaultSeo,
+    setDefaultSeo,
+    mobileMenuActive,
+    toggleMobileMenu,
+    closeMobileMenu
+  };
+});

package/dist/runtime/types/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/utils/seo.d.ts

@@ -0,0 +1,3 @@
+import type { SanityPage } from "@gluhar/sanity/types";
+export declare const getCanonicalUrl: (page: SanityPage | null) => string;
+export declare const defaultSeoQuery = "\n  *[_id == \"defaultSeo\"]{\n    ...,\n    ogImage{\n      ...,\n      asset->\n    }\n  }[0]\n";

package/dist/runtime/utils/seo.js

@@ -0,0 +1,22 @@
+import { useRuntimeConfig } from "#imports";
+import { envMode } from "@gluhar/core/utils/common";
+export const getCanonicalUrl = (page) => {
+  const prod = envMode() === "prod";
+  const config = useRuntimeConfig().public;
+  const websiteUrl = (prod ? config.baseUrl?.toString() : config.devUrl?.toString()) || "http://localhost:3000";
+  if (!page?.slug) return websiteUrl;
+  const { _type } = page;
+  const slug = page.slug.current;
+  const path = _type === "page" ? slug : `${_type}s/${slug}`;
+  const url = new URL(path, websiteUrl);
+  return url.toString();
+};
+export const defaultSeoQuery = `
+  *[_id == "defaultSeo"]{
+    ...,
+    ogImage{
+      ...,
+      asset->
+    }
+  }[0]
+`;

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type GluharAppOptions, default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type GluharAppOptions, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gluhar/app",
-  "version": "5.1.5",
+  "version": "5.2.0",
   "description": "Gluhar main package. This combines and configures @gluhar/theme, @gluhar/i18n, @gluhar/sanity and @gluhar/core into one main package. Provides numerous components, composables, utils and types.",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,6 @@
   "scripts": {
     "gluhar": "npm run gluhar --prefix ../.. -- --cwd=$PWD",
     "build": "npm run gluhar build -- -t module",
-    "prepack": "npm run build",
     "dev": "nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
@@ -37,10 +36,10 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@gluhar/core": "^4.1.5",
-    "@gluhar/i18n": "^4.1.5",
-    "@gluhar/sanity": "^5.1.5",
-    "@gluhar/theme": "^4.0.4",
+    "@gluhar/core": "^4.2.0",
+    "@gluhar/i18n": "^4.2.0",
+    "@gluhar/sanity": "^5.2.0",
+    "@gluhar/theme": "^4.1.0",
     "@gluhar/v-gsap-nuxt": "^1.5.1",
     "@nuxt/image": "^1.10.0",
     "@nuxt/kit": "^3.13.1",
@@ -64,5 +63,5 @@
     "nuxt": "^3.13.1",
     "vitest": "^2.0.5"
   },
-  "gitHead": "a60bf29f338bc3af3212a3a8ed647f75c69a2c4a"
+  "gitHead": "10ebf6500c71e1beeceece4de90467b26aa67a21"
 }