@sonordev/site-kit 6.4.0 → 7.0.0

package/dist/chunk-G3NHWMP5.js

@@ -0,0 +1,233 @@
+// src/commerce/server.ts
+function isFrameworkSignal(err) {
+  const digest = err?.digest;
+  return typeof digest === "string" && (digest === "DYNAMIC_SERVER_USAGE" || digest.startsWith("NEXT_"));
+}
+async function apiFetch(config, endpoint) {
+  try {
+    const response = await fetch(`${config.apiUrl}${endpoint}`, {
+      headers: {
+        "X-API-Key": config.apiKey,
+        "X-Project-ID": config.projectId,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      console.error(`[site-kit/commerce] GET ${endpoint} failed: ${response.status}`);
+      return { ok: false, data: null };
+    }
+    return { ok: true, data: await response.json() };
+  } catch (error) {
+    if (isFrameworkSignal(error)) throw error;
+    console.error(`[site-kit/commerce] GET ${endpoint} failed:`, error);
+    return { ok: false, data: null };
+  }
+}
+async function apiPost(config, endpoint, body) {
+  try {
+    const response = await fetch(`${config.apiUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "X-API-Key": config.apiKey,
+        "X-Project-ID": config.projectId,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      console.error(`[site-kit/commerce] POST ${endpoint} failed: ${response.status}`);
+      return { ok: false, data: null };
+    }
+    return { ok: true, data: await response.json() };
+  } catch (error) {
+    if (isFrameworkSignal(error)) throw error;
+    console.error(`[site-kit/commerce] POST ${endpoint} failed:`, error);
+    return { ok: false, data: null };
+  }
+}
+function transformOffering(data) {
+  return {
+    id: data.id,
+    project_id: data.project_id,
+    type: data.type,
+    status: data.status,
+    name: data.name,
+    slug: data.slug,
+    description: data.description,
+    short_description: data.short_description,
+    long_description: data.long_description,
+    featured_image_url: data.featured_image_url,
+    gallery_images: data.gallery_image_urls || [],
+    price_type: data.price_type || "fixed",
+    price: data.price,
+    compare_at_price: data.compare_at_price,
+    currency: data.currency || "USD",
+    price_is_public: data.price_is_public ?? true,
+    billing_period: data.billing_period,
+    track_inventory: data.track_inventory,
+    inventory_count: data.inventory_count,
+    allow_backorder: data.allow_backorder,
+    duration_minutes: data.duration_minutes,
+    capacity: data.capacity,
+    location: data.location,
+    is_virtual: data.is_virtual,
+    virtual_meeting_url: data.virtual_meeting_url,
+    requires_booking: data.requires_booking,
+    booking_lead_time_hours: data.booking_lead_time_hours,
+    category: data.category,
+    category_id: data.category_id,
+    tags: data.tags || [],
+    seo_title: data.seo_title,
+    seo_description: data.seo_description,
+    features: data.features || [],
+    specifications: data.specifications || {},
+    schedules: data.schedules || [],
+    variants: data.variants || [],
+    created_at: data.created_at,
+    updated_at: data.updated_at
+  };
+}
+async function getProductPaths(config) {
+  const { ok, data } = await apiFetch(
+    config,
+    `/api/public/commerce/offerings?type=product&status=active&fields=slug`
+  );
+  if (!ok) console.error("[site-kit/commerce] getProductPaths failed \u2014 0 product pages will be prerendered");
+  if (!data?.offerings) return [];
+  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
+}
+async function getEventPaths(config) {
+  const { ok, data } = await apiFetch(
+    config,
+    `/api/public/commerce/offerings?type=event&status=active&fields=slug`
+  );
+  if (!ok) console.error("[site-kit/commerce] getEventPaths failed \u2014 0 event pages will be prerendered");
+  if (!data?.offerings) return [];
+  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
+}
+async function getOfferingPaths(config, type) {
+  let typeParam = "";
+  if (type) {
+    if (Array.isArray(type)) {
+      typeParam = `&type=${type.join(",")}`;
+    } else {
+      typeParam = `&type=${type}`;
+    }
+  }
+  const { ok, data } = await apiFetch(
+    config,
+    `/api/public/commerce/offerings?status=active&fields=slug${typeParam}`
+  );
+  if (!ok) console.error("[site-kit/commerce] getOfferingPaths failed \u2014 0 pages will be prerendered");
+  if (!data?.offerings) return [];
+  return data.offerings.map((item) => ({ params: { slug: item.slug } }));
+}
+async function getOfferingBySlug(config, slug) {
+  return (await getOfferingBySlugResult(config, slug)).data;
+}
+async function getOfferingBySlugResult(config, slug) {
+  const { ok, data } = await apiFetch(
+    config,
+    `/api/public/commerce/offerings/${slug}`
+  );
+  if (!data?.offering) return { ok, data: null };
+  return { ok: true, data: transformOffering(data.offering) };
+}
+async function getOfferings(config, options = {}) {
+  return (await getOfferingsResult(config, options)).data;
+}
+async function getOfferingsResult(config, options = {}) {
+  const params = new URLSearchParams();
+  params.set("status", options.status || "active");
+  if (options.type) {
+    if (Array.isArray(options.type)) {
+      params.set("type", options.type.join(","));
+    } else {
+      params.set("type", options.type);
+    }
+  }
+  if (options.category) {
+    params.set("category", options.category);
+  }
+  if (options.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  const { ok, data } = await apiFetch(
+    config,
+    `/api/public/commerce/offerings?${params.toString()}`
+  );
+  if (!data?.offerings) return { ok, data: [] };
+  return { ok: true, data: data.offerings.map(transformOffering) };
+}
+async function getUpcomingEvents(config, options = {}) {
+  return (await getUpcomingEventsResult(config, options)).data;
+}
+async function getUpcomingEventsResult(config, options = {}) {
+  const primary = await apiPost(
+    config,
+    "/api/public/commerce/events",
+    {
+      type: "event",
+      category: options.category,
+      limit: options.limit,
+      includePast: false
+    }
+  );
+  if (primary.ok && primary.data?.events) {
+    return { ok: true, data: primary.data.events.map(transformOffering) };
+  }
+  const params = new URLSearchParams();
+  params.set("type", "event");
+  params.set("status", "active");
+  params.set("upcoming", "true");
+  if (options.category) {
+    params.set("category", options.category);
+  }
+  if (options.limit) {
+    params.set("limit", options.limit.toString());
+  }
+  const legacy = await apiFetch(
+    config,
+    `/api/public/commerce/offerings?${params.toString()}`
+  );
+  if (legacy.ok && legacy.data?.offerings) {
+    return { ok: true, data: legacy.data.offerings.map(transformOffering) };
+  }
+  return { ok: primary.ok || legacy.ok, data: [] };
+}
+async function getNextEvent(config, category) {
+  return (await getNextEventResult(config, category)).data;
+}
+async function getNextEventResult(config, category) {
+  const { ok, data } = await getUpcomingEventsResult(config, { limit: 1, category });
+  return { ok, data: data[0] || null };
+}
+function generateOfferingMetadata(offering, siteUrl) {
+  if (!offering) return null;
+  const title = offering.seo_title || offering.name;
+  const description = offering.seo_description || offering.short_description || offering.description || "";
+  const images = offering.featured_image_url ? [offering.featured_image_url] : [];
+  const typeMap = {
+    product: "product",
+    service: "website",
+    event: "website",
+    class: "website",
+    subscription: "product"
+  };
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      images,
+      type: typeMap[offering.type] || "website",
+      url: `${siteUrl}/${offering.type}s/${offering.slug}`
+    }
+  };
+}
+function createServerConfig(apiUrl, apiKey, projectId) {
+  return { apiUrl, apiKey, projectId };
+}
+
+export { createServerConfig, generateOfferingMetadata, getEventPaths, getNextEvent, getNextEventResult, getOfferingBySlug, getOfferingBySlugResult, getOfferingPaths, getOfferings, getOfferingsResult, getProductPaths, getUpcomingEvents, getUpcomingEventsResult };

package/dist/chunk-GJWI74ZZ.js

@@ -0,0 +1,27 @@
+// src/shared/uuid.ts
+var HEX = Array.from(
+  { length: 256 },
+  (_, i) => (i + 256).toString(16).slice(1)
+);
+function bytesToUuid(b) {
+  return HEX[b[0]] + HEX[b[1]] + HEX[b[2]] + HEX[b[3]] + "-" + HEX[b[4]] + HEX[b[5]] + "-" + HEX[b[6]] + HEX[b[7]] + "-" + HEX[b[8]] + HEX[b[9]] + "-" + HEX[b[10]] + HEX[b[11]] + HEX[b[12]] + HEX[b[13]] + HEX[b[14]] + HEX[b[15]];
+}
+function uuid() {
+  const c = typeof crypto !== "undefined" ? crypto : void 0;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  if (c && typeof c.getRandomValues === "function") {
+    const bytes2 = c.getRandomValues(new Uint8Array(16));
+    bytes2[6] = bytes2[6] & 15 | 64;
+    bytes2[8] = bytes2[8] & 63 | 128;
+    return bytesToUuid(bytes2);
+  }
+  const bytes = new Array(16);
+  for (let i = 0; i < 16; i++) bytes[i] = Math.random() * 256 & 255;
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  return bytesToUuid(bytes);
+}
+
+export { uuid };

package/dist/chunk-GKGSXUVQ.js

@@ -0,0 +1,218 @@
+'use client';
+import { useState, useCallback, useRef } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/articles/ArticleFAQ.tsx
+var defaultStyles = {
+  section: {
+    margin: "3rem 0",
+    padding: 0
+  },
+  title: {
+    fontSize: "1.5rem",
+    fontWeight: 700,
+    color: "var(--sk-text-primary, #0f172a)",
+    marginBottom: "1.5rem",
+    display: "flex",
+    alignItems: "center",
+    gap: "0.5rem"
+  },
+  list: {
+    listStyle: "none",
+    margin: 0,
+    padding: 0,
+    display: "flex",
+    flexDirection: "column",
+    gap: "0.5rem"
+  },
+  item: {
+    borderRadius: "0.75rem",
+    border: "1px solid var(--sk-surface-border, #e2e8f0)",
+    background: "var(--sk-bg-elevated, #f8fafc)",
+    overflow: "hidden",
+    transition: "border-color 0.2s, box-shadow 0.2s"
+  },
+  itemOpen: {
+    borderColor: "color-mix(in srgb, var(--sk-primary, #2563eb) 40%, var(--sk-surface-border, #e2e8f0))",
+    boxShadow: "0 1px 3px rgba(0,0,0,0.06)"
+  },
+  question: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    width: "100%",
+    padding: "1rem 1.25rem",
+    background: "none",
+    border: "none",
+    cursor: "pointer",
+    textAlign: "left"
+  },
+  questionText: {
+    fontSize: "1rem",
+    fontWeight: 600,
+    color: "var(--sk-text-primary, #0f172a)",
+    paddingRight: "1rem"
+  },
+  icon: {
+    flexShrink: 0,
+    width: "1.25rem",
+    height: "1.25rem",
+    color: "var(--sk-primary, #2563eb)",
+    transition: "transform 0.2s"
+  },
+  answer: {
+    overflow: "hidden",
+    transition: "max-height 0.3s ease, opacity 0.2s ease"
+  },
+  answerInner: {
+    padding: "0 1.25rem 1.25rem",
+    fontSize: "0.9375rem",
+    lineHeight: 1.7,
+    color: "var(--sk-text-secondary, #475569)"
+  }
+};
+function PlusMinusIcon({ isOpen }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      style: {
+        ...defaultStyles.icon,
+        transform: isOpen ? "rotate(45deg)" : "rotate(0deg)"
+      },
+      children: [
+        /* @__PURE__ */ jsx("line", { x1: "10", y1: "4", x2: "10", y2: "16" }),
+        /* @__PURE__ */ jsx("line", { x1: "4", y1: "10", x2: "16", y2: "10" })
+      ]
+    }
+  );
+}
+function FAQItem({
+  item,
+  isOpen,
+  onToggle,
+  styles,
+  unstyled
+}) {
+  const answerRef = useRef(null);
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      className: styles?.item,
+      style: unstyled ? void 0 : {
+        ...defaultStyles.item,
+        ...isOpen ? defaultStyles.itemOpen : {}
+      },
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            className: styles?.question,
+            style: unstyled ? void 0 : defaultStyles.question,
+            onClick: onToggle,
+            "aria-expanded": isOpen,
+            type: "button",
+            children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: styles?.questionText,
+                  style: unstyled ? void 0 : defaultStyles.questionText,
+                  children: item.question
+                }
+              ),
+              /* @__PURE__ */ jsx("span", { className: styles?.icon, children: /* @__PURE__ */ jsx(PlusMinusIcon, { isOpen }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: answerRef,
+            className: styles?.answer,
+            style: unstyled ? void 0 : {
+              ...defaultStyles.answer,
+              maxHeight: isOpen ? `${(answerRef.current?.scrollHeight || 500) + 40}px` : "0",
+              opacity: isOpen ? 1 : 0
+            },
+            role: "region",
+            "aria-hidden": !isOpen,
+            children: /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: styles?.answerInner,
+                style: unstyled ? void 0 : defaultStyles.answerInner,
+                dangerouslySetInnerHTML: { __html: item.answer }
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+function ArticleFAQ({
+  items,
+  title = "Frequently Asked Questions",
+  allowMultiple = false,
+  styles,
+  unstyled = false
+}) {
+  const [openIndices, setOpenIndices] = useState(/* @__PURE__ */ new Set());
+  const toggle = useCallback((index) => {
+    setOpenIndices((prev) => {
+      const next = new Set(allowMultiple ? prev : []);
+      if (prev.has(index)) {
+        next.delete(index);
+      } else {
+        next.add(index);
+      }
+      return next;
+    });
+  }, [allowMultiple]);
+  if (!items || items.length === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: styles?.section,
+      style: unstyled ? void 0 : defaultStyles.section,
+      "aria-label": "Frequently Asked Questions",
+      children: [
+        /* @__PURE__ */ jsx(
+          "h2",
+          {
+            className: styles?.title,
+            style: unstyled ? void 0 : defaultStyles.title,
+            children: title
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "ul",
+          {
+            className: styles?.list,
+            style: unstyled ? void 0 : defaultStyles.list,
+            children: items.map((item, index) => /* @__PURE__ */ jsx(
+              FAQItem,
+              {
+                item,
+                isOpen: openIndices.has(index),
+                onToggle: () => toggle(index),
+                styles,
+                unstyled
+              },
+              index
+            ))
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { ArticleFAQ };

package/dist/chunk-GLHQ3LRO.js

@@ -0,0 +1,97 @@
+import { freshFetch } from './chunk-VX5CMNMM.js';
+import { LLM_GEO_CONTRACT_VERSION } from './chunk-4Y5FWDPM.js';
+import { withSiteParam } from './chunk-MJP63SSS.js';
+import { cache } from 'react';
+
+function getApiConfig() {
+  const apiUrl = typeof window !== "undefined" && window.__SITE_KIT_API_URL__ || process.env.SONOR_API_URL || "https://api.sonor.io";
+  const apiKey = typeof window !== "undefined" && window.__SITE_KIT_API_KEY__ || process.env.SONOR_API_KEY || "";
+  return { apiUrl, apiKey };
+}
+async function apiGet(endpoint, options) {
+  const { apiUrl, apiKey } = getApiConfig();
+  if (!apiKey) {
+    console.error("@sonordev/llms: No API key configured. Set SONOR_API_KEY.");
+    return null;
+  }
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey
+    };
+    const response = options?.fresh ? await freshFetch(`${apiUrl}${endpoint}`, { method: "GET", headers }) : await fetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      headers,
+      next: { revalidate: 3600 }
+      // Next.js fetch cache
+    });
+    if (!response.ok) {
+      console.error(`@sonordev/llms: API error: ${response.statusText}`);
+      return null;
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    console.error("@sonordev/llms: Network error:", error);
+    return null;
+  }
+}
+var getLLMsData = cache(async (projectId, site, fresh) => {
+  const data = await apiGet(withSiteParam(`/api/public/llms/data`, site), { fresh });
+  if (data?.meta && data.meta.contract_version != null && data.meta.contract_version !== LLM_GEO_CONTRACT_VERSION && typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+    console.warn(
+      `[site-kit/llms] API meta.contract_version (${data.meta.contract_version}) !== site-kit LLM_GEO_CONTRACT_VERSION (${LLM_GEO_CONTRACT_VERSION}).`
+    );
+  }
+  return data;
+});
+var getBusinessInfo = cache(async (projectId) => {
+  const result = await apiGet(`/api/public/llms/business`);
+  return result?.business || null;
+});
+var getServices = cache(async (projectId, site) => {
+  const result = await apiGet(withSiteParam(`/api/public/llms/services`, site));
+  return result?.services || [];
+});
+var getFAQItems = cache(async (projectId, limit, site) => {
+  const endpoint = limit ? `/api/public/llms/faq?limit=${limit}` : "/api/public/llms/faq";
+  const result = await apiGet(withSiteParam(endpoint, site));
+  return result?.faq || [];
+});
+var getPageSummaries = cache(async (projectId, limit, site) => {
+  const endpoint = limit ? `/api/public/llms/pages?limit=${limit}` : "/api/public/llms/pages";
+  const result = await apiGet(withSiteParam(endpoint, site));
+  return result?.pages || [];
+});
+async function getOptimizedLLMsTxt(options) {
+  const apiUrl = options?.apiUrl || typeof process !== "undefined" && process.env?.SONOR_API_URL || "https://api.sonor.io";
+  const apiKey = options?.apiKey || typeof process !== "undefined" && process.env?.SONOR_API_KEY || "";
+  if (!apiKey) {
+    console.error("@sonordev/llms: No API key configured for getOptimizedLLMsTxt");
+    return null;
+  }
+  const params = new URLSearchParams();
+  if (options?.full) params.set("full", "true");
+  if (options?.publicSummaryOnly) params.set("publicSummaryOnly", "true");
+  const qs = params.toString();
+  const endpoint = withSiteParam(`/api/public/llms/txt${qs ? `?${qs}` : ""}`, options?.site);
+  try {
+    const response = await freshFetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "text/plain",
+        "x-api-key": apiKey
+      }
+    });
+    if (!response.ok) {
+      console.error(`@sonordev/llms: Optimized txt API error: ${response.status} ${response.statusText}`);
+      return null;
+    }
+    return await response.text();
+  } catch (error) {
+    console.error("@sonordev/llms: Failed to fetch optimized llms.txt:", error);
+    return null;
+  }
+}
+
+export { getBusinessInfo, getFAQItems, getLLMsData, getOptimizedLLMsTxt, getPageSummaries, getServices };

package/dist/chunk-GW7GSBO7.js

@@ -0,0 +1,66 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+
+// src/images/ManagedFavicon.tsx
+function toAbsoluteFaviconUrl(url, apiBase) {
+  if (!url) return void 0;
+  if (url.startsWith("http://") || url.startsWith("https://")) return url;
+  const base = apiBase.replace(/\/$/, "");
+  return url.startsWith("/") ? `${base}${url}` : `${base}/${url}`;
+}
+async function fetchFaviconData(apiUrl, apiKey) {
+  try {
+    const res = await fetch(`${apiUrl}/public/images/slot/favicon`, {
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      next: { revalidate: 3600 }
+      // Cache 1hr – favicon rarely changes, allows static generation
+    });
+    if (!res.ok) {
+      console.warn("[ManagedFavicon] Failed to fetch:", res.status);
+      return null;
+    }
+    const data = await res.json();
+    if (data.image && !data.is_placeholder) {
+      const raw = data.image.public_url || data.image.external_url;
+      const public_url = toAbsoluteFaviconUrl(raw, apiUrl);
+      return {
+        public_url: public_url || void 0,
+        mime_type: data.image.file?.mime_type,
+        is_placeholder: false
+      };
+    }
+    return null;
+  } catch (err) {
+    console.error("[ManagedFavicon] Error fetching favicon:", err);
+    return null;
+  }
+}
+async function getManagedFaviconUrl(apiKey, apiUrl = process.env.SONOR_API_URL || "https://api.sonor.io") {
+  const key = apiKey ?? process.env.SONOR_API_KEY;
+  if (!key) return null;
+  const data = await fetchFaviconData(apiUrl, key);
+  return data?.public_url ?? null;
+}
+async function ManagedFavicon({
+  apiKey = process.env.SONOR_API_KEY,
+  apiUrl = process.env.SONOR_API_URL || "https://api.sonor.io",
+  fallback = "/favicon.ico",
+  themeColor = "#4bbf39"
+}) {
+  const faviconData = apiKey && apiUrl ? await fetchFaviconData(apiUrl, apiKey) : null;
+  const faviconUrl = faviconData?.public_url || fallback;
+  const mimeType = faviconData?.mime_type || "image/x-icon";
+  const isSvg = mimeType === "image/svg+xml" || faviconUrl.endsWith(".svg");
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    isSvg ? /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/svg+xml", href: faviconUrl }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "32x32", href: faviconUrl }),
+      /* @__PURE__ */ jsx("link", { rel: "icon", type: "image/png", sizes: "16x16", href: faviconUrl })
+    ] }),
+    /* @__PURE__ */ jsx("link", { rel: "apple-touch-icon", sizes: "180x180", href: faviconUrl }),
+    /* @__PURE__ */ jsx("meta", { name: "theme-color", content: themeColor })
+  ] });
+}
+
+export { ManagedFavicon, fetchFaviconData, getManagedFaviconUrl };