@gluhar/app 5.0.10 → 5.1.5

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

@@ -1,370 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

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

package/dist/runtime/composables/useSeo.js

@@ -1,34 +0,0 @@
-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);
-};