@gscdump/nuxt 0.19.0

package/app/composables/useGscResource.ts

@@ -0,0 +1,114 @@
+// Site-keyed async resource composable. Owns key-watch, stale-token discard,
+// status classification, refresh, and dispose for every read-only `/api/__gsc/*`
+// fetcher in the layer. Resource composables (useGscSitemaps,
+// useGscIndexingDiagnostics, …) are thin adapters that wire reactive keys to
+// `useGscAnalyticsClient().getX(...)` plus optional derived computeds.
+//
+// Stale-token (not AbortController) because `@gscdump/sdk`'s AnalyticsClient
+// doesn't accept a signal. Late-arriving promises from a superseded run are
+// dropped on `data`/`status` writes; the in-flight fetch still runs to
+// completion, which is acceptable for read-only GETs.
+
+import type { ComputedRef, Ref, WatchSource } from 'vue'
+import type { GscErrorStatus } from '../utils/gsc-error'
+import { classifyGscError } from '../utils/gsc-error'
+
+export type GscResourceStatus = 'idle' | 'pending' | 'success' | 'empty' | GscErrorStatus
+
+export interface UseGscResourceOptions<TArgs extends readonly unknown[], TData> {
+  /** Reactive args passed to the fetcher. Resource stays idle while any required key is null/undefined. */
+  keys: { [I in keyof TArgs]: MaybeRefOrGetter<TArgs[I] | null | undefined> }
+  /** Async fetcher invoked with the resolved keys. */
+  fetcher: (...args: TArgs) => Promise<TData | null>
+  /** Predicate for the `empty` status — defaults to checking `null`/`[]`/typical container fields. */
+  isEmpty?: (data: TData) => boolean
+  /** Extra reactive sources that should retrigger a fetch. */
+  watchSources?: WatchSource[]
+}
+
+export interface UseGscResourceReturn<TData> {
+  data: Ref<TData | null>
+  status: Ref<GscResourceStatus>
+  loading: ComputedRef<boolean>
+  error: Ref<Error | null>
+  refresh: () => Promise<void>
+}
+
+function defaultIsEmpty(v: unknown): boolean {
+  if (v == null)
+    return true
+  if (Array.isArray(v))
+    return v.length === 0
+  if (typeof v === 'object') {
+    const rec = v as Record<string, unknown>
+    for (const key of ['rows', 'records', 'snapshots', 'items', 'results']) {
+      const arr = rec[key]
+      if (Array.isArray(arr))
+        return arr.length === 0
+    }
+  }
+  return false
+}
+
+export function useGscResource<TArgs extends readonly unknown[], TData>(
+  opts: UseGscResourceOptions<TArgs, TData>,
+): UseGscResourceReturn<TData> {
+  const data = shallowRef<TData | null>(null)
+  const status = ref<GscResourceStatus>('idle')
+  const error = ref<Error | null>(null)
+  const loading = computed(() => status.value === 'pending')
+
+  let runToken = 0
+
+  function resolveKeys(): TArgs | null {
+    const out: unknown[] = []
+    for (const k of opts.keys) {
+      const v = toValue(k)
+      if (v == null || v === '')
+        return null
+      out.push(v)
+    }
+    return out as unknown as TArgs
+  }
+
+  async function refresh(): Promise<void> {
+    const args = resolveKeys()
+    const token = ++runToken
+    if (!args) {
+      data.value = null
+      status.value = 'idle'
+      error.value = null
+      return
+    }
+    status.value = 'pending'
+    error.value = null
+    try {
+      const out = await opts.fetcher(...args)
+      if (token !== runToken)
+        return
+      data.value = out
+      const empty = out == null || (opts.isEmpty ?? defaultIsEmpty)(out)
+      status.value = empty ? 'empty' : 'success'
+    }
+    catch (e) {
+      if (token !== runToken)
+        return
+      const classified = classifyGscError(e)
+      error.value = e instanceof Error ? e : new Error(String(e))
+      status.value = classified.status
+      data.value = null
+    }
+  }
+
+  watch(
+    [...opts.keys.map(k => () => toValue(k)), ...(opts.watchSources ?? [])],
+    refresh,
+    { immediate: true },
+  )
+
+  onScopeDispose(() => {
+    runToken++
+  })
+
+  return { data, status, loading, error, refresh }
+}

package/app/composables/useGscRollup.ts

@@ -0,0 +1,252 @@
+// Rollup fetchers.
+//
+//   useGscRollup(site, id)             → { data, envelope, loading, refresh }
+//   useGscRollups(site, [id, ...])     → { get, payload, envelopes, loading, refresh }
+//   useGscRollupFanout(sites, id)      → { envelopes, loading, refresh }
+//
+// The single/multi-site overload on `useGscRollups` from the previous API was
+// split into three focused hooks so each has one return shape.
+//
+// Progress flows to the shared analytics map so <GscBootProgress> lights up.
+
+import type { RollupEnvelope } from '@gscdump/contracts'
+import type { SiteListItem } from './useGscAnalytics'
+import { useGscResource } from './_useGscResource'
+import { useGscAnalyticsContext } from './useGscAnalytics'
+import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+
+type RollupsInput = MaybeRefOrGetter<string | readonly string[]>
+type SiteLike = string | { id: string } | SiteListItem
+
+export interface UseGscRollupReturn<T> {
+  data: Ref<T | null>
+  envelope: Ref<RollupEnvelope<T> | null>
+  loading: Readonly<Ref<boolean>>
+  refresh: () => Promise<void>
+}
+
+export interface UseGscRollupsReturn<T> {
+  get: (rollupId: string) => RollupEnvelope<T> | null
+  payload: (rollupId: string) => T | null
+  envelopes: Ref<Record<string, RollupEnvelope<T> | null>>
+  loading: Readonly<Ref<boolean>>
+  refresh: () => Promise<void>
+}
+
+export interface UseGscRollupFanoutReturn<T> {
+  /** `{ [siteId]: envelope | null }` — null for sites missing the rollup. */
+  envelopes: Ref<Record<string, RollupEnvelope<T> | null>>
+  loading: Readonly<Ref<boolean>>
+  /**
+   * How many fan-out fetches have resolved so far (incl. nulls). Useful for
+   *  showing "loaded X/Y" hints in tiers where each site is a live API call.
+   */
+  progress: Readonly<Ref<{ completed: number, total: number }>>
+  refresh: () => Promise<void>
+}
+
+export interface UseGscRollupOptions {
+  /**
+   * Optional reactive `{ start, end }` ISO-date window. When provided, the
+   * endpoint is free to synthesize the rollup for that window (how it does
+   * so is host-specific). Rollups that are range-agnostic (e.g. the
+   * client-sliced `daily_totals`) safely ignore these params.
+   */
+  range?: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>
+}
+
+/** Fetch one rollup for one site. */
+export function useGscRollup<T = unknown>(
+  siteId: MaybeRefOrGetter<string | null | undefined>,
+  rollupId: MaybeRefOrGetter<string>,
+  opts: UseGscRollupOptions = {},
+): UseGscRollupReturn<T> {
+  const ctx = useGscAnalyticsContext()
+  const resource = useGscResource<[string, string], RollupEnvelope<T> | null>({
+    keys: [siteId, rollupId],
+    fetcher: (id, rid) => fetchOne<T>(id, rid, ctx, toValue(opts.range) ?? null),
+    watchSources: [() => toValue(opts.range)?.start, () => toValue(opts.range)?.end],
+    isEmpty: env => env == null,
+  })
+
+  return {
+    data: computed<T | null>(() => resource.data.value?.payload ?? null),
+    envelope: resource.data as unknown as Ref<RollupEnvelope<T> | null>,
+    loading: resource.loading as unknown as Readonly<Ref<boolean>>,
+    refresh: resource.refresh,
+  }
+}
+
+/** Fetch N rollups for one site. */
+export function useGscRollups<T = unknown>(
+  siteId: MaybeRefOrGetter<string | null | undefined>,
+  rollupIds: RollupsInput,
+  opts: UseGscRollupOptions = {},
+): UseGscRollupsReturn<T> {
+  const ctx = useGscAnalyticsContext()
+
+  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
+  const loading = ref(false)
+
+  async function refresh(): Promise<void> {
+    const sid = toValue(siteId)
+    const rids = normaliseRollups(toValue(rollupIds))
+    if (!sid || rids.length === 0) {
+      envelopes.value = {}
+      return
+    }
+    loading.value = true
+    const range = toValue(opts.range) ?? null
+    const next: Record<string, RollupEnvelope<T> | null> = {}
+    try {
+      await Promise.all(rids.map(async (rid) => {
+        next[rid] = await fetchOne<T>(sid, rid, ctx, range)
+      }))
+      envelopes.value = next
+    }
+    finally {
+      loading.value = false
+    }
+  }
+
+  watch(
+    () => [toValue(siteId), normaliseRollups(toValue(rollupIds)).join(','), toValue(opts.range)?.start, toValue(opts.range)?.end],
+    refresh,
+    { immediate: true },
+  )
+
+  return {
+    get: (rollupId: string) => envelopes.value[rollupId] ?? null,
+    payload: (rollupId: string) => envelopes.value[rollupId]?.payload ?? null,
+    envelopes,
+    loading: loading as Readonly<Ref<boolean>>,
+    refresh,
+  }
+}
+
+/**
+ * Fan one rollup id across N sites — returns `{ [siteId]: envelope | null }`.
+ * Used by the "all sites" overview page; composes without an overload.
+ */
+export function useGscRollupFanout<T = unknown>(
+  sites: MaybeRefOrGetter<readonly SiteLike[] | null | undefined>,
+  rollupId: MaybeRefOrGetter<string>,
+  opts: UseGscRollupOptions = {},
+): UseGscRollupFanoutReturn<T> {
+  const ctx = useGscAnalyticsContext()
+  const envelopes = ref<Record<string, RollupEnvelope<T> | null>>({})
+  const loading = ref(false)
+  const progress = ref<{ completed: number, total: number }>({ completed: 0, total: 0 })
+  // Ensures late-arriving promises from a superseded run don't mutate state
+  // for the current run (e.g. when the range changes rapidly).
+  let runToken = 0
+
+  async function refresh(): Promise<void> {
+    const token = ++runToken
+    const siteIds = normaliseSites(toValue(sites))
+    const rid = toValue(rollupId)
+    if (siteIds.length === 0 || !rid) {
+      envelopes.value = {}
+      progress.value = { completed: 0, total: 0 }
+      return
+    }
+    loading.value = true
+    // Seed envelopes with nulls so the UI can render skeleton rows before any
+    // fetch resolves. Writes land incrementally as each site returns.
+    const seeded: Record<string, RollupEnvelope<T> | null> = {}
+    for (const sid of siteIds) seeded[sid] = null
+    envelopes.value = seeded
+    progress.value = { completed: 0, total: siteIds.length }
+    const range = toValue(opts.range) ?? null
+    try {
+      await Promise.all(siteIds.map(async (sid) => {
+        const env = await fetchOne<T>(sid, rid, ctx, range)
+        if (token !== runToken)
+          return
+        envelopes.value = { ...envelopes.value, [sid]: env }
+        progress.value = { completed: progress.value.completed + 1, total: siteIds.length }
+      }))
+    }
+    finally {
+      if (token === runToken)
+        loading.value = false
+    }
+  }
+
+  watch(
+    () => [normaliseSites(toValue(sites)).join(','), toValue(rollupId), toValue(opts.range)?.start, toValue(opts.range)?.end],
+    refresh,
+    { immediate: true },
+  )
+
+  return {
+    envelopes,
+    loading: loading as Readonly<Ref<boolean>>,
+    progress: progress as Readonly<Ref<{ completed: number, total: number }>>,
+    refresh,
+  }
+}
+
+function normaliseSites(input: unknown): string[] {
+  if (!input)
+    return []
+  const list = Array.isArray(input) ? input : [input]
+  const out: string[] = []
+  for (const s of list) {
+    if (typeof s === 'string') {
+      if (s)
+        out.push(s)
+    }
+    else if (s && typeof s === 'object' && 'id' in s && typeof s.id === 'string' && s.id) {
+      out.push(s.id)
+    }
+  }
+  return out
+}
+
+async function fetchOne<T>(
+  siteId: string,
+  rollupId: string,
+  ctx: ReturnType<typeof useGscAnalyticsContext>,
+  range: { start: string, end: string } | null = null,
+): Promise<RollupEnvelope<T> | null> {
+  ctx.patchProgress(siteId, {
+    source: 'rollup',
+    stage: 'manifest',
+    filesTotal: 1,
+    filesAttached: 0,
+    startedAt: Date.now(),
+    error: undefined,
+    endedAt: undefined,
+  })
+  try {
+    const env = await useGscAnalyticsClient().getRollup<T>(
+      siteId,
+      rollupId,
+      range ? { start: range.start, end: range.end } : undefined,
+    )
+    ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
+    return env
+  }
+  catch (err: unknown) {
+    const status = (err as { statusCode?: number, status?: number })?.statusCode
+      ?? (err as { status?: number })?.status
+    if (status === 404) {
+      ctx.patchProgress(siteId, { stage: 'ready', filesAttached: 1, endedAt: Date.now() })
+      return null
+    }
+    const msg = err instanceof Error ? err.message : String(err)
+    ctx.patchProgress(siteId, { stage: 'error', error: msg, endedAt: Date.now() })
+    return null
+  }
+}
+
+function normaliseRollups(input: unknown): string[] {
+  if (!input)
+    return []
+  if (typeof input === 'string')
+    return input ? [input] : []
+  if (Array.isArray(input))
+    return input.filter((v): v is string => typeof v === 'string' && v.length > 0)
+  return []
+}

package/app/composables/useGscRollupTable.ts

@@ -0,0 +1,78 @@
+// Top-N rollup table state for list pages.
+//
+// Owns the canonical wiring previously duplicated across consumer apps:
+//   - shared `useGscPeriod` + windowed range
+//   - `useGscRollup` fetch
+//   - URL-synced search/sort via `useGscTableState`
+//   - debounced fuzzy filter on one row field
+//   - position-aware sort (sort key 'position' invokes `positionFor`)
+//   - top-N slice (default 100)
+//
+// Row shape contract: `impressions` + `sum_position` so `positionFor` works
+// without a caller-supplied accessor.
+
+import type { MaybeRefOrGetter, Ref } from '@vue/runtime-core'
+
+interface SortState { column: string, direction: 'asc' | 'desc' }
+
+export interface UseGscRollupTableOptions<TRow> {
+  siteId: MaybeRefOrGetter<string>
+  rollupKey: string
+  filterField: keyof TRow & string
+  defaultSort?: SortState
+  limit?: number
+  debounceMs?: number
+}
+
+// eslint-disable-next-line ts/explicit-function-return-type -- complex generic inference; explicit type would diverge as composables evolve
+export function useGscRollupTable<
+  TRow extends { impressions: number, sum_position: number },
+>(opts: UseGscRollupTableOptions<TRow>) {
+  const { period, compareMode, stableData, range } = useGscPeriod()
+  const windowRange = computed(() => ({ start: range.value.start, end: range.value.end }))
+
+  const { data: payload, loading } = useGscRollup<TRow[]>(
+    opts.siteId,
+    opts.rollupKey,
+    { range: windowRange },
+  )
+
+  const { q, sort, toggleSort } = useGscTableState({ defaultSort: opts.defaultSort })
+
+  const searchDebounced = refDebounced<string>(q, opts.debounceMs ?? 150)
+
+  const limit = opts.limit ?? 100
+  const rows = computed<TRow[]>(() => {
+    const needle = searchDebounced.value.trim().toLowerCase()
+    const source = (payload.value ?? []).slice()
+    const filtered = needle
+      ? source.filter((r: TRow) => {
+          const v = (r as Record<string, unknown>)[opts.filterField]
+          return typeof v === 'string' && v.toLowerCase().includes(needle)
+        })
+      : source
+    const s = sort.value
+    if (s) {
+      const dir = s.direction === 'desc' ? -1 : 1
+      filtered.sort((a: TRow, b: TRow) => {
+        const av = s.column === 'position' ? positionFor(a) : ((a as Record<string, unknown>)[s.column] as number)
+        const bv = s.column === 'position' ? positionFor(b) : ((b as Record<string, unknown>)[s.column] as number)
+        return av < bv ? -1 * dir : av > bv ? 1 * dir : 0
+      })
+    }
+    return filtered.slice(0, limit)
+  })
+
+  return {
+    period,
+    compareMode,
+    stableData,
+    range,
+    q,
+    sort,
+    toggleSort,
+    payload: payload as Ref<TRow[] | null>,
+    loading,
+    rows,
+  }
+}

package/app/composables/useGscRowQuery.ts

@@ -0,0 +1,56 @@
+// Thin client wrapper over POST /api/__gsc/sites/[siteId]/rows. Takes a
+// BuilderState (or a typed query builder) and returns reactive rows with
+// auto-refetch when the state / site changes.
+//
+// Use for row-level page needs (country breakdowns, top-N with custom
+// filters, per-page drilldowns, …). For analyzer-style transforms, use
+// `useGscQuery` which dispatches via /analyze.
+
+import type { QueryRow } from '@gscdump/analysis'
+import type { GscRowQueryMeta, GscRowQueryResponse } from '@gscdump/contracts'
+import type { ComputedRef, Ref } from '@vue/runtime-core'
+import type { BuilderState } from 'gscdump/query'
+import { useGscResource } from './_useGscResource'
+import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+
+export type { GscRowQueryMeta, GscRowQueryResponse } from '@gscdump/contracts'
+
+export interface UseGscRowQueryOptions {
+  site: MaybeRefOrGetter<string | null | undefined>
+  state: MaybeRefOrGetter<BuilderState | null | undefined>
+  /** Gate the query; when `false` stays idle (useful for lazy tabs). */
+  enabled?: MaybeRefOrGetter<boolean>
+}
+
+export interface UseGscRowQueryReturn<T> {
+  rows: ComputedRef<T[]>
+  meta: ComputedRef<GscRowQueryMeta | null>
+  loading: Ref<boolean>
+  error: Ref<Error | null>
+  refresh: () => Promise<void>
+}
+
+export function useGscRowQuery<T = QueryRow>(
+  opts: UseGscRowQueryOptions,
+): UseGscRowQueryReturn<T> {
+  const resource = useGscResource<[string, BuilderState], GscRowQueryResponse<T>>({
+    keys: [
+      () => (opts.enabled === undefined || toValue(opts.enabled) ? toValue(opts.site) : null),
+      // BuilderState is structural; stringify so keys[]-watch picks up shape changes.
+      () => {
+        const s = toValue(opts.state)
+        return s ? JSON.stringify(s) as unknown as BuilderState : null
+      },
+    ],
+    fetcher: site => useGscAnalyticsClient().queryRows<T>(site, toValue(opts.state) as BuilderState),
+    isEmpty: r => r.rows.length === 0,
+  })
+
+  return {
+    rows: computed(() => resource.data.value?.rows ?? []),
+    meta: computed(() => resource.data.value?.meta ?? null),
+    loading: resource.loading as unknown as Ref<boolean>,
+    error: resource.error,
+    refresh: resource.refresh,
+  }
+}

package/app/composables/useGscSearchAppearance.ts

@@ -0,0 +1,47 @@
+// Fetches per-search-appearance facet performance (AMP, rich results, videos, …)
+// for a site over a date window. Server dispatches tier-aware: free → GSC API
+// live, pro → engine parquet. Uniform row shape regardless of backend.
+
+import type { GscApiRange, SearchAppearanceResponse, SearchAppearanceRow } from '@gscdump/contracts'
+import type { ComputedRef, Ref } from '@vue/runtime-core'
+import type { GscResourceStatus } from './_useGscResource'
+import { useGscResource } from './_useGscResource'
+import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+
+export interface UseGscSearchAppearanceReturn {
+  response: Readonly<Ref<SearchAppearanceResponse | null>>
+  rows: ComputedRef<SearchAppearanceRow[]>
+  range: ComputedRef<GscApiRange | null>
+  source: ComputedRef<SearchAppearanceResponse['source'] | null>
+  loading: ComputedRef<boolean>
+  status: Ref<GscResourceStatus>
+  error: Ref<Error | null>
+  refresh: () => Promise<void>
+}
+
+export function useGscSearchAppearance(
+  siteId: MaybeRefOrGetter<string | null | undefined>,
+  range: MaybeRefOrGetter<{ start: string, end: string } | null | undefined>,
+): UseGscSearchAppearanceReturn {
+  const { data, status, loading, error, refresh } = useGscResource({
+    keys: [
+      siteId,
+      () => toValue(range)?.start,
+      () => toValue(range)?.end,
+    ] as const,
+    fetcher: (id: string, start: string, end: string) =>
+      useGscAnalyticsClient().getSearchAppearance(id, { start, end }),
+    isEmpty: r => r.rows.length === 0,
+  })
+
+  return {
+    response: data as Readonly<Ref<SearchAppearanceResponse | null>>,
+    rows: computed(() => data.value?.rows ?? []),
+    range: computed(() => data.value?.range ?? null),
+    source: computed(() => data.value?.source ?? null),
+    loading,
+    status,
+    error,
+    refresh,
+  }
+}

package/app/composables/useGscSitemapHistory.ts

@@ -0,0 +1,41 @@
+// Fetches the snapshot timeline for a single sitemap (by feedpath hash)
+// from the site's history store. Oldest → newest.
+
+import type { SitemapHistoryRecord, SitemapHistoryResponse } from '@gscdump/contracts'
+import type { ComputedRef, Ref } from '@vue/runtime-core'
+import type { GscResourceStatus } from './_useGscResource'
+import { useGscResource } from './_useGscResource'
+import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+
+export interface UseGscSitemapHistoryReturn {
+  response: Readonly<Ref<SitemapHistoryResponse | null>>
+  snapshots: ComputedRef<SitemapHistoryRecord[]>
+  path: ComputedRef<string | null>
+  loading: ComputedRef<boolean>
+  status: Ref<GscResourceStatus>
+  error: Ref<Error | null>
+  refresh: () => Promise<void>
+}
+
+export function useGscSitemapHistory(
+  siteId: MaybeRefOrGetter<string | null | undefined>,
+  feedpathHash: MaybeRefOrGetter<string | null | undefined>,
+): UseGscSitemapHistoryReturn {
+  const { data, status, loading, error, refresh } = useGscResource({
+    keys: [siteId, feedpathHash] as const,
+    fetcher: (id: string, hash: string) => useGscAnalyticsClient().getSitemapHistory(id, hash),
+  })
+
+  const snapshots = computed(() => data.value?.snapshots ?? [])
+  const path = computed(() => data.value?.path ?? null)
+
+  return {
+    response: data as Readonly<Ref<SitemapHistoryResponse | null>>,
+    snapshots,
+    path,
+    loading,
+    status,
+    error,
+    refresh,
+  }
+}

package/app/composables/useGscSitemaps.ts

@@ -0,0 +1,45 @@
+// Fetches the sitemap entity index for a site. Records are sorted by
+// `lastDownloaded` desc. Split from the previous `useEntity(kind)` discriminated
+// API so each entity stays its own typed hook.
+
+import type { SitemapHistoryRecord, SitemapIndex } from '@gscdump/contracts'
+import type { ComputedRef, Ref } from '@vue/runtime-core'
+import type { GscResourceStatus } from './_useGscResource'
+import { useGscResource } from './_useGscResource'
+import { useGscAnalyticsClient } from './useGscAnalyticsClient'
+
+export interface UseGscSitemapsReturn {
+  index: Readonly<Ref<SitemapIndex | null>>
+  records: ComputedRef<SitemapHistoryRecord[]>
+  loading: ComputedRef<boolean>
+  status: Ref<GscResourceStatus>
+  error: Ref<Error | null>
+  refresh: () => Promise<void>
+}
+
+export function useGscSitemaps(siteId: MaybeRefOrGetter<string | null | undefined>): UseGscSitemapsReturn {
+  const { data, status, loading, error, refresh } = useGscResource({
+    keys: [siteId] as const,
+    fetcher: (id: string) => useGscAnalyticsClient().getSitemaps(id),
+  })
+
+  const records = computed<SitemapHistoryRecord[]>(() => {
+    if (!data.value)
+      return []
+    const list = Object.values(data.value.records) as SitemapHistoryRecord[]
+    return list.sort((a, b) => {
+      const ad = a.lastDownloaded ?? ''
+      const bd = b.lastDownloaded ?? ''
+      return bd.localeCompare(ad)
+    })
+  })
+
+  return {
+    index: data as Readonly<Ref<SitemapIndex | null>>,
+    records,
+    loading,
+    status,
+    error,
+    refresh,
+  }
+}