@devite/nuxt-sanity 1.5.2 → 2.0.0

package/dist/runtime/components/SanityPage.vue

@@ -1,5 +1,5 @@
 <template>
-  <main v-if="sanityData?.modules?.length > 0">
+  <main v-if="sanityData?.modules?.length">
     <SanityComponent
       v-for="module in sanityData.modules"
       :key="module._key"
@@ -9,24 +9,35 @@
 </template>
 
 <script setup lang="ts">
-import { useSanityQuery } from '@nuxtjs/sanity/runtime/composables/visual-editing'
-import { groq } from '@nuxtjs/sanity/runtime/groq'
-import type { ComputedRef } from 'vue'
+import { computed, type ComputedRef } from 'vue'
 import type { ImageAsset } from '@sanity/types'
-import type { Home, Page, NotFound, GlobalSEO } from '@devite/nuxt-sanity'
+import type { GlobalSEO, Home, NotFound, Page } from '@devite/nuxt-sanity'
 import { IMAGE_WITHOUT_PREVIEW_PROJECTION } from '../utils/projections'
-import { useHead, useRoute, useRuntimeConfig, useSeoMeta, computed } from '#imports'
+import { useSanityQuery } from '../composables/useSanityQuery'
+import { groq } from '../utils/groq'
+import { useHead, useRoute, useRuntimeConfig, useSeoMeta } from '#imports'
 
 const path = useRoute().fullPath
 const groqFilter = path === '/' ? '_type == "home"' : `_type == "page" && slug.current == $slug`
-const { data: sanityData } = await useSanityQuery<Home | Page | NotFound>(groq`*[(${groqFilter}) || _type == "notFound"][0] { _id, _type, title, modules, seo { _type, indexable, title, shortTitle, description, image ${IMAGE_WITHOUT_PREVIEW_PROJECTION} } }`, { slug: path.substring(1) })
+const { data: sanityData } = await useSanityQuery<Home | Page | NotFound>(
+  groq`*[(${groqFilter}) || _type == "notFound"][0] { _id, _type, title, modules, seo { _type, indexable, title, shortTitle, description, image ${IMAGE_WITHOUT_PREVIEW_PROJECTION} } }`,
+  { slug: path.substring(1) },
+)
 
 const { baseURL } = useRuntimeConfig().public
 const seo = computed(() => sanityData.value?.seo)
-const url = computed(() => baseURL + (sanityData.value?.slug || '/'))
+const url = computed(
+  () =>
+    ((baseURL as string) || '')
+    + ((sanityData.value && ('slug' in sanityData.value ? sanityData.value.slug.current : null)) || '/'),
+)
 
-const { data: globalSEO } = await useSanityQuery<GlobalSEO>(groq`*[_type == 'settings'][0].seo { siteName, image ${IMAGE_WITHOUT_PREVIEW_PROJECTION} }`)
-const image: ComputedRef<ImageAsset> = computed(() => sanityData.value?.image?.asset || globalSEO.value?.image?.asset)
+const { data: globalSEO } = await useSanityQuery<GlobalSEO>(
+  groq`*[_type == 'settings'][0].seo { siteName, image ${IMAGE_WITHOUT_PREVIEW_PROJECTION} }`,
+)
+const image: ComputedRef<ImageAsset | undefined> = computed(
+  () => sanityData.value?.seo.image?.asset || globalSEO.value?.image?.asset,
+)
 const imageUrl = computed(() => image.value?.url)
 const imageDimensions = computed(() => image.value?.metadata.dimensions)
 
@@ -42,14 +53,12 @@ useHead({
     { name: 'og:url', content: () => url.value },
     { name: 'twitter:url', content: () => url.value },
   ],
-  link: [
-    { rel: 'canonical', href: () => url.value },
-  ],
+  link: [{ rel: 'canonical', href: () => url.value }],
 })
 
 useSeoMeta({
   robots: () => `${seo.value?.indexable ? '' : 'no'}index,follow`,
-  title: () => seo.value?.title,
+  title: () => seo.value?.title || '',
   description: () => seo.value?.description,
   ogTitle: () => seo.value?.shortTitle,
   ogDescription: () => seo.value?.description,

package/dist/runtime/components/SanityRichText.vue

@@ -7,33 +7,27 @@
 
 <script setup lang="ts">
 import { PortableText, type PortableTextComponents } from '@portabletext/vue'
+import type { PortableTextChild, PortableTextSpan } from '@sanity/types'
 import type { RichText } from '@devite/nuxt-sanity'
-import { computed, h } from '#imports'
+import { computed, h } from 'vue'
 import { SanityLinkExternal, SanityLinkInternal } from '#components'
 
-const { data, placeholders = {} as object } = defineProps<{ data: RichText, placeholders?: object }>()
+const props = defineProps<{ data: RichText, placeholders?: Record<string, string> }>()
 const currentData = computed(() => {
-  return data.map((block) => {
+  return props.data.map((block) => {
     return {
       ...block,
-      children: replaceChildren(block.children),
+      children: replaceChildren(block.children as PortableTextChild[]),
     }
   })
 })
 
-function replaceChildren(children: object[]) {
+function replaceChildren(children: PortableTextChild[]): PortableTextChild[] {
   return children.map((child) => {
     if (child._type === 'span') {
       return {
         ...child,
-        text: replacePlaceholders(child.text),
-      }
-    }
-
-    if (child.children) {
-      return {
-        ...child,
-        children: replaceChildren(child.children),
+        text: replacePlaceholders((child as PortableTextSpan).text),
       }
     }
 
@@ -42,15 +36,17 @@ function replaceChildren(children: object[]) {
 }
 
 function replacePlaceholders(text: string) {
-  return text.replace(/\{\{(.*?)\}\}/g, (match, key) => placeholders[key] || match)
+  return text.replace(/\{\{(.*?)}}/g, (match, key) => {
+    if (!props.placeholders || !Object.prototype.hasOwnProperty.call(props.placeholders, key)) return match
+
+    return props.placeholders[key]
+  })
 }
 
 const richTextSerializer: PortableTextComponents = {
   marks: {
-    linkExternal: ({ value }, { slots }) =>
-      h(SanityLinkExternal, { data: value }, slots.default),
-    linkInternal: ({ value }, { slots }) =>
-      h(SanityLinkInternal, { data: value }, slots.default),
+    linkExternal: ({ value }, { slots }) => h(SanityLinkExternal, { data: value }, slots.default),
+    linkInternal: ({ value }, { slots }) => h(SanityLinkInternal, { data: value }, slots.default),
   },
 }
 </script>

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

@@ -0,0 +1,4 @@
+import type { AsyncDataOptions } from 'nuxt/app';
+import type { QueryParams } from '@sanity/client';
+import { type AsyncSanityData, type SanityQueryResponse } from './useSanityQuery.js';
+export declare const useLazySanityQuery: <T = unknown, E = Error>(query: string, _params?: QueryParams, options?: AsyncDataOptions<SanityQueryResponse<T | null>>) => AsyncSanityData<T | null, E>;

package/dist/runtime/composables/useLazySanityQuery.js

@@ -0,0 +1,4 @@
+import { useSanityQuery } from "./useSanityQuery.js";
+export const useLazySanityQuery = (query, _params = {}, options = {}) => {
+  return useSanityQuery(query, _params, options, true);
+};

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

@@ -0,0 +1 @@
+export declare const useSanityLiveMode: () => () => void;

package/dist/runtime/composables/useSanityLiveMode.js

@@ -0,0 +1,16 @@
+import { onScopeDispose } from "vue";
+import useSanityClient from "../utils/useSanityClient.js";
+export const useSanityLiveMode = () => {
+  let disable = () => {
+  };
+  if (import.meta.client) {
+    const client = useSanityClient("default");
+    if (client.queryStore) {
+      disable = client.queryStore.enableLiveMode({
+        client: client.client
+      });
+    }
+  }
+  onScopeDispose(disable);
+  return disable;
+};

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

@@ -0,0 +1,30 @@
+import type { ContentSourceMap, QueryParams } from '@sanity/client';
+import type { EncodeDataAttributeFunction } from '@sanity/core-loader/encode-data-attribute';
+import type { AsyncDataOptions, AsyncDataRequestStatus } from 'nuxt/app';
+import { type Ref } from 'vue';
+export interface SanityQueryResponse<T> {
+    data: T;
+    sourceMap?: ContentSourceMap;
+    encodeDataAttribute?: EncodeDataAttributeFunction;
+}
+interface AsyncDataExecuteOptions {
+    _initial?: boolean;
+    dedupe?: boolean;
+}
+export interface _AsyncSanityData<T, E> {
+    data: Ref<T>;
+    sourceMap: Ref<ContentSourceMap | null>;
+    encodeDataAttribute: Ref<EncodeDataAttributeFunction | (() => void)>;
+    pending: Ref<boolean>;
+    refresh: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    error: Ref<E | null>;
+    status: Ref<AsyncDataRequestStatus>;
+}
+export type AsyncSanityData<T, E> = _AsyncSanityData<T, E> & Promise<_AsyncSanityData<T, E>>;
+export interface UseSanityQueryOptions<T> extends AsyncDataOptions<T> {
+    client?: 'default' | 'minimal';
+    perspective?: 'previewDrafts' | 'published' | 'raw';
+}
+export declare const useSanityQuery: <T = unknown, E = Error>(query: string, _params?: QueryParams, _options?: UseSanityQueryOptions<SanityQueryResponse<T | null>>, lazy?: boolean) => AsyncSanityData<T | null, E>;
+export {};

package/dist/runtime/composables/useSanityQuery.js

@@ -0,0 +1,69 @@
+import { hash } from "ohash";
+import { defineEncodeDataAttribute } from "@sanity/core-loader/encode-data-attribute";
+import { onScopeDispose, reactive, ref } from "vue";
+import useSanityClient from "../utils/useSanityClient.js";
+import { useAsyncData, useLazyAsyncData } from "#imports";
+export const useSanityQuery = (query, _params = {}, _options = {}, lazy = false) => {
+  const { client: clientType, perspective: _perspective, ...options } = _options;
+  const client = clientType ? useSanityClient(clientType) : useSanityClient();
+  const hasQueryStore = "queryStore" in client && client.queryStore !== null;
+  const perspective = _perspective || (hasQueryStore ? "previewDrafts" : "published");
+  const key = "sanity-" + hash(query + (_params ? JSON.stringify(_params) : ""));
+  const reactiveParams = _params ? reactive(_params) : void 0;
+  if (reactiveParams) {
+    options.watch ||= [];
+    options.watch.push(reactiveParams);
+  }
+  const data = ref(null);
+  const sourceMap = ref(null);
+  const encodeDataAttribute = ref(() => {
+  });
+  function updateResult(newData, newSourceMap) {
+    data.value = newData;
+    sourceMap.value = newSourceMap || null;
+    if (client.config.visualEditing) {
+      encodeDataAttribute.value = defineEncodeDataAttribute(newData, newSourceMap, client.config.visualEditing?.studioUrl);
+    }
+  }
+  let fetchFunc = async () => {
+    return { data: await client.fetch(query, reactiveParams || {}, { perspective }) };
+  };
+  if (hasQueryStore) {
+    let setupFetcher = function(cb) {
+      unsubscribe();
+      const deepClonedParams = JSON.parse(JSON.stringify(_params));
+      const fetcher = defaultClient.queryStore.createFetcherStore(query, deepClonedParams, void 0);
+      unsubscribe = fetcher.subscribe((newSnapshot) => {
+        if (newSnapshot.data) {
+          updateResult(newSnapshot.data, newSnapshot.sourceMap);
+          cb?.(newSnapshot);
+        }
+      });
+    };
+    const defaultClient = client;
+    let unsubscribe = () => {
+    };
+    const proxyClient = {
+      fetch: (query2, params, options2) => $fetch(defaultClient.config.visualEditing.proxyEndpoint || "/_sanity/fetch", {
+        method: "POST",
+        body: { query: query2, params, options: options2 }
+      })
+    };
+    fetchFunc = async () => {
+      const currentClient = import.meta.server ? defaultClient.queryStore.unstable__serverClient.instance || defaultClient.client : proxyClient;
+      const { result: fetchData, resultSourceMap: sourceMap2 } = await currentClient.fetch(query, reactiveParams || {}, {
+        perspective,
+        filterResponse: false,
+        resultSourceMap: "withKeyArraySelector"
+      });
+      return sourceMap2 ? { data: fetchData, sourceMap: sourceMap2 } : { data: fetchData };
+    };
+    if (import.meta.client) setupFetcher();
+    onScopeDispose(unsubscribe);
+  }
+  const pendingData = lazy ? useLazyAsyncData(key, fetchFunc, options) : useAsyncData(key, fetchFunc, options);
+  return Object.assign(new Promise((resolve) => pendingData.then(({ data: { value } }) => {
+    updateResult(value.data, value.sourceMap);
+    resolve({ ...pendingData, data, sourceMap, encodeDataAttribute });
+  })), { ...pendingData, data, sourceMap, encodeDataAttribute });
+};

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

@@ -0,0 +1,8 @@
+import type { DisableVisualEditing, VisualEditingOptions } from '@sanity/visual-editing';
+import type { SanityVisualEditingRefreshHandler } from '@devite/nuxt-sanity';
+export interface VisualEditingProps {
+    refresh?: SanityVisualEditingRefreshHandler;
+    zIndex?: VisualEditingOptions['zIndex'];
+}
+/** @return A function to disable visual editing */
+export declare const useSanityVisualEditing: (options?: VisualEditingProps) => DisableVisualEditing;

package/dist/runtime/composables/useSanityVisualEditing.js

@@ -0,0 +1,44 @@
+import { enableVisualEditing } from "@sanity/visual-editing";
+import { onScopeDispose } from "vue";
+import { reloadNuxtApp, useRouter } from "#imports";
+export const useSanityVisualEditing = (options = {}) => {
+  const { refresh, zIndex } = options;
+  let disable = () => {
+  };
+  if (import.meta.client) {
+    const router = useRouter();
+    disable = enableVisualEditing({
+      zIndex,
+      refresh: (payload) => {
+        function refreshDefault() {
+          if (payload.source === "mutation" && payload.livePreviewEnabled)
+            return false;
+          return new Promise((resolve) => {
+            reloadNuxtApp({ ttl: 1e3 });
+            resolve();
+          });
+        }
+        return refresh ? refresh(payload, refreshDefault) : refreshDefault();
+      },
+      history: {
+        subscribe(navigate) {
+          router.isReady().then(() => navigate({ type: "replace", url: router.currentRoute.value.fullPath }));
+          return router.afterEach((to) => navigate({ type: "push", url: to.fullPath }));
+        },
+        update(update) {
+          switch (update.type) {
+            case "push":
+            case "replace":
+              router[update.type](update.url);
+              break;
+            case "pop":
+              router.back();
+              break;
+          }
+        }
+      }
+    });
+  }
+  onScopeDispose(disable);
+  return disable;
+};

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

@@ -0,0 +1,4 @@
+export declare const useSanityVisualEditingState: () => {
+    enabled: boolean;
+    isInFrame: () => boolean | undefined;
+};

package/dist/runtime/composables/useSanityVisualEditingState.js

@@ -0,0 +1,12 @@
+import { reactive } from "vue";
+import { useState } from "#imports";
+export const useSanityVisualEditingState = () => {
+  const enabled = useState("_sanity_visualEditing", () => false);
+  return reactive({
+    enabled,
+    isInFrame() {
+      if (import.meta.server) return void 0;
+      return !!(window.self !== window.top || window.opener);
+    }
+  });
+};

package/dist/runtime/plugins/visual-editing.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/visual-editing.js

@@ -0,0 +1,30 @@
+import { useSanityVisualEditingState } from "../composables/useSanityVisualEditingState.js";
+import { useSanityLiveMode } from "../composables/useSanityLiveMode.js";
+import { useSanityVisualEditing } from "../composables/useSanityVisualEditing.js";
+import {
+  defineNuxtPlugin,
+  useCookie,
+  useRuntimeConfig
+} from "#imports";
+export default defineNuxtPlugin(() => {
+  const visualEditingState = useSanityVisualEditingState();
+  const $config = useRuntimeConfig();
+  const { visualEditing } = $config.public.sanity;
+  if (import.meta.server) {
+    if (visualEditing?.previewMode) {
+      const previewModeCookie = useCookie("__sanity_preview");
+      visualEditingState.enabled = visualEditing.previewModeId === previewModeCookie.value;
+    }
+  } else if (visualEditingState.enabled && visualEditing.mode !== "custom") {
+    switch (visualEditing?.mode) {
+      case "live-visual-editing":
+      case "visual-editing":
+        useSanityVisualEditing({
+          refresh: visualEditing?.refresh,
+          zIndex: visualEditing?.zIndex
+        });
+        if (visualEditing?.mode === "live-visual-editing") useSanityLiveMode();
+        break;
+    }
+  }
+});

package/dist/runtime/server/routes/preview/disable.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/routes/preview/disable.js

@@ -0,0 +1,6 @@
+import { defineEventHandler, deleteCookie, getQuery, sendRedirect } from "h3";
+export default defineEventHandler(async (event) => {
+  const { redirect } = getQuery(event);
+  deleteCookie(event, "__sanity_preview");
+  await sendRedirect(event, redirect?.toString() || "/");
+});

package/dist/runtime/server/routes/preview/enable.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("h3").H3Error<unknown> | undefined>>;
+export default _default;

package/dist/runtime/server/routes/preview/enable.js

@@ -0,0 +1,20 @@
+import { validatePreviewUrl } from "@sanity/preview-url-secret";
+import { createError, defineEventHandler, getRequestURL, sendRedirect, setCookie } from "h3";
+import useSanityClient from "../../utils/useSanityClient.js";
+export default defineEventHandler(async (event) => {
+  const client = useSanityClient("default");
+  const { isValid, redirectTo = "/" } = await validatePreviewUrl(client.client, getRequestURL(event).toString());
+  if (!isValid) {
+    return createError({
+      statusCode: 403,
+      statusMessage: "Invalid secret"
+    });
+  }
+  setCookie(event, "__sanity_preview", client.config.visualEditing.previewModeId || "", {
+    httpOnly: true,
+    sameSite: !import.meta.dev ? "none" : "lax",
+    secure: !import.meta.dev,
+    path: "/"
+  });
+  await sendRedirect(event, redirectTo, 307);
+});

package/dist/runtime/server/routes/proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+export default _default;

package/dist/runtime/server/routes/proxy.js

@@ -0,0 +1,19 @@
+import { createError, defineEventHandler, getCookie, readBody } from "h3";
+import useSanityClient from "../utils/useSanityClient.js";
+export default defineEventHandler(async (event) => {
+  const previewModeCookie = getCookie(event, "__sanity_preview");
+  if (!previewModeCookie) {
+    return createError({
+      statusCode: 403,
+      statusMessage: "This route is only available in preview mode"
+    });
+  }
+  const { query, params = {} } = await readBody(event);
+  if (!query) {
+    return createError({
+      statusCode: 400,
+      statusMessage: `Field "query" is required`
+    });
+  }
+  return await useSanityClient("default").fetch(query, params);
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/utils/useSanityClient.d.ts

@@ -0,0 +1,3 @@
+import type SanityClient from '../../client/SanityClient.js';
+import type { SanityClientType } from '../../utils/getOrCreateSanityClient.js';
+export default function useSanityClient(type?: SanityClientType): SanityClient;

package/dist/runtime/server/utils/useSanityClient.js

@@ -0,0 +1,17 @@
+import defu from "defu";
+import getOrCreateSanityClient from "../../utils/getOrCreateSanityClient.js";
+import { useRuntimeConfig } from "#imports";
+export default function useSanityClient(type) {
+  const $config = useRuntimeConfig();
+  const sanityConfig = defu($config.sanity, $config.public.sanity || {});
+  const visualEditingEnabled = sanityConfig.visualEditing && sanityConfig.visualEditing.previewMode !== false;
+  return getOrCreateSanityClient(
+    visualEditingEnabled || false,
+    visualEditingEnabled ? {
+      ...sanityConfig,
+      token: sanityConfig.visualEditing?.token,
+      useCdn: false
+    } : sanityConfig,
+    type
+  );
+}

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

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from '@devite/nuxt-sanity';
+import type SanityClient from '~/src/runtime/client/SanityClient';
+export type SanityClientType = 'minimal' | 'default';
+export default function getOrCreateSanityClient(visualEditing: boolean, config: ModuleOptions, type?: SanityClientType): SanityClient;

package/dist/runtime/utils/getOrCreateSanityClient.js

@@ -0,0 +1,15 @@
+import MinimalSanityClient from "../client/MinimalSanityClient.js";
+import DefaultSanityClient from "../client/DefaultSanityClient.js";
+const clients = {};
+export default function getOrCreateSanityClient(visualEditing, config, type) {
+  const clientType = visualEditing ? "default" : type || (config.minimalClient ? "minimal" : "default");
+  if (clientType in clients) return clients[clientType];
+  const clientConfig = {
+    ...config,
+    stega: visualEditing && config.stega
+  };
+  const client = clientType === "minimal" ? new MinimalSanityClient(clientConfig) : new DefaultSanityClient(clientConfig);
+  if (visualEditing && import.meta.client) client.createQueryStore();
+  clients[clientType] = client;
+  return client;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * GROQ template string tag that allows for syntax highlighting and linting.
+ *
+ * Source: https://github.com/sanity-io/sanity/blob/next/packages/groq/src/groq.ts
+ */
+export declare const groq: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;

package/dist/runtime/utils/groq.js

@@ -0,0 +1,6 @@
+export const groq = String.raw || ((strings, ...keys) => {
+  const lastIndex = strings.length - 1;
+  return strings.slice(0, lastIndex).reduce((acc, str, index) => {
+    return acc + str + keys[index];
+  }, "") + strings[lastIndex];
+});

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

@@ -1,4 +1,4 @@
-export declare const IMAGE_ASSET_PROJECTION: any;
-export declare const IMAGE_WITHOUT_PREVIEW_PROJECTION: any;
-export declare const IMAGE_WITH_PREVIEW_PROJECTION: any;
-export declare const LINK_PROJECTION: any;
+export declare const IMAGE_ASSET_PROJECTION: string;
+export declare const IMAGE_WITHOUT_PREVIEW_PROJECTION: string;
+export declare const IMAGE_WITH_PREVIEW_PROJECTION: string;
+export declare const LINK_PROJECTION: string;

package/dist/runtime/utils/projections.js

@@ -1,4 +1,4 @@
-import { groq } from "@nuxtjs/sanity/runtime/groq";
+import { groq } from "./groq.js";
 export const IMAGE_ASSET_PROJECTION = groq`{
   _type,
   _id,

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

@@ -1,3 +1,3 @@
 import type { ImageAsset } from '@sanity/types';
-import type { Ref } from '#imports';
-export declare const resolveImageAssetById: (id: string) => Promise<Ref<ImageAsset | undefined>>;
+import type { Ref } from 'vue';
+export declare const resolveImageAssetById: (id: string) => Promise<Ref<ImageAsset | null>>;

package/dist/runtime/utils/resolveImageAssetById.js

@@ -1,5 +1,5 @@
-import { useSanityQuery } from "@nuxtjs/sanity/runtime/composables/visual-editing";
+import { useSanityQuery } from "../composables/useSanityQuery.js";
 import { IMAGE_ASSET_PROJECTION } from "./projections.js";
 export const resolveImageAssetById = async (id) => {
-  return (await useSanityQuery(`*[_type == "sanity.imageAsset" && _id == $assetId][0] ${IMAGE_ASSET_PROJECTION}`, { assetId: id })).data;
+  return useSanityQuery(`*[_type == "sanity.imageAsset" && _id == $assetId][0] ${IMAGE_ASSET_PROJECTION}`, { assetId: id }).data;
 };

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

@@ -1,4 +1,4 @@
 import type { Reference } from '@sanity/types';
 import type { LinkInternal } from '@devite/nuxt-sanity';
-import type { Ref } from '#imports';
-export declare const resolveInternalLink: (reference: Reference) => Promise<Ref<LinkInternal | undefined>>;
+import type { Ref } from 'vue';
+export declare const resolveInternalLink: (reference: Reference) => Promise<Ref<LinkInternal | null>>;

package/dist/runtime/utils/resolveInternalLink.js

@@ -1,4 +1,4 @@
-import { useSanityQuery } from "@nuxtjs/sanity/runtime/composables/visual-editing";
+import { useSanityQuery } from "../composables/useSanityQuery.js";
 export const resolveInternalLink = async (reference) => {
-  return (await useSanityQuery(`*[_id == $documentId][0] { '_type': 'linkInternal', 'slug': coalesce(slug.current, '/') }`, { documentId: reference._ref })).data;
+  return useSanityQuery(`*[_id == $documentId][0] { '_type': 'linkInternal', 'slug': coalesce(slug.current, '/') }`, { documentId: reference._ref }).data;
 };

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

@@ -0,0 +1,2 @@
+import type SanityClient from '../client/SanityClient.js';
+export default function useSanityClient(type?: 'minimal' | 'default'): SanityClient;

package/dist/runtime/utils/useSanityClient.js

@@ -0,0 +1,8 @@
+import { useSanityVisualEditingState } from "../composables/useSanityVisualEditingState.js";
+import getOrCreateSanityClient from "./getOrCreateSanityClient.js";
+import { useRuntimeConfig } from "#imports";
+export default function useSanityClient(type) {
+  const $config = useRuntimeConfig();
+  const sanityConfig = $config.public.sanity;
+  return getOrCreateSanityClient(useSanityVisualEditingState().enabled, sanityConfig, type);
+}

package/dist/types.d.mts

@@ -1,7 +1 @@
-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 GlobalSEO, type Home, type LinkExternal, type LinkInternal, type NotFound, type Page, type RichText, type SEO, default } from './module.js'
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module.js'

package/dist/types.d.ts

@@ -1,7 +1 @@
-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 GlobalSEO, type Home, type LinkExternal, type LinkInternal, type NotFound, type Page, type RichText, type SEO, default } from './module'
+export { type GlobalSEO, type Home, type LinkExternal, type LinkInternal, type ModuleOptions, type NotFound, type Page, type RichText, type SEO, type SanityArray, type SanityModule, type SanityVisualEditingRefreshHandler, type VisualEditingOptions, default } from './module'