@weaverse/next 0.1.0-alpha.2 → 0.1.0-alpha.20

package/src/server.ts

@@ -0,0 +1,67 @@
+/**
+ * Server-only Weaverse APIs for Next.js App Router server components and route
+ * handlers.
+ *
+ * When migrating from Hydrogen's `context.weaverse`, create a request-scoped
+ * client with {@link createWeaverseNextServerClient}, then call `loadPage()` or
+ * `loadThemeSettings()`. Keep rendering providers and components imported from
+ * the root `@weaverse/next` entrypoint.
+ *
+ * @packageDocumentation
+ */
+
+export type { WeaverseNextRevalidateRouteContext } from './revalidate-item'
+export {
+  formatWeaverseNextSeoMetadata,
+  getWeaverseNextSeoMetadata,
+  type NextOpenGraph,
+  type NextTwitter,
+  type WeaverseNextSeoInput,
+  type WeaverseNextSeoMetadata,
+  type WeaverseNextSeoPageContainer,
+} from './seo'
+export {
+  getWeaverseNextConfigs,
+  type ResolveConfigsOptions,
+} from './server/configs'
+export {
+  normalizeNextPageUrl,
+  resolveRequestUrl,
+} from './server/normalize-page-url'
+export {
+  createWeaverseNextRevalidateHandler,
+  type WeaverseNextRevalidateHandler,
+  type WeaverseNextRevalidateHandlerConfig,
+  type WeaverseNextRevalidateRequestBody,
+} from './server/revalidate-handler'
+export { createWeaverseNextServerClient } from './server/server-client'
+export type {
+  WeaverseNextBaseConfigs,
+  WeaverseNextCacheConfig,
+  WeaverseNextClient,
+  WeaverseNextCommerceContext,
+  WeaverseNextComponent,
+  WeaverseNextComponentData,
+  WeaverseNextComponentLoaderArgs,
+  WeaverseNextComponentProps,
+  WeaverseNextConfigs,
+  WeaverseNextCustomPageEntry,
+  WeaverseNextFetchCustomPagesOptions,
+  WeaverseNextFetchOptions,
+  WeaverseNextI18n,
+  WeaverseNextLoaderData,
+  WeaverseNextLoadPageInput,
+  WeaverseNextPageAssignment,
+  WeaverseNextPageData,
+  WeaverseNextProjectId,
+  WeaverseNextRequestContext,
+  WeaverseNextServerClient,
+  WeaverseNextServerClientConfig,
+  WeaverseNextServerLoadPageInput,
+  WeaverseNextStorefront,
+  WeaverseNextThemeSchema,
+  WeaverseNextThemeSchemaGroup,
+  WeaverseNextThemeSchemaInput,
+  WeaverseNextThemeSettingsOptions,
+  WeaverseNextThemeSettingsResponse,
+} from './types'

package/src/studio-bridge.tsx

@@ -0,0 +1,82 @@
+'use client'
+
+import { useEffect, useRef } from 'react'
+import {
+  bindWeaverseNextStudioRuntime,
+  type WeaverseNextRuntime,
+} from './runtime'
+import type { WeaverseNextRuntimeInternal } from './types'
+
+const STUDIO_BIND_RETRY_INTERVAL_MS = 50
+const STUDIO_BIND_MAX_ATTEMPTS = 100
+
+/** Runtime and host callbacks attached to the Builder Studio bridge. */
+export interface WeaverseNextStudioBridgeProps {
+  /** Preview navigation callback. */
+  navigate?: WeaverseNextRuntimeInternal['navigate']
+  /** Whole-route refresh callback used as a legacy fallback. */
+  revalidate?: WeaverseNextRuntimeInternal['revalidate']
+  /** Preferred per-item loader revalidation callback. */
+  revalidateItem?: WeaverseNextRuntimeInternal['revalidateItem']
+  /** Browser runtime to initialize or refresh in Studio. */
+  runtime: WeaverseNextRuntime
+}
+
+/** Page-level Studio runtime binder. */
+export function WeaverseNextStudioBridge(props: WeaverseNextStudioBridgeProps) {
+  let { runtime, navigate, revalidate, revalidateItem } = props
+  let lastRuntimeRef = useRef(runtime)
+  let lastRuntimeDataRef = useRef(runtime.data)
+  let lastRequestInfoRef = useRef(runtime.requestInfo)
+
+  useEffect(() => {
+    if (navigate) {
+      runtime.internal.navigate = navigate
+    }
+    if (revalidate) {
+      runtime.internal.revalidate = revalidate
+    }
+    if (revalidateItem) {
+      runtime.internal.revalidateItem = revalidateItem
+    }
+
+    if (bindWeaverseNextStudioRuntime(runtime) || !runtime.isDesignMode) {
+      return
+    }
+
+    let attempts = 0
+    let interval = window.setInterval(() => {
+      attempts += 1
+      if (
+        bindWeaverseNextStudioRuntime(runtime) ||
+        attempts >= STUDIO_BIND_MAX_ATTEMPTS
+      ) {
+        window.clearInterval(interval)
+      }
+    }, STUDIO_BIND_RETRY_INTERVAL_MS)
+
+    return () => window.clearInterval(interval)
+  }, [runtime, navigate, revalidate, revalidateItem])
+
+  useEffect(() => {
+    if (lastRuntimeRef.current !== runtime) {
+      lastRuntimeRef.current = runtime
+      lastRuntimeDataRef.current = runtime.data
+      lastRequestInfoRef.current = runtime.requestInfo
+      return
+    }
+
+    if (
+      lastRuntimeDataRef.current === runtime.data &&
+      lastRequestInfoRef.current === runtime.requestInfo
+    ) {
+      return
+    }
+
+    lastRuntimeDataRef.current = runtime.data
+    lastRequestInfoRef.current = runtime.requestInfo
+    bindWeaverseNextStudioRuntime(runtime)
+  }, [runtime, runtime.data, runtime.requestInfo])
+
+  return null
+}

package/src/studio-connect.tsx

@@ -0,0 +1,88 @@
+'use client'
+
+import { useEffect } from 'react'
+import { resolveWeaverseNextStudioScriptSrc } from './studio-script-src'
+import type { WeaverseNextRequestContext } from './types'
+
+const loadedScriptSrcs = new Set<string>()
+
+function loadScript(src: string) {
+  if (typeof document === 'undefined') {
+    return
+  }
+
+  if (loadedScriptSrcs.has(src)) {
+    return
+  }
+
+  let existing = document.querySelector(`script[src="${src}"]`)
+  if (existing) {
+    loadedScriptSrcs.add(src)
+    return
+  }
+
+  let script = document.createElement('script')
+  script.async = true
+  script.src = src
+  document.head.appendChild(script)
+  loadedScriptSrcs.add(src)
+}
+
+/** Trust context used while loading the Studio bridge script. */
+export interface LoadWeaverseNextStudioScriptOptions {
+  /** Storefront hostname; required to permit loopback Studio origins. */
+  storefrontHostname?: string
+}
+
+/**
+ * Resolve and append the Next Studio bridge script for the given request
+ * context, deduping by src. SSR-safe (no-op without `document`) so it can run
+ * unconditionally from a root layout/error boundary before any page tree or
+ * runtime exists — e.g. App Router `not-found.tsx` / `error.tsx` routes.
+ */
+export function loadWeaverseNextStudioScript(
+  context?: WeaverseNextRequestContext,
+  options: LoadWeaverseNextStudioScriptOptions = {}
+) {
+  let resolvedContext = context
+  if (!resolvedContext && typeof window !== 'undefined') {
+    resolvedContext = {
+      searchParams: new URLSearchParams(window.location.search),
+      url: window.location.href,
+    }
+  }
+
+  let src = resolveWeaverseNextStudioScriptSrc(resolvedContext, {
+    storefrontHostname:
+      options.storefrontHostname ??
+      (typeof window === 'undefined' ? undefined : window.location.hostname),
+  })
+  if (src) {
+    loadScript(src)
+  }
+}
+
+/** Props for the root-level Studio script connector. */
+export interface WeaverseNextStudioConnectProps {
+  /** Explicit request context used to resolve Studio mode and host. */
+  context?: WeaverseNextRequestContext
+  /** Storefront hostname; required to permit loopback Studio origins. */
+  storefrontHostname?: string
+}
+
+/**
+ * Root-level Studio script connector for Next client boundaries. Mount once
+ * near the app root (e.g. root layout) so it also covers routes that never
+ * render `WeaverseNextRenderer`, such as `not-found.tsx` / `error.tsx`.
+ */
+export function WeaverseNextStudioConnect(
+  props: WeaverseNextStudioConnectProps
+) {
+  useEffect(() => {
+    loadWeaverseNextStudioScript(props.context, {
+      storefrontHostname: props.storefrontHostname,
+    })
+  }, [props.context, props.storefrontHostname])
+
+  return null
+}

package/src/studio-router.ts

@@ -0,0 +1,85 @@
+import type { WeaverseNextRuntimeInternal } from './types'
+
+/**
+ * Minimal structural shape of the Next App Router returned by `useRouter()`
+ * (`next/navigation`) that the Studio bridge needs. Declared locally — rather
+ * than importing `AppRouterInstance` from `next` — so the adapter stays a pure
+ * function that unit tests can drive with a plain mock and never pulls
+ * `next/navigation` into the test graph.
+ */
+export interface WeaverseNextRouterLike {
+  /** Add a route to browser history. */
+  push: (
+    href: string,
+    options?: {
+      /** Whether to scroll to the top after navigation. */
+      scroll?: boolean
+    }
+  ) => void
+  /** Refresh the current App Router route and server data. */
+  refresh: () => void
+  /** Replace the current browser-history entry. */
+  replace: (
+    href: string,
+    options?: {
+      /** Whether to scroll to the top after navigation. */
+      scroll?: boolean
+    }
+  ) => void
+}
+
+/** Resolved Studio navigation/revalidation callbacks for a Next runtime. */
+export interface WeaverseNextStudioInternals {
+  /** Navigate Studio's preview with React Router-compatible options. */
+  navigate: NonNullable<WeaverseNextRuntimeInternal['navigate']>
+  /** Refresh the current App Router route. */
+  revalidate: NonNullable<WeaverseNextRuntimeInternal['revalidate']>
+}
+
+/** Controls how Studio navigation maps to the Next App Router. */
+export interface CreateWeaverseNextStudioInternalsOptions {
+  /** Use `router.replace` instead of `router.push` for navigation. */
+  replace?: boolean
+}
+
+function shouldResetScroll(
+  options?: { preventScrollReset?: boolean } | Record<string, unknown>
+): boolean {
+  if (!options || typeof options !== 'object') {
+    return true
+  }
+  return !(options as { preventScrollReset?: boolean }).preventScrollReset
+}
+
+/**
+ * Build Studio `navigate` / `revalidate` callbacks from a Next App Router.
+ *
+ * Maps Hydrogen's React Router semantics onto Next App Router:
+ * - `navigate(to, { preventScrollReset })` → `router.push(to, { scroll })`,
+ *   where `scroll` is the inverse of `preventScrollReset`. Studio passes
+ *   `preventScrollReset` for in-place edits so the preview viewport is kept,
+ *   matching React Router's `navigate({ preventScrollReset })`.
+ * - `revalidate()` → `router.refresh()`, the App Router's loader-backed refresh
+ *   and the closest equivalent to React Router's `useRevalidator`.
+ *
+ * Pure (no React, no `next/navigation`) so it is unit-testable with a mock
+ * router; the {@link WeaverseNextRouterLike} contract is the only coupling.
+ */
+export function createWeaverseNextStudioInternals(
+  router: WeaverseNextRouterLike,
+  options: CreateWeaverseNextStudioInternalsOptions = {}
+): WeaverseNextStudioInternals {
+  return {
+    navigate: (to, navigateOptions) => {
+      let scroll = shouldResetScroll(navigateOptions)
+      if (options.replace) {
+        router.replace(to, { scroll })
+      } else {
+        router.push(to, { scroll })
+      }
+    },
+    revalidate: () => {
+      router.refresh()
+    },
+  }
+}

package/src/studio-script-src.ts

@@ -0,0 +1,128 @@
+import type { WeaverseNextRequestContext } from './types'
+
+/**
+ * Weaverse-controlled apex domains the Studio bridge may be served from
+ * (matched on the host itself and any subdomain), mirroring Hydrogen's
+ * `TRUSTED_STUDIO_DOMAINS`.
+ */
+const TRUSTED_STUDIO_DOMAINS = ['weaverse.io', 'weaverse.dev']
+
+function isLoopbackHostname(hostname: string): boolean {
+  return (
+    hostname === 'localhost' ||
+    hostname === '127.0.0.1' ||
+    hostname.endsWith('.localhost')
+  )
+}
+
+function normalizeOrigin(value: string | null): string | null {
+  if (!value) {
+    return null
+  }
+
+  try {
+    return new URL(value).origin
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Whether `origin` is one we trust to serve the Studio bridge script. Matches
+ * Hydrogen's `isTrustedStudioHost`: trusts `weaverse.io` / `weaverse.dev` and
+ * their subdomains over https, plus loopback (`localhost` / `*.localhost` /
+ * `127.0.0.1`) — but only when the storefront itself is loopback (genuine
+ * local-builder dev). Loopback is the only place http is allowed; every other
+ * trusted host must be https. Arbitrary origins are rejected.
+ */
+function isTrustedStudioOrigin(
+  origin: string,
+  storefrontHostname: string
+): boolean {
+  let parsed: URL
+  try {
+    parsed = new URL(origin)
+  } catch {
+    return false
+  }
+
+  let { hostname, protocol } = parsed
+  if (isLoopbackHostname(storefrontHostname) && isLoopbackHostname(hostname)) {
+    return protocol === 'http:' || protocol === 'https:'
+  }
+
+  if (protocol !== 'https:') {
+    return false
+  }
+
+  return TRUSTED_STUDIO_DOMAINS.some(
+    (domain) => hostname === domain || hostname.endsWith(`.${domain}`)
+  )
+}
+
+function toSearchParams(context?: WeaverseNextRequestContext): URLSearchParams {
+  if (context?.searchParams) {
+    return new URLSearchParams(context.searchParams)
+  }
+
+  if (context?.url) {
+    let url =
+      typeof context.url === 'string'
+        ? new URL(context.url, 'http://localhost')
+        : context.url
+    return new URLSearchParams(url.searchParams)
+  }
+
+  return new URLSearchParams()
+}
+
+function last(searchParams: URLSearchParams, key: string): string | null {
+  let values = searchParams.getAll(key)
+  return values.length ? (values.at(-1) ?? null) : null
+}
+
+/** Trust context used when resolving a Studio bridge script URL. */
+export interface ResolveWeaverseNextStudioScriptSrcOptions {
+  /** Storefront hostname; required to permit loopback Studio origins. */
+  storefrontHostname?: string
+}
+
+/**
+ * Resolve the Studio script URL from request/search context. `@weaverse/next`
+ * uses the dedicated Next bridge path served by Builder.
+ */
+export function resolveWeaverseNextStudioScriptSrc(
+  context?: WeaverseNextRequestContext,
+  options: ResolveWeaverseNextStudioScriptSrcOptions = {}
+): string | null {
+  let searchParams = toSearchParams(context)
+
+  let isDesignMode =
+    context?.isDesignMode ?? last(searchParams, 'isDesignMode') === 'true'
+  let isPreviewMode =
+    context?.isPreviewMode ?? last(searchParams, 'isPreviewMode') === 'true'
+  let isRevisionPreview =
+    context?.isRevisionPreview ?? Boolean(last(searchParams, '__revisionId'))
+
+  if (!(isDesignMode || isPreviewMode || isRevisionPreview)) {
+    return null
+  }
+
+  let origin = normalizeOrigin(last(searchParams, 'weaverseHost'))
+  if (!origin) {
+    return null
+  }
+
+  let storefrontHostname = options.storefrontHostname ?? ''
+  if (!isTrustedStudioOrigin(origin, storefrontHostname)) {
+    return null
+  }
+
+  // Builder section-preview URLs carry both isDesignMode and isPreviewMode;
+  // the preview iframe waits for `preview-size`, which only preview.js emits,
+  // so preview/revision mode takes precedence (matching Hydrogen).
+  let bundle = isPreviewMode || isRevisionPreview ? 'preview.js' : 'index.js'
+  let version = last(searchParams, 'weaverseVersion')
+  let url = `${origin}/static/studio/next/${bundle}`
+  return version ? `${url}?v=${encodeURIComponent(version)}` : url
+}

package/src/theme-settings-store.ts

@@ -0,0 +1,47 @@
+import type { SchemaType } from '@weaverse/schema'
+import type {
+  WeaverseNextThemeSchema,
+  WeaverseNextThemeSettingsStore,
+} from './types'
+
+/** Initial values for a root-scoped theme-settings store. */
+export interface CreateWeaverseNextThemeSettingsStoreOptions {
+  /** Public environment values exposed alongside the store. */
+  publicEnv?: Record<string, string | undefined>
+  /** Theme schema associated with the settings. */
+  schema?: SchemaType | WeaverseNextThemeSchema
+  /** Initial setting values. */
+  settings?: Record<string, unknown>
+}
+
+/**
+ * Small external store shape compatible with the Studio bridge and React's
+ * `useSyncExternalStore` contract. The bridge calls `updateThemeSettings` during
+ * live theme edits, so keep that method name stable.
+ */
+export function createWeaverseNextThemeSettingsStore(
+  options: CreateWeaverseNextThemeSettingsStoreOptions = {}
+): WeaverseNextThemeSettingsStore {
+  let listeners = new Set<() => void>()
+  let store: WeaverseNextThemeSettingsStore = {
+    publicEnv: options.publicEnv,
+    schema: options.schema,
+    settings: { ...(options.settings ?? {}) },
+    getServerSnapshot: () => store.settings,
+    getSnapshot: () => store.settings,
+    subscribe: (listener: () => void) => {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    updateThemeSettings: (next: Record<string, unknown>) => {
+      store.settings = { ...store.settings, ...next }
+      for (let listener of listeners) {
+        listener()
+      }
+    },
+  }
+
+  return store
+}