@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-6HDT4G4A.js

@@ -0,0 +1,253 @@
+import { getSEOPageData, ensureMetadata, getABTest, recordABImpression, getRedirectData, getRobotsData, getSitemapEntries } from './chunk-N2UVOR3X.js';
+import { titleProblem, descriptionProblem } from './chunk-BQR4IPBW.js';
+import { resolveSiteHost } from './chunk-FESKKJAS.js';
+
+// src/seo/getManagedMetadata.ts
+async function getManagedMetadata(options) {
+  const { path, fallback = {}, overrides = {}, favicon: faviconMode = "metadata" } = options;
+  const omitIcons = faviconMode === "component";
+  const result = await getSEOPageData(path);
+  const pageData = result?.page;
+  const projectData = result?.project;
+  if (!pageData) {
+    const fallbackMeta = {
+      ...fallback,
+      ...overrides,
+      _managed: false,
+      _source: "fallback"
+    };
+    if (!omitIcons && projectData?.logo_url) {
+      fallbackMeta.icons = {
+        icon: projectData.logo_url,
+        apple: projectData.logo_url
+      };
+    }
+    return fallbackMeta;
+  }
+  const metadata = {
+    _managed: true,
+    _source: "database"
+  };
+  if (!omitIcons && projectData?.logo_url) {
+    metadata.icons = {
+      icon: projectData.logo_url,
+      apple: projectData.logo_url
+    };
+  }
+  if (!pageData.managed_title && !pageData.managed_meta_description && !pageData.managed_description) {
+    ensureMetadata(path).catch(() => {
+    });
+  }
+  const identity = {
+    brand: projectData?.brand ?? projectData?.title ?? null,
+    hosts: [resolveSiteHost(), pageData.site, projectData?.domain, projectData?.site_url]
+  };
+  const rejected = {};
+  const rawTitle = pageData.managed_title;
+  const titleIssue = rawTitle ? titleProblem(rawTitle, identity, { path }) : null;
+  if (titleIssue) rejected.title = titleIssue;
+  const managedTitle = rawTitle && !titleIssue ? rawTitle : void 0;
+  const rawDescription = pageData.managed_meta_description || pageData.managed_description;
+  const descriptionIssue = rawDescription ? descriptionProblem(rawDescription, identity) : null;
+  if (descriptionIssue) rejected.description = descriptionIssue;
+  const managedDescription = rawDescription && !descriptionIssue ? rawDescription : void 0;
+  if (titleIssue || descriptionIssue) metadata._rejected = rejected;
+  if (managedTitle) {
+    metadata.title = managedTitle;
+  } else if (fallback.title) {
+    metadata.title = fallback.title;
+  }
+  if (managedDescription) {
+    metadata.description = managedDescription;
+  } else if (fallback.description) {
+    metadata.description = fallback.description;
+  }
+  if (pageData.managed_keywords?.length) {
+    metadata.keywords = pageData.managed_keywords;
+  } else if (fallback.keywords) {
+    metadata.keywords = fallback.keywords;
+  }
+  if (pageData.managed_robots) {
+    metadata.robots = pageData.managed_robots;
+  }
+  if (pageData.managed_canonical) {
+    metadata.alternates = {
+      ...metadata.alternates,
+      canonical: pageData.managed_canonical
+    };
+  }
+  const langAlts = pageData.language_alternates;
+  if (langAlts && typeof langAlts === "object" && !Array.isArray(langAlts)) {
+    metadata.alternates = {
+      ...metadata.alternates,
+      languages: langAlts
+    };
+  }
+  const managedOgTitle = pageData.managed_og_title && !titleProblem(pageData.managed_og_title, identity, { path }) ? pageData.managed_og_title : void 0;
+  const managedOgDescription = pageData.managed_og_description && !descriptionProblem(pageData.managed_og_description, identity) ? pageData.managed_og_description : void 0;
+  const ogTitle = managedOgTitle || managedTitle;
+  const ogDescription = managedOgDescription || managedDescription;
+  const ogImage = pageData.managed_og_image;
+  if (ogTitle || ogDescription || ogImage) {
+    metadata.openGraph = {
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...ogImage && { images: [{ url: ogImage }] }
+    };
+  }
+  if (ogTitle || ogDescription || ogImage) {
+    metadata.twitter = {
+      card: "summary_large_image",
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...ogImage && { images: [ogImage] }
+    };
+  }
+  return {
+    ...metadata,
+    ...overrides,
+    _managed: true,
+    _source: "database"
+  };
+}
+async function getABVariant(options) {
+  const { path, field, sessionId } = options;
+  const test = await getABTest(path, field);
+  if (!test) {
+    return null;
+  }
+  let variant;
+  if (sessionId) {
+    const hash = sessionId.split("").reduce((acc, char) => {
+      return (acc << 5) - acc + char.charCodeAt(0);
+    }, 0);
+    variant = Math.abs(hash) % 100 < test.traffic_split * 100 ? "a" : "b";
+  } else {
+    variant = Math.random() < test.traffic_split ? "a" : "b";
+  }
+  recordABImpression(test.id, variant, sessionId).catch(() => {
+  });
+  return {
+    testId: test.id,
+    variant,
+    value: variant === "a" ? test.variant_a : test.variant_b
+  };
+}
+async function getManagedMetadataWithAB(options) {
+  const { sessionId, ...metadataOptions } = options;
+  const metadata = await getManagedMetadata(metadataOptions);
+  const titleTest = await getABVariant({
+    path: options.path,
+    field: "title",
+    sessionId
+  });
+  if (titleTest) {
+    metadata.title = titleTest.value;
+  }
+  const descTest = await getABVariant({
+    path: options.path,
+    field: "description",
+    sessionId
+  });
+  if (descTest) {
+    metadata.description = descTest.value;
+  }
+  return metadata;
+}
+
+// src/seo/routing.ts
+async function getRedirect(options) {
+  const { path } = options;
+  const redirect = await getRedirectData(path);
+  if (!redirect) {
+    return null;
+  }
+  if (redirect.expires_at && new Date(redirect.expires_at) < /* @__PURE__ */ new Date()) {
+    return null;
+  }
+  const destination = redirect.destination_url || redirect.destination_path;
+  const isExternal = destination.startsWith("http://") || destination.startsWith("https://");
+  return {
+    destination,
+    statusCode: redirect.status_code,
+    isExternal
+  };
+}
+function parseRobotsString(robots) {
+  const directive = {
+    index: true,
+    follow: true
+  };
+  const parts = robots.toLowerCase().split(",").map((p) => p.trim());
+  for (const part of parts) {
+    if (part === "noindex") directive.index = false;
+    if (part === "nofollow") directive.follow = false;
+    if (part === "noarchive") directive.noarchive = true;
+    if (part === "nosnippet") directive.nosnippet = true;
+    if (part === "noimageindex") directive.noimageindex = true;
+    if (part.startsWith("max-snippet:")) {
+      directive.max_snippet = parseInt(part.split(":")[1], 10);
+    }
+    if (part.startsWith("max-image-preview:")) {
+      const value = part.split(":")[1];
+      directive.max_image_preview = value;
+    }
+    if (part.startsWith("max-video-preview:")) {
+      directive.max_video_preview = parseInt(part.split(":")[1], 10);
+    }
+  }
+  return directive;
+}
+async function getRobotsDirective(options) {
+  const { path } = options;
+  const robotsString = await getRobotsData(path);
+  if (!robotsString) {
+    return { index: true, follow: true };
+  }
+  return parseRobotsString(robotsString);
+}
+async function generateSitemap(options) {
+  const { baseUrl, publishedOnly = true } = options;
+  const pages = await getSitemapEntries({ publishedOnly });
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return pages.map((page) => ({
+    path: page.path,
+    url: `${normalizedBase}${page.path}`,
+    lastmod: page.lastmod,
+    changefreq: page.changefreq || "weekly",
+    priority: page.priority ?? 0.5
+  }));
+}
+async function registerLocalSitemap(options) {
+  const { registerSitemap } = await import('./server-api-GJJQZVG7.js');
+  let entries = options.entries || [];
+  if (options.autoDiscover && entries.length === 0) {
+    try {
+      const { discoverNextJsRoutes, findAppDirForDiscovery } = await import('./discover-3YYOHOQP.js');
+      const appDir = findAppDirForDiscovery();
+      if (appDir) {
+        entries = discoverNextJsRoutes(appDir);
+        console.log(`[Sonor] Auto-discovered ${entries.length} routes from app directory`);
+      }
+    } catch (error) {
+      console.error("[Sonor] Auto-discovery failed:", error);
+    }
+  }
+  if (entries.length === 0) {
+    console.warn("[Sonor] No sitemap entries to register");
+    return { success: true, created: 0, updated: 0 };
+  }
+  const mode = options.mode ?? "additive";
+  console.log(`[Sonor] Registering ${entries.length} sitemap entries (${mode})...`);
+  const result = await registerSitemap(entries, { mode, site: options.site });
+  if (result.success) {
+    console.log(`[Sonor] Sitemap registered: ${result.created} new, ${result.updated} updated`);
+  }
+  return result;
+}
+async function isIndexable(projectId, path) {
+  const directive = await getRobotsDirective({ path });
+  return directive.index;
+}
+
+export { generateSitemap, getABVariant, getManagedMetadata, getManagedMetadataWithAB, getRedirect, getRobotsDirective, isIndexable, registerLocalSitemap };

package/dist/chunk-6T6CQVNL.js

@@ -0,0 +1,37 @@
+'use client';
+import { useEffect } from 'react';
+
+// src/shared/visual-viewport-gap.ts
+var VISUAL_VIEWPORT_GAP_PROPERTY = "--sk-vv-layout-gap";
+function measureVisualViewportGap(win) {
+  const vv = win.visualViewport;
+  if (!vv) return 0;
+  return Math.max(0, Math.round(win.innerHeight - vv.offsetTop - vv.height));
+}
+function useVisualViewportGap() {
+  useEffect(() => {
+    const root = document.documentElement;
+    const vv = window.visualViewport;
+    const sync = () => {
+      const next = `${measureVisualViewportGap(window)}px`;
+      if (root.style.getPropertyValue(VISUAL_VIEWPORT_GAP_PROPERTY) === next) return;
+      root.style.setProperty(VISUAL_VIEWPORT_GAP_PROPERTY, next);
+    };
+    sync();
+    vv?.addEventListener("resize", sync);
+    vv?.addEventListener("scroll", sync);
+    window.addEventListener("resize", sync);
+    return () => {
+      vv?.removeEventListener("resize", sync);
+      vv?.removeEventListener("scroll", sync);
+      window.removeEventListener("resize", sync);
+      root.style.removeProperty(VISUAL_VIEWPORT_GAP_PROPERTY);
+    };
+  }, []);
+}
+function VisualViewportGap() {
+  useVisualViewportGap();
+  return null;
+}
+
+export { VISUAL_VIEWPORT_GAP_PROPERTY, VisualViewportGap, useVisualViewportGap };

package/dist/chunk-6ZB3XNAT.js

@@ -0,0 +1,54 @@
+'use client';
+import { getSiteDesignTokens, tokensForReport, shouldReportDesign, sendSiteDesign } from './chunk-MZFF5F7R.js';
+import { designTokensHash } from './chunk-IHG36STL.js';
+import { useDeferredActivation } from './chunk-YC7ELZS3.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { useRef, useEffect } from 'react';
+
+var STAMP_KEY = (site) => `_sk_design_sent:${site}`;
+function SiteDesignReporter({
+  apiUrl,
+  apiKey,
+  site,
+  overrides,
+  defer = true,
+  allowInFrame = false,
+  allowLocalhost = false,
+  debug = false
+}) {
+  const ready = useDeferredActivation(defer);
+  const doneRef = useRef(false);
+  useEffect(() => {
+    if (!ready || doneRef.current || typeof window === "undefined") return;
+    doneRef.current = true;
+    if ((window.location.pathname || "/") !== "/") return;
+    const target = resolveAnalyticsTarget({ apiUrl, apiKey, allowInFrame, allowLocalhost, debug });
+    if (!target) return;
+    const w = window;
+    const host = site || w.__SITE_KIT_SITE__ || window.location.host;
+    const tokens = getSiteDesignTokens({ site: host, overrides, requirePath: "/" });
+    if (!tokens) {
+      if (debug) console.info("[Sonor design] nothing to report: no background, text or accent color found");
+      return;
+    }
+    const hash = designTokensHash(tokensForReport(tokens));
+    let stamp = null;
+    try {
+      stamp = localStorage.getItem(STAMP_KEY(host));
+    } catch {
+    }
+    if (!shouldReportDesign(stamp, hash, Date.now())) return;
+    void sendSiteDesign({ apiUrl: target.apiUrl, apiKey: target.apiKey, site: host, tokens, path: "/", allowInFrame, allowLocalhost, debug }).then(
+      (ok) => {
+        if (!ok) return;
+        try {
+          localStorage.setItem(STAMP_KEY(host), `${hash}:${Date.now()}`);
+        } catch {
+        }
+      }
+    );
+  }, [ready, apiUrl, apiKey, site, overrides, allowInFrame, allowLocalhost, debug]);
+  return null;
+}
+
+export { SiteDesignReporter };

package/dist/chunk-7KJGO77W.js

@@ -0,0 +1 @@
+

package/dist/chunk-7L5AARVY.js

@@ -0,0 +1,68 @@
+import { sameSite } from './chunk-NZOJHERI.js';
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+
+// src/contracts/seo-pages.ts
+var SEO_PAGES_CONTRACT_VERSION = 1;
+var LIVE_SEO_PAGE_FILTER = "status.is.null,status.eq.active";
+function pickSeoPageRow(rows, opts = {}) {
+  if (!rows.length) return null;
+  if (rows.length === 1) return rows[0];
+  const wanted = normalizeSiteHost(opts.site);
+  if (wanted) {
+    const exact = rows.find((r) => sameSite(r.site, wanted));
+    if (exact) return exact;
+  }
+  const unattributed = rows.find((r) => !r.site);
+  if (unattributed) return unattributed;
+  const primary = normalizeSiteHost(opts.primaryHost);
+  if (primary) {
+    const main = rows.find((r) => sameSite(r.site, primary));
+    if (main) return main;
+  }
+  return [...rows].sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? ""))[0];
+}
+function matchSitemapEntryRow(candidates, site, primaryHost) {
+  if (!candidates.length) return null;
+  if (site) {
+    return candidates.find((r) => sameSite(r.site, site)) ?? candidates.find((r) => !r.site) ?? null;
+  }
+  return pickSeoPageRow(candidates, { primaryHost });
+}
+function scopeSeoPagesToSite(rows, site, primaryHost) {
+  const wanted = normalizeSiteHost(site);
+  const host = normalizeSiteHost(primaryHost);
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const path = row.path ?? "";
+    const key = path.replace(/\/$/, "") || path;
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(row);
+    else groups.set(key, [row]);
+  }
+  const scoped = [];
+  for (const candidates of groups.values()) {
+    const picked = matchSitemapEntryRow(candidates, wanted, host);
+    if (picked) scoped.push(picked);
+  }
+  return scoped;
+}
+var SEO_PAGE_ROW_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/seo-page-row.v1.json",
+  title: "SeoPageRowLike",
+  description: "The subset of an seo_pages row that determines per-site resolution.",
+  type: "object",
+  properties: {
+    site: {
+      description: "Normalized sub-site host, or null for a project-wide row.",
+      type: ["string", "null"]
+    },
+    updated_at: {
+      description: "ISO 8601 timestamp; ties in resolution break toward the most recent.",
+      type: ["string", "null"]
+    }
+  },
+  additionalProperties: true
+};
+
+export { LIVE_SEO_PAGE_FILTER, SEO_PAGES_CONTRACT_VERSION, SEO_PAGE_ROW_JSON_SCHEMA, matchSitemapEntryRow, pickSeoPageRow, scopeSeoPagesToSite };

package/dist/chunk-7ZHJIRM3.js

@@ -0,0 +1,4 @@
+// src/shared/version.ts
+var SITE_KIT_VERSION = "7.0.0";
+
+export { SITE_KIT_VERSION };

package/dist/chunk-7ZWO5HDQ.js

@@ -0,0 +1 @@
+

package/dist/chunk-A4CC4ZG3.js

@@ -0,0 +1,15 @@
+// src/contracts/sites-normalize.ts
+function normalizeSiteHost(site) {
+  if (!site || typeof site !== "string") return null;
+  let s = site.trim().toLowerCase();
+  if (!s) return null;
+  s = s.replace(/^https?:\/\//, "");
+  const slash = s.indexOf("/");
+  if (slash >= 0) s = s.slice(0, slash);
+  const colon = s.indexOf(":");
+  if (colon >= 0) s = s.slice(0, colon);
+  s = s.replace(/\.+$/, "");
+  return s || null;
+}
+
+export { normalizeSiteHost };

package/dist/chunk-AQSNPZY4.js

@@ -0,0 +1,92 @@
+// src/forms/field-rules.ts
+var DISPLAY_ONLY_FIELD_TYPES = [
+  "heading",
+  "section_header",
+  "paragraph",
+  "hidden"
+];
+function isDisplayOnly(field) {
+  return DISPLAY_ONLY_FIELD_TYPES.includes(field.field_type);
+}
+function isEmptyValue(value) {
+  if (value === void 0 || value === null || value === "") return true;
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function isUnanswered(value) {
+  return isEmptyValue(value) || value === false;
+}
+function searchableTexts(value) {
+  const items = Array.isArray(value) ? value : [value];
+  return items.map((item) => item === void 0 || item === null ? "" : String(item));
+}
+function isFieldVisible(field, values) {
+  const condition = field.conditional?.show_when;
+  if (!condition) return true;
+  const { field: condField, operator, value } = condition;
+  const fieldValue = values[condField];
+  switch (operator) {
+    case "equals":
+      return fieldValue === value;
+    case "not_equals":
+      return fieldValue !== value;
+    case "contains":
+      return searchableTexts(fieldValue).some((text) => text.includes(String(value)));
+    case "not_contains":
+      return !searchableTexts(fieldValue).some((text) => text.includes(String(value)));
+    case "is_empty":
+      return isUnanswered(fieldValue);
+    case "not_empty":
+      return !isUnanswered(fieldValue);
+    case "greater_than":
+      return Number(fieldValue) > Number(value);
+    case "less_than":
+      return Number(fieldValue) < Number(value);
+    default:
+      return true;
+  }
+}
+function validateField(field, values, isVisible = (f) => isFieldVisible(f, values)) {
+  if (!isVisible(field)) return null;
+  if (isDisplayOnly(field)) return null;
+  const value = values[field.slug];
+  const rules = field.validation || {};
+  if (isUnanswered(value)) {
+    return field.is_required ? rules.custom_error || `${field.label} is required` : null;
+  }
+  const strValue = String(value);
+  if (rules.min_length && strValue.length < rules.min_length) {
+    return `${field.label} must be at least ${rules.min_length} characters`;
+  }
+  if (rules.max_length && strValue.length > rules.max_length) {
+    return `${field.label} must be no more than ${rules.max_length} characters`;
+  }
+  if (rules.min !== void 0 && Number(value) < rules.min) {
+    return `${field.label} must be at least ${rules.min}`;
+  }
+  if (rules.max !== void 0 && Number(value) > rules.max) {
+    return `${field.label} must be no more than ${rules.max}`;
+  }
+  if (rules.pattern) {
+    try {
+      if (!new RegExp(rules.pattern).test(strValue)) {
+        return rules.custom_error || `${field.label} is invalid`;
+      }
+    } catch {
+    }
+  }
+  if (field.field_type === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue)) {
+    return "Please enter a valid email address";
+  }
+  if (field.field_type === "phone" && !/^[\d\s\-\+\(\)]+$/.test(strValue)) {
+    return "Please enter a valid phone number";
+  }
+  return null;
+}
+function isFieldComplete(field, values, isVisible = (f) => isFieldVisible(f, values)) {
+  if (!isVisible(field) || isDisplayOnly(field)) return false;
+  if (isEmptyValue(values[field.slug])) return false;
+  return validateField(field, values, isVisible) === null;
+}
+
+export { isDisplayOnly, isEmptyValue, isFieldComplete, isFieldVisible, validateField };