@uptrademedia/site-kit 1.0.5 → 1.0.8

package/dist/seo/index.mjs

@@ -1,9 +1,200 @@
 export { SitemapSync } from '../chunk-WPSRS352.mjs';
-export { generateSitemap, getRedirect, getRobotsDirective, isIndexable } from '../chunk-GQ6ZOU2N.mjs';
-import { getSEOPageData, getABTest, recordABImpression, getSchemaMarkups, getFAQData, getInternalLinks, getContentBlock, getManagedScripts } from '../chunk-7H6I3ECV.mjs';
-import '../chunk-NYKRE2FL.mjs';
+export { generateSitemap, getRedirect, getRobotsDirective, isIndexable } from '../chunk-JGQPAXTL.mjs';
+import { getSchemaMarkups, getEntityEnhancedSchema, getFAQData, getInternalLinks, getContentBlock, getEntities, getManagedScripts } from '../chunk-FQVGK746.mjs';
+import '../chunk-4XPGGLVP.mjs';
+import { cache } from 'react';
+import 'server-only';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
+function getSecureApiConfig() {
+  const apiUrl = process.env.UPTRADE_API_URL || process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  const apiKey = process.env.UPTRADE_API_KEY || "";
+  const projectId = process.env.UPTRADE_PROJECT_ID || "";
+  if (!apiKey) {
+    throw new Error("@uptrade/seo: UPTRADE_API_KEY environment variable is required for server-side SEO functions");
+  }
+  return { apiUrl, apiKey, projectId };
+}
+async function secureApiPost(endpoint, body = {}) {
+  const { apiUrl, apiKey } = getSecureApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(body),
+      next: { revalidate: 60 }
+      // Cache for 60 seconds
+    });
+    if (!response.ok) {
+      console.error(`@uptrade/seo: API error ${response.status}: ${response.statusText}`);
+      return null;
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("@uptrade/seo: Network error:", error);
+    return null;
+  }
+}
+var getSEOPageData = cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/page", {
+    projectId,
+    path
+  });
+  return result?.page || null;
+});
+var getSchemaMarkups2 = cache(async (projectId, path, options) => {
+  const result = await secureApiPost("/api/public/seo/schemas", {
+    projectId,
+    path,
+    includeTypes: options?.includeTypes,
+    excludeTypes: options?.excludeTypes
+  });
+  return result?.schemas || [];
+});
+var getFAQData2 = cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/faq", {
+    projectId,
+    path
+  });
+  return result?.faq || null;
+});
+var getInternalLinks2 = cache(async (projectId, sourcePath, options) => {
+  const result = await secureApiPost("/api/public/seo/internal-links", {
+    projectId,
+    sourcePath,
+    position: options?.position,
+    limit: options?.limit
+  });
+  return result?.links || [];
+});
+var getContentBlock2 = cache(async (projectId, path, section) => {
+  const result = await secureApiPost("/api/public/seo/content", {
+    projectId,
+    path,
+    section
+  });
+  return result?.content || null;
+});
+var getABTest = cache(async (projectId, path, field) => {
+  const result = await secureApiPost("/api/public/seo/ab-test", {
+    projectId,
+    path,
+    field
+  });
+  return result?.test || null;
+});
+async function recordABImpression(testId, variant, sessionId) {
+  await secureApiPost("/api/public/seo/ab-impression", { testId, variant, sessionId });
+}
+var getRedirectData = cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/redirect", {
+    projectId,
+    path
+  });
+  return result?.redirect || null;
+});
+var getManagedScripts2 = cache(async (projectId, position, currentPath) => {
+  const result = await secureApiPost("/api/public/seo/scripts", {
+    projectId,
+    position,
+    currentPath
+  });
+  return result?.scripts || [];
+});
+var getRobotsData = cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/page", {
+    projectId,
+    path
+  });
+  return result?.page?.managed_robots || null;
+});
+var getSitemapEntries = cache(async (projectId, options) => {
+  const result = await secureApiPost("/api/public/seo/sitemap", {
+    projectId,
+    publishedOnly: options?.publishedOnly
+  });
+  return result?.entries || [];
+});
+async function registerSitemap(entries) {
+  const { apiUrl, apiKey, projectId } = getSecureApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}/api/public/seo/register-sitemap`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({ projectId, entries })
+    });
+    if (!response.ok) {
+      console.error(`@uptrade/seo: Sitemap registration failed: ${response.statusText}`);
+      return { success: false, created: 0, updated: 0 };
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("@uptrade/seo: Sitemap registration error:", error);
+    return { success: false, created: 0, updated: 0 };
+  }
+}
+function getSignalApiConfig() {
+  const apiUrl = process.env.SIGNAL_API_URL || process.env.NEXT_PUBLIC_SIGNAL_API_URL || "https://signal.uptrademedia.com";
+  const apiKey = process.env.UPTRADE_API_KEY || "";
+  return { apiUrl, apiKey };
+}
+async function signalApiGet(endpoint) {
+  const { apiUrl, apiKey } = getSignalApiConfig();
+  if (!apiKey) {
+    return null;
+  }
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      next: { revalidate: 300 }
+      // Cache for 5 minutes
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const result = await response.json();
+    return result?.data || result;
+  } catch (error) {
+    console.error("@uptrade/seo: Signal API error:", error);
+    return null;
+  }
+}
+var getEntities2 = cache(async (projectId, options) => {
+  let endpoint = `/skills/seo/entities/${projectId}`;
+  if (options?.type) {
+    endpoint += `?type=${options.type}`;
+  }
+  const result = await signalApiGet(endpoint);
+  return result || [];
+});
+var getPrimaryEntity = cache(async (projectId) => {
+  return signalApiGet(`/skills/seo/entities/${projectId}/primary`);
+});
+var getEntityEnhancedSchema2 = cache(async (projectId, pagePath) => {
+  const result = await signalApiGet(
+    `/skills/seo/schema/${projectId}/entity-enhanced?pagePath=${encodeURIComponent(pagePath)}`
+  );
+  return result?.schemas || [];
+});
+var getVisibilityScore = cache(async (projectId, pagePath) => {
+  const result = await signalApiGet(`/skills/seo/visibility/${projectId}`);
+  if (!result) return null;
+  return result.find((s) => s.page_path === pagePath) || null;
+});
+var getVisibilitySummary = cache(async (projectId) => {
+  return signalApiGet(`/skills/seo/visibility/${projectId}/summary`);
+});
+
 // src/seo/getManagedMetadata.ts
 async function getManagedMetadata(options) {
   const { projectId, path, fallback = {}, overrides = {} } = options;
@@ -25,8 +216,8 @@ async function getManagedMetadata(options) {
   } else if (fallback.title) {
     metadata.title = fallback.title;
   }
-  if (pageData.managed_description) {
-    metadata.description = pageData.managed_description;
+  if (pageData.managed_meta_description || pageData.managed_description) {
+    metadata.description = pageData.managed_meta_description || pageData.managed_description;
   } else if (fallback.description) {
     metadata.description = fallback.description;
   }
@@ -45,7 +236,7 @@ async function getManagedMetadata(options) {
     };
   }
   const ogTitle = pageData.managed_og_title || pageData.managed_title;
-  const ogDescription = pageData.managed_og_description || pageData.managed_description;
+  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 = {
@@ -115,21 +306,47 @@ async function getManagedMetadataWithAB(options) {
   }
   return metadata;
 }
+var DEFAULT_SPEAKABLE_SELECTORS = [
+  "h1",
+  '[data-speakable="true"]',
+  ".page-summary",
+  ".key-points",
+  '.aeo-block[data-speakable="true"]'
+];
 async function ManagedSchema({
   projectId,
   path,
   additionalSchemas = [],
   includeTypes,
-  excludeTypes
+  excludeTypes,
+  speakable,
+  pageType = "WebPage",
+  pageName,
+  pageUrl,
+  includeEntityGraph = false
 }) {
   const schemas = await getSchemaMarkups(projectId, path, {
     includeTypes,
     excludeTypes
   });
+  let entitySchemas = [];
+  if (includeEntityGraph) {
+    entitySchemas = await getEntityEnhancedSchema(projectId, path);
+  }
   const allSchemas = [
+    ...entitySchemas,
     ...schemas.map((s) => s.schema_json),
     ...additionalSchemas
   ];
+  if (speakable && pageName && pageUrl) {
+    const speakableSchema = createSpeakableWebPageSchema(
+      pageType,
+      pageName,
+      pageUrl,
+      typeof speakable === "object" ? speakable : void 0
+    );
+    allSchemas.push(speakableSchema);
+  }
   if (allSchemas.length === 0) {
     return null;
   }
@@ -158,6 +375,25 @@ function createSchema(type, data) {
     ...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) => {
@@ -297,13 +533,46 @@ async function ManagedInternalLinks({
 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({
   projectId,
   path,
   section,
   fallback,
   className,
-  components = {}
+  components = {},
+  injectEntityAnnotations: shouldInjectEntities = false
 }) {
   const block = await getContentBlock(projectId, path, section);
   if (!block) {
@@ -312,18 +581,32 @@ async function ManagedContent({
     }
     return null;
   }
+  let entities = [];
+  if (shouldInjectEntities) {
+    try {
+      entities = await getEntities(projectId);
+    } catch (err) {
+      console.warn("@uptrade/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: block.content }
+          dangerouslySetInnerHTML: { __html: processHtml(block.content) }
         }
       );
     case "markdown":
-      const htmlContent = renderMarkdown(block.content);
+      const htmlContent = processHtml(renderMarkdown(block.content));
       return /* @__PURE__ */ jsx(
         "div",
         {
@@ -405,7 +688,114 @@ async function ManagedNoScripts({
   }
   return /* @__PURE__ */ jsx("noscript", { dangerouslySetInnerHTML: { __html: noscriptContent } });
 }
+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 { ManagedContent, ManagedFAQ, ManagedInternalLinks, ManagedNoScripts, ManagedSchema, ManagedScripts, createBreadcrumbSchema, createSchema, ManagedSchema as default, getABVariant, getManagedContentData, getManagedMetadata, getManagedMetadataWithAB };
+export { LocationPageContent, ManagedContent, ManagedFAQ, ManagedInternalLinks, ManagedNoScripts, ManagedSchema, ManagedScripts, createBreadcrumbSchema, createSchema, ManagedSchema as default, getABTest, getABVariant, getContentBlock2 as getContentBlock, getEntities2 as getEntities, getEntityEnhancedSchema2 as getEntityEnhancedSchema, getFAQData2 as getFAQData, getInternalLinks2 as getInternalLinks, getLocationSection, getManagedContentData, getManagedMetadata, getManagedMetadataWithAB, getManagedScripts2 as getManagedScripts, getPrimaryEntity, getRedirectData, getRobotsData, getSEOPageData, getSchemaMarkups2 as getSchemaMarkups, getSitemapEntries, getVisibilityScore, getVisibilitySummary, recordABImpression, registerSitemap };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map