@sonordev/site-kit 1.2.7

package/dist/seo/index.mjs

@@ -0,0 +1,773 @@
+export { ManagedNoScripts, ManagedScripts } from '../chunk-MV3QN7PW.mjs';
+export { SitemapSync } from '../chunk-PKN27UMH.mjs';
+export { generateSitemap, getRedirect, getRobotsDirective, isIndexable } from '../chunk-7RYCHO6D.mjs';
+import { getSEOPageData, ensureMetadata, getABTest, recordABImpression, getSchemaMarkups, getEntityEnhancedSchema, getFAQData, getInternalLinks, getContentBlock, getEntities } from '../chunk-K23A4G76.mjs';
+export { getABTest, getContentBlock, getEntities, getEntityEnhancedSchema, getFAQData, getInternalLinks, getManagedScripts, getPrimaryEntity, getRedirectData, getRobotsData, getSEOPageData, getSchemaMarkups, getSitemapEntries, getVisibilityScore, getVisibilitySummary, recordABImpression, registerSitemap } from '../chunk-K23A4G76.mjs';
+import '../chunk-4XPGGLVP.mjs';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { cache } from 'react';
+
+// 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
+    };
+  }
+  let signalData = null;
+  if (!pageData.managed_title && !pageData.managed_meta_description && !pageData.managed_description) {
+    try {
+      signalData = await ensureMetadata(path);
+    } catch {
+    }
+  }
+  if (pageData.managed_title) {
+    metadata.title = pageData.managed_title;
+  } else if (signalData?.managed_title) {
+    metadata.title = signalData.managed_title;
+    metadata._source = "signal";
+  } else if (fallback.title) {
+    metadata.title = fallback.title;
+  }
+  if (pageData.managed_meta_description || pageData.managed_description) {
+    metadata.description = pageData.managed_meta_description || pageData.managed_description;
+  } else if (signalData?.managed_meta_description) {
+    metadata.description = signalData.managed_meta_description;
+    metadata._source = "signal";
+  } else if (fallback.description) {
+    metadata.description = fallback.description;
+  }
+  if (pageData.managed_keywords?.length) {
+    metadata.keywords = pageData.managed_keywords;
+  } else if (signalData?.managed_keywords?.length) {
+    metadata.keywords = signalData.managed_keywords;
+    metadata._source = "signal";
+  } 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 ogTitle = pageData.managed_og_title || pageData.managed_title;
+  const ogDescription = pageData.managed_og_description || pageData.managed_meta_description || pageData.managed_description;
+  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/withManagedMetadata.ts
+function withManagedMetadata(path, pageMetadata) {
+  return async function generateMetadata(args, parent) {
+    const resolvedPath = typeof path === "function" ? await path(args) : path;
+    const managed = await getManagedMetadata({ path: resolvedPath });
+    if (!pageMetadata) {
+      return managed;
+    }
+    const pageSpecific = await pageMetadata(args, parent);
+    return {
+      ...managed,
+      ...pageSpecific,
+      openGraph: {
+        ...managed.openGraph,
+        ...pageSpecific.openGraph
+      },
+      twitter: {
+        ...managed.twitter,
+        ...pageSpecific.twitter
+      }
+    };
+  };
+}
+var DEFAULT_SPEAKABLE_SELECTORS = [
+  "h1",
+  '[data-speakable="true"]',
+  ".page-summary",
+  ".key-points",
+  '.aeo-block[data-speakable="true"]'
+];
+async function ManagedSchema({
+  path,
+  additionalSchemas = [],
+  includeTypes,
+  excludeTypes,
+  speakable,
+  pageType = "WebPage",
+  pageName,
+  pageUrl,
+  includeEntityGraph = true
+}) {
+  const schemas = await getSchemaMarkups(path, {
+    includeTypes,
+    excludeTypes
+  });
+  const pageData = await getSEOPageData(path);
+  let entitySchemas = [];
+  if (includeEntityGraph) {
+    try {
+      entitySchemas = await getEntityEnhancedSchema(path);
+    } catch {
+    }
+  }
+  const page = pageData?.page;
+  const siteUrl = pageData?.project?.site_url || "";
+  const allSchemas = [
+    ...entitySchemas,
+    ...schemas.map((s) => s.schema_json),
+    // Include auto-generated schema from Signal meta optimization
+    ...page?.managed_schema ? [page.managed_schema] : [],
+    ...additionalSchemas
+  ];
+  const hasBreadcrumb = allSchemas.some(
+    (s) => s && typeof s === "object" && s["@type"] === "BreadcrumbList"
+  );
+  if (!hasBreadcrumb && path !== "/" && siteUrl) {
+    allSchemas.push(createBreadcrumbSchema(siteUrl, path));
+  }
+  if (speakable && pageName && pageUrl) {
+    const speakableSchema = createSpeakableWebPageSchema(
+      pageType,
+      pageName,
+      pageUrl,
+      typeof speakable === "object" ? speakable : void 0
+    );
+    allSchemas.push(speakableSchema);
+  }
+  if (allSchemas.length === 0 && !includeEntityGraph) {
+    try {
+      const fallbackSchemas = await getEntityEnhancedSchema(path);
+      allSchemas.push(...fallbackSchemas);
+    } catch {
+    }
+  }
+  if (allSchemas.length === 0) {
+    return null;
+  }
+  const schemaContent = allSchemas.length === 1 ? allSchemas[0] : {
+    "@context": "https://schema.org",
+    "@graph": allSchemas.filter((s) => s && typeof s === "object").map((s) => {
+      const { "@context": _, ...rest } = s;
+      return rest;
+    })
+  };
+  const finalSchema = allSchemas.length === 1 ? { "@context": "https://schema.org", ...schemaContent } : schemaContent;
+  return /* @__PURE__ */ jsx(
+    "script",
+    {
+      type: "application/ld+json",
+      async: true,
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify(finalSchema, null, 0)
+      }
+    }
+  );
+}
+async function LLMSchema({
+  path
+}) {
+  const { page: pageData } = await getSEOPageData(path);
+  if (!pageData?.managed_llm_schema) {
+    return null;
+  }
+  const llmSchema = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    ...pageData.managed_llm_schema,
+    // Add AI-specific metadata hints
+    additionalType: "https://uptrade.ai/ns/LLMOptimizedContent"
+  };
+  return /* @__PURE__ */ jsx(
+    "script",
+    {
+      type: "application/ld+json",
+      "data-llm-optimized": "true",
+      async: true,
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify(llmSchema, null, 0)
+      }
+    }
+  );
+}
+function createSchema(type, data) {
+  return {
+    "@context": "https://schema.org",
+    "@type": type,
+    ...data
+  };
+}
+function createSpeakableWebPageSchema(type, name, url, speakable) {
+  const speakableSpec = {
+    "@type": "SpeakableSpecification"
+  };
+  if (speakable?.cssSelector?.length) {
+    speakableSpec.cssSelector = speakable.cssSelector;
+  } else if (speakable?.xpath?.length) {
+    speakableSpec.xpath = speakable.xpath;
+  } else {
+    speakableSpec.cssSelector = DEFAULT_SPEAKABLE_SELECTORS;
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": type,
+    name,
+    url,
+    speakable: speakableSpec
+  };
+}
+function createBreadcrumbSchema(baseUrl, path, labels) {
+  const segments = path.split("/").filter(Boolean);
+  const items = segments.map((segment, index) => {
+    const itemPath = "/" + segments.slice(0, index + 1).join("/");
+    const label = labels?.[segment] || segment.replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+    return {
+      "@type": "ListItem",
+      position: index + 1,
+      name: label,
+      item: `${baseUrl}${itemPath}`
+    };
+  });
+  items.unshift({
+    "@type": "ListItem",
+    position: 0,
+    name: "Home",
+    item: baseUrl
+  });
+  items.forEach((item, index) => {
+    item.position = index + 1;
+  });
+  return createSchema("BreadcrumbList", {
+    itemListElement: items
+  });
+}
+var faqStyles = `
+.uptrade-faq-items {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+}
+.uptrade-faq-item {
+  border-bottom: 1px solid rgba(0,0,0,0.08);
+}
+.uptrade-faq-item:first-child {
+  border-top: 1px solid rgba(0,0,0,0.08);
+}
+.uptrade-faq-item summary {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  cursor: pointer;
+  padding: 1.25rem 0;
+  font-weight: 600;
+  font-size: 1.05rem;
+  line-height: 1.5;
+  color: inherit;
+  list-style: none;
+  user-select: none;
+  transition: color 0.15s ease;
+}
+.uptrade-faq-item summary:hover {
+  opacity: 0.8;
+}
+.uptrade-faq-item summary::-webkit-details-marker {
+  display: none;
+}
+.uptrade-faq-item summary::marker {
+  display: none;
+  content: '';
+}
+.uptrade-faq-chevron {
+  flex-shrink: 0;
+  width: 1.25rem;
+  height: 1.25rem;
+  margin-left: 1rem;
+  transition: transform 0.2s ease;
+  opacity: 0.5;
+}
+.uptrade-faq-item[open] .uptrade-faq-chevron {
+  transform: rotate(180deg);
+}
+.uptrade-faq-answer {
+  padding: 0 0 1.25rem 0;
+  color: rgba(0,0,0,0.6);
+  line-height: 1.75;
+  font-size: 0.95rem;
+}
+.uptrade-faq-answer p {
+  margin: 0 0 0.75rem 0;
+}
+.uptrade-faq-answer p:last-child {
+  margin-bottom: 0;
+}
+.uptrade-faq-answer ul, .uptrade-faq-answer ol {
+  padding-left: 1.5rem;
+  margin: 0.5rem 0;
+}
+.uptrade-faq-answer li {
+  margin-bottom: 0.25rem;
+}
+.uptrade-faq-answer a {
+  color: inherit;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+.uptrade-faq-title {
+  font-size: 1.75rem;
+  font-weight: 700;
+  margin-bottom: 0.5rem;
+}
+.uptrade-faq-description {
+  color: rgba(0,0,0,0.6);
+  margin-bottom: 2rem;
+  font-size: 1rem;
+  line-height: 1.6;
+}
+`;
+function ChevronDown() {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      className: "uptrade-faq-chevron",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx("polyline", { points: "6 9 12 15 18 9" })
+    }
+  );
+}
+function DefaultFAQItem({ item, index }) {
+  return /* @__PURE__ */ jsxs("details", { className: "uptrade-faq-item", children: [
+    /* @__PURE__ */ jsxs("summary", { children: [
+      /* @__PURE__ */ jsx("span", { children: item.question }),
+      /* @__PURE__ */ jsx(ChevronDown, {})
+    ] }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "uptrade-faq-answer",
+        dangerouslySetInnerHTML: { __html: item.answer }
+      }
+    )
+  ] }, item.id);
+}
+function generateFAQSchema(items) {
+  return createSchema("FAQPage", {
+    mainEntity: items.filter((item) => item.is_visible).map((item) => ({
+      "@type": "Question",
+      name: item.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: item.answer
+      }
+    }))
+  });
+}
+async function ManagedFAQ({
+  path,
+  className,
+  renderItem,
+  includeSchema = true,
+  showTitle = true
+}) {
+  const faqData = await getFAQData(path);
+  if (!faqData || !faqData.items?.length) {
+    return null;
+  }
+  const visibleItems = faqData.items.filter((item) => item.is_visible);
+  if (visibleItems.length === 0) {
+    return null;
+  }
+  visibleItems.sort((a, b) => a.order - b.order);
+  const shouldIncludeSchema = includeSchema && faqData.include_schema;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    shouldIncludeSchema && /* @__PURE__ */ jsx(
+      "script",
+      {
+        type: "application/ld+json",
+        dangerouslySetInnerHTML: {
+          __html: JSON.stringify(generateFAQSchema(visibleItems), null, 0)
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: faqStyles } }),
+    /* @__PURE__ */ jsxs("div", { className: className || "uptrade-faq", children: [
+      showTitle && faqData.title && /* @__PURE__ */ jsx("h2", { className: "uptrade-faq-title", children: faqData.title }),
+      faqData.description && /* @__PURE__ */ jsx("p", { className: "uptrade-faq-description", children: faqData.description }),
+      /* @__PURE__ */ jsx("div", { className: "uptrade-faq-items", children: visibleItems.map(
+        (item, index) => renderItem ? renderItem(item, index) : /* @__PURE__ */ jsx(DefaultFAQItem, { item, index }, item.id)
+      ) })
+    ] })
+  ] });
+}
+function DefaultLinkRenderer({ link }) {
+  const href = link.target_url || link.target_path;
+  return /* @__PURE__ */ jsx(
+    "a",
+    {
+      href,
+      className: "uptrade-internal-link",
+      children: link.anchor_text
+    },
+    link.id
+  );
+}
+async function ManagedInternalLinks({
+  path,
+  position = "bottom",
+  limit = 5,
+  className,
+  renderLink
+}) {
+  const links = await getInternalLinks(path, { position, limit });
+  if (!links.length) {
+    return null;
+  }
+  const containerClass = className || `uptrade-internal-links uptrade-internal-links--${position}`;
+  if (position === "inline") {
+    return /* @__PURE__ */ jsx("span", { className: containerClass, children: links.map(
+      (link) => renderLink ? renderLink(link) : /* @__PURE__ */ jsx(DefaultLinkRenderer, { link }, link.id)
+    ) });
+  }
+  if (position === "sidebar") {
+    return /* @__PURE__ */ jsxs("aside", { className: containerClass, children: [
+      /* @__PURE__ */ jsx("h4", { className: "uptrade-internal-links-title", children: "Related Pages" }),
+      /* @__PURE__ */ jsx("ul", { className: "uptrade-internal-links-list", children: links.map((link) => /* @__PURE__ */ jsx("li", { children: renderLink ? renderLink(link) : /* @__PURE__ */ jsx(DefaultLinkRenderer, { link }) }, link.id)) })
+    ] });
+  }
+  if (position === "related") {
+    return /* @__PURE__ */ jsxs("nav", { className: containerClass, "aria-label": "Related content", children: [
+      /* @__PURE__ */ jsx("h3", { className: "uptrade-internal-links-title", children: "You May Also Like" }),
+      /* @__PURE__ */ jsx("div", { className: "uptrade-internal-links-grid", children: links.map((link) => /* @__PURE__ */ jsxs("div", { className: "uptrade-internal-link-card", children: [
+        renderLink ? renderLink(link) : /* @__PURE__ */ jsx(DefaultLinkRenderer, { link }),
+        link.context && /* @__PURE__ */ jsx("p", { className: "uptrade-internal-link-context", children: link.context })
+      ] }, link.id)) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: containerClass, children: [
+    /* @__PURE__ */ jsx("h4", { className: "uptrade-internal-links-title", children: "Related Articles" }),
+    /* @__PURE__ */ jsx("ul", { className: "uptrade-internal-links-list", children: links.map((link) => /* @__PURE__ */ jsx("li", { children: renderLink ? renderLink(link) : /* @__PURE__ */ jsx(DefaultLinkRenderer, { link }) }, link.id)) })
+  ] });
+}
+function renderMarkdown(content) {
+  return content.replace(/^### (.*$)/gim, "<h3>$1</h3>").replace(/^## (.*$)/gim, "<h2>$1</h2>").replace(/^# (.*$)/gim, "<h1>$1</h1>").replace(/\*\*(.*)\*\*/gim, "<strong>$1</strong>").replace(/\*(.*)\*/gim, "<em>$1</em>").replace(/\[(.*?)\]\((.*?)\)/gim, '<a href="$2">$1</a>').replace(/\n\n/gim, "</p><p>").replace(/^(.+)$/gim, "<p>$1</p>");
+}
+function injectEntityAnnotations(html, entities) {
+  if (!entities.length) return html;
+  let annotatedHtml = html;
+  const sortedEntities = [...entities].sort((a, b) => b.name.length - a.name.length);
+  for (const entity of sortedEntities) {
+    if (entity.name.length < 3) continue;
+    const regex = new RegExp(
+      `(?<![\\w-])(?<!data-sonor-entity=")${escapeRegExp(entity.name)}(?![\\w-])`,
+      "gi"
+    );
+    const schemaType = getSchemaTypeForEntity(entity.entity_type);
+    annotatedHtml = annotatedHtml.replace(regex, (match) => {
+      return `<span class="aeo-entity aeo-entity-${entity.entity_type}" data-sonor-entity="${entity.id}" data-sonor-entity-type="${entity.entity_type}" data-sonor-entity-name="${entity.name}" itemscope itemtype="https://schema.org/${schemaType}"><span itemprop="name">${match}</span></span>`;
+    });
+  }
+  return annotatedHtml;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getSchemaTypeForEntity(entityType) {
+  const typeMap = {
+    organization: "Organization",
+    person: "Person",
+    service: "Service",
+    product: "Product",
+    location: "Place",
+    concept: "Thing",
+    credential: "EducationalOccupationalCredential"
+  };
+  return typeMap[entityType] || "Thing";
+}
+async function ManagedContent({
+  path,
+  section,
+  fallback,
+  className,
+  components = {},
+  injectEntityAnnotations: shouldInjectEntities = false
+}) {
+  const block = await getContentBlock(path, section);
+  if (!block) {
+    if (fallback) {
+      return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+    }
+    return null;
+  }
+  let entities = [];
+  if (shouldInjectEntities) {
+    try {
+      entities = await getEntities();
+    } catch (err) {
+      console.warn("@sonordev/seo: Failed to fetch entities for annotation:", err);
+    }
+  }
+  const containerClass = className || `uptrade-content uptrade-content--${section}`;
+  const processHtml = (html) => {
+    if (shouldInjectEntities && entities.length > 0) {
+      return injectEntityAnnotations(html, entities);
+    }
+    return html;
+  };
+  switch (block.content_type) {
+    case "html":
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: containerClass,
+          dangerouslySetInnerHTML: { __html: processHtml(block.content) }
+        }
+      );
+    case "markdown":
+      const htmlContent = processHtml(renderMarkdown(block.content));
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: containerClass,
+          dangerouslySetInnerHTML: { __html: htmlContent }
+        }
+      );
+    case "json":
+      const jsonData = typeof block.content === "string" ? JSON.parse(block.content) : block.content;
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: containerClass,
+          "data-content": JSON.stringify(jsonData),
+          children: [
+            jsonData.title && /* @__PURE__ */ jsx("h2", { children: jsonData.title }),
+            jsonData.subtitle && /* @__PURE__ */ jsx("p", { className: "subtitle", children: jsonData.subtitle }),
+            jsonData.content && /* @__PURE__ */ jsx("div", { dangerouslySetInnerHTML: { __html: jsonData.content } }),
+            jsonData.items && /* @__PURE__ */ jsx("ul", { children: jsonData.items.map((item, index) => /* @__PURE__ */ jsx("li", { children: typeof item === "string" ? item : item.text }, index)) })
+          ]
+        }
+      );
+    case "react":
+      const componentData = typeof block.content === "string" ? JSON.parse(block.content) : block.content;
+      const componentName = componentData.component;
+      const componentProps = componentData.props || {};
+      const Component = components[componentName];
+      if (!Component) {
+        console.warn(`@sonordev/seo: Component "${componentName}" not found in components map`);
+        return fallback ? /* @__PURE__ */ jsx(Fragment, { children: fallback }) : null;
+      }
+      return /* @__PURE__ */ jsx("div", { className: containerClass, children: /* @__PURE__ */ jsx(Component, { ...componentProps }) });
+    default:
+      console.warn(`@sonordev/seo: Unknown content type "${block.content_type}"`);
+      return fallback ? /* @__PURE__ */ jsx(Fragment, { children: fallback }) : null;
+  }
+}
+async function getManagedContentData(path, section) {
+  return getContentBlock(path, section);
+}
+function getApiConfig() {
+  const apiUrl = process.env.UPTRADE_API_URL || process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  return { apiUrl };
+}
+var getLocationSection = cache(async (projectId, path, section) => {
+  const { apiUrl } = getApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}/api/public/seo/location-content`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        project_id: projectId,
+        path,
+        section
+      }),
+      next: { revalidate: 3600 }
+      // Cache for 1 hour
+    });
+    if (!response.ok) {
+      console.error(`LocationPageContent: Failed to fetch section "${section}" for path "${path}"`);
+      return null;
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("LocationPageContent: API error:", error);
+    return null;
+  }
+});
+function HeroRenderer({ data, className }) {
+  return /* @__PURE__ */ jsxs("section", { className: className || "location-hero", children: [
+    /* @__PURE__ */ jsx("h1", { children: data.title }),
+    data.subtitle && /* @__PURE__ */ jsx("p", { className: "subtitle", children: data.subtitle }),
+    data.stats && /* @__PURE__ */ jsx("div", { className: "stats-grid", children: data.stats.map((stat, i) => /* @__PURE__ */ jsxs("div", { className: "stat", children: [
+      /* @__PURE__ */ jsx("span", { className: "stat-value", children: stat.value }),
+      /* @__PURE__ */ jsx("span", { className: "stat-label", children: stat.label })
+    ] }, i)) }),
+    data.cta_text && data.cta_href && /* @__PURE__ */ jsx("a", { href: data.cta_href, className: "cta-button", children: data.cta_text })
+  ] });
+}
+function TextRenderer({ data, className }) {
+  if (data.html) {
+    return /* @__PURE__ */ jsx(
+      "section",
+      {
+        className: className || "location-text",
+        dangerouslySetInnerHTML: { __html: data.html }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs("section", { className: className || "location-text", children: [
+    data.heading && /* @__PURE__ */ jsx("h2", { children: data.heading }),
+    data.paragraphs.map((p, i) => /* @__PURE__ */ jsx("p", { children: p }, i))
+  ] });
+}
+function ServicesGridRenderer({ data, className }) {
+  return /* @__PURE__ */ jsx("section", { className: className || "location-services-grid", children: /* @__PURE__ */ jsx("div", { className: "services-list", children: data.services.map((service, i) => /* @__PURE__ */ jsxs("a", { href: service.href, className: "service-card", children: [
+    service.icon && /* @__PURE__ */ jsx("span", { className: "service-icon", children: service.icon }),
+    /* @__PURE__ */ jsx("h3", { children: service.title }),
+    /* @__PURE__ */ jsx("p", { children: service.description })
+  ] }, i)) }) });
+}
+function DefaultRenderer({ data, className }) {
+  if (process.env.NODE_ENV === "development") {
+    return /* @__PURE__ */ jsx("section", { className, children: /* @__PURE__ */ jsx("pre", { style: { fontSize: "12px", background: "#f0f0f0", padding: "1rem" }, children: JSON.stringify(data, null, 2) }) });
+  }
+  if (typeof data.content === "string") {
+    return /* @__PURE__ */ jsx(
+      "section",
+      {
+        className,
+        dangerouslySetInnerHTML: { __html: data.content }
+      }
+    );
+  }
+  return null;
+}
+async function LocationPageContent({
+  projectId,
+  path,
+  section,
+  fallback = null,
+  className,
+  render
+}) {
+  const data = await getLocationSection(projectId, path, section);
+  if (!data) {
+    return fallback;
+  }
+  if (render) {
+    return /* @__PURE__ */ jsx(Fragment, { children: render(data) });
+  }
+  switch (data.type) {
+    case "hero":
+      return /* @__PURE__ */ jsx(HeroRenderer, { data: data.content, className });
+    case "text":
+    case "intro":
+    case "about":
+    case "about_location":
+      return /* @__PURE__ */ jsx(TextRenderer, { data: data.content, className });
+    case "services_grid":
+    case "services":
+      return /* @__PURE__ */ jsx(ServicesGridRenderer, { data: data.content, className });
+    default:
+      return /* @__PURE__ */ jsx(DefaultRenderer, { data, className });
+  }
+}
+
+export { LLMSchema, LocationPageContent, ManagedContent, ManagedFAQ, ManagedInternalLinks, ManagedSchema, createBreadcrumbSchema, createSchema, getABVariant, getLocationSection, getManagedContentData, getManagedMetadata, getManagedMetadataWithAB, withManagedMetadata };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map