@duffcloudservices/cms 0.12.0 → 0.13.0

package/dist/index.js

@@ -1,11 +1,398 @@
-import './chunk-DAYLLSEE.js';
-import { resolvePageSeo, generateJsonLd, buildHeadTags } from './chunk-F3EIWEZD.js';
-export { AI_BOTS, absolutizeUrl, breadcrumbTrailFromRoute, buildBlogPosting, buildBreadcrumbList, buildFaqPage, buildGlobalGraph, buildHeadTags, buildLlmsTxt, buildReviewSchemaParts, buildRobotsTxt, buildSitemapXml, buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute, escapeJsonLd, filterRealFaq, filterRealReviews, findReviewItemsForPage, generateJsonLd, generateOpenGraphMeta, generateTwitterMeta, isRouteIndexable, renderHeadTags, resolvePageSeo, slugToTitle, spliceHeadHtml, stripManagedHeadTags } from './chunk-F3EIWEZD.js';
-import { shallowRef, ref, computed, onMounted, readonly, toValue, onUnmounted } from 'vue';
-import { useHead } from '@unhead/vue';
-import { isCdnAssetUrl, resolveResponsiveImage } from '@duffcloudservices/cms-core';
+import './chunk-A5F4C72F.js';
+import { resolvePageSeo, generateJsonLd, buildHeadTags } from './chunk-HVSF23P7.js';
+export { AI_BOTS, absolutizeUrl, breadcrumbTrailFromRoute, buildBlogPosting, buildBreadcrumbList, buildFaqPage, buildGlobalGraph, buildHeadTags, buildLlmsTxt, buildReviewSchemaParts, buildRobotsTxt, buildSeoHeadRouteMap, buildSitemapXml, buildVitePressSeoHead, createSeoTransformPageData, defaultRelativePathToRoute, escapeJsonLd, filterRealFaq, filterRealReviews, findReviewItemsForPage, generateJsonLd, generateOpenGraphMeta, generateTwitterMeta, installSeoHead, isRouteIndexable, normalizeSeoHeadPath, renderHeadTags, resolvePageSeo, slugToTitle, spliceHeadHtml, stripManagedHeadTags } from './chunk-HVSF23P7.js';
+import { shallowRef, getCurrentInstance, onMounted, onBeforeUnmount, ref, computed, readonly, toValue, onUnmounted } from 'vue';
+import { isCdnAssetUrl, resolveResponsiveImage, platformFetch, isPlatformFetchError } from '@duffcloudservices/cms-core';
 export { isCdnAssetUrl, resolveResponsiveImage } from '@duffcloudservices/cms-core';
+import { useHead } from '@unhead/vue';
 
+var CONVERSION_INTERACTION_TYPES = [
+  "booking",
+  "phone",
+  "email",
+  "form_submit"
+];
+function isConversionType(type) {
+  return CONVERSION_INTERACTION_TYPES.includes(type);
+}
+var CONVERSION_CAPTURE_VERSION = "2";
+var DEFAULT_BOOKING_HOSTS = [
+  "stridethera.com",
+  // KEPT — physical therapy
+  "momence.com",
+  // KEPT — gym / recovery
+  "vagaro.com",
+  // Just Posh
+  "acuityscheduling.com",
+  "booksy.com",
+  "calendly.com",
+  "fresha.com",
+  "janeapp.com",
+  "mindbodyonline.com",
+  "schedulicity.com",
+  "setmore.com",
+  "simplepractice.com",
+  "square.site",
+  "squareup.com"
+];
+var DEFAULT_SOCIAL_HOSTS = [
+  "facebook.com",
+  "instagram.com",
+  "linkedin.com",
+  "pinterest.com",
+  "threads.net",
+  "tiktok.com",
+  "x.com",
+  "youtube.com"
+];
+var LABEL_MAX_LENGTH = 120;
+var DEFAULT_BUFFER_LIMIT = 50;
+var DEDUPE_WINDOW_MS = 400;
+function hostMatches(host, patterns) {
+  const h = host.toLowerCase();
+  return patterns.some((p) => {
+    const needle = p.toLowerCase();
+    return h === needle || h.endsWith(`.${needle}`);
+  });
+}
+function sanitizeUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  const cut = trimmed.split("#")[0].split("?")[0];
+  return cut.slice(0, 300);
+}
+var CONTACT_SCHEMES = ["tel:", "sms:", "mailto:"];
+function hashTarget(value) {
+  let h = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    h ^= value.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+function hrefScheme(href, pageHost) {
+  const raw = href.trim();
+  if (!raw) return "";
+  const lower = raw.toLowerCase();
+  const contact = CONTACT_SCHEMES.find((s) => lower.startsWith(s));
+  if (contact) return contact;
+  if (lower.startsWith("#")) return "";
+  try {
+    return new URL(raw, `https://${pageHost || "localhost"}/`).protocol;
+  } catch {
+    return "";
+  }
+}
+function redactHref(href, pageHost) {
+  const raw = href.trim();
+  if (!raw) return { href: "", scheme: "", hash: "" };
+  const lower = raw.toLowerCase();
+  const contact = CONTACT_SCHEMES.find((s) => lower.startsWith(s));
+  if (contact) {
+    const target = raw.slice(contact.length).split("?")[0].trim().toLowerCase();
+    const normalized = contact === "mailto:" ? target : target.replace(/[^0-9+]/gu, "");
+    const hash = normalized ? hashTarget(normalized) : "";
+    return { href: `${contact}#${hash}`, scheme: contact, hash };
+  }
+  return { href: sanitizeUrl(raw), scheme: hrefScheme(raw, pageHost), hash: "" };
+}
+function isSubmitControl(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag !== "button" && tag !== "input") return false;
+  const type = (el.getAttribute("type") ?? "").toLowerCase();
+  if (type === "submit") return true;
+  if (type) return false;
+  return tag === "button" && !!el.closest("form");
+}
+function doNotTrackEnabled() {
+  if (typeof navigator === "undefined" && typeof window === "undefined") return false;
+  const nav = typeof navigator !== "undefined" ? navigator : void 0;
+  const win = typeof window !== "undefined" ? window : void 0;
+  const signal = nav?.doNotTrack ?? win?.doNotTrack ?? nav?.msDoNotTrack;
+  return signal === "1" || signal === "yes";
+}
+function labelFor(element) {
+  const aria = element.getAttribute("aria-label");
+  const source = aria && aria.trim() || (element.textContent ?? "").replace(/\s+/gu, " ").trim() || element.getAttribute("title") || element.getAttribute("href") || element.tagName.toLowerCase();
+  return source.slice(0, LABEL_MAX_LENGTH);
+}
+function classifyHref(href, opts) {
+  const raw = href.trim();
+  if (!raw) return "button";
+  const lower = raw.toLowerCase();
+  if (lower.startsWith("tel:") || lower.startsWith("sms:")) return "phone";
+  if (lower.startsWith("mailto:")) return "email";
+  if (lower.startsWith("#") || lower.startsWith("javascript:")) return "button";
+  let url;
+  try {
+    url = new URL(raw, `https://${opts.pageHost || "localhost"}/`);
+  } catch {
+    return "internal";
+  }
+  if (hostMatches(url.hostname, opts.bookingHosts)) return "booking";
+  const sameOrigin = !!opts.pageHost && url.hostname.toLowerCase() === opts.pageHost.toLowerCase();
+  if (sameOrigin && opts.bookingPaths.some((p) => url.pathname.startsWith(p))) {
+    return "booking";
+  }
+  if (hostMatches(url.hostname, opts.socialHosts)) return "social";
+  if (sameOrigin) return "internal";
+  if (url.protocol === "http:" || url.protocol === "https:") return "external";
+  return "external";
+}
+var registeredTrackers = /* @__PURE__ */ new Set();
+var boundDocuments = /* @__PURE__ */ new WeakSet();
+var warnedDoubleBind = false;
+function attachConversionSink(sink) {
+  let count = 0;
+  for (const tracker of registeredTrackers) {
+    tracker.attachSink(sink);
+    count += 1;
+  }
+  return count;
+}
+function createConversionTracker(options = {}) {
+  const eventName = options.eventName ?? "site_interaction";
+  const bookingHosts = [...DEFAULT_BOOKING_HOSTS, ...options.bookingHosts ?? []];
+  const socialHosts = [...DEFAULT_SOCIAL_HOSTS, ...options.socialHosts ?? []];
+  const bookingPaths = options.bookingPaths ?? [];
+  const bufferLimit = Math.max(0, options.bufferLimit ?? DEFAULT_BUFFER_LIMIT);
+  const requireTrusted = options.requireTrusted ?? false;
+  const captureFormSubmits = options.captureFormSubmits ?? true;
+  const respectDoNotTrack = options.respectDoNotTrack ?? true;
+  const force = options.force ?? false;
+  const mirrors = options.mirrors ?? [];
+  let sink = options.sink ?? null;
+  let buffer = [];
+  let listening = false;
+  let lastKey = "";
+  let lastAt = 0;
+  const doc = () => options.target ?? (typeof document !== "undefined" ? document : null);
+  function pageHost() {
+    return typeof window !== "undefined" ? window.location.hostname : "";
+  }
+  function pagePath() {
+    return typeof window !== "undefined" ? window.location.pathname : "";
+  }
+  function emit(event) {
+    for (const mirror of mirrors) {
+      try {
+        mirror(event);
+      } catch {
+      }
+    }
+    if (sink) {
+      try {
+        sink(event);
+      } catch {
+      }
+      return;
+    }
+    if (bufferLimit === 0) return;
+    buffer.push(event);
+    if (buffer.length > bufferLimit) buffer.shift();
+  }
+  function compose(actionable, interactionType, rawHref) {
+    const host = pageHost();
+    const { href, scheme, hash } = redactHref(rawHref, host);
+    let hrefHost = "";
+    if (href && !hash) {
+      try {
+        hrefHost = new URL(href, `https://${host || "localhost"}/`).hostname;
+      } catch {
+        hrefHost = "";
+      }
+    }
+    return {
+      name: eventName,
+      properties: {
+        interaction_type: interactionType,
+        is_conversion: isConversionType(interactionType) ? "true" : "false",
+        label: labelFor(actionable),
+        href,
+        href_scheme: scheme,
+        href_host: hrefHost,
+        href_hash: hash,
+        page_path: pagePath(),
+        host,
+        capture_version: CONVERSION_CAPTURE_VERSION
+      }
+    };
+  }
+  function build(element) {
+    const anchor = element.closest("a");
+    const actionable = anchor ?? element.closest("button");
+    if (!actionable) return null;
+    if (captureFormSubmits && !anchor && isSubmitControl(actionable)) return null;
+    const rawHref = anchor?.getAttribute("href") ?? "";
+    const interactionType = anchor ? classifyHref(rawHref, { pageHost: pageHost(), bookingHosts, bookingPaths, socialHosts }) : "button";
+    const resolved = anchor && !CONTACT_SCHEMES.some((s) => rawHref.trim().toLowerCase().startsWith(s)) ? anchor.href || rawHref : rawHref;
+    return compose(actionable, interactionType, resolved);
+  }
+  function buildSubmit(form) {
+    const control = form.querySelector('button[type="submit"], input[type="submit"]') ?? form.querySelector("button") ?? form;
+    return compose(control, "form_submit", "");
+  }
+  function emitDeduped(event) {
+    const key = `${event.properties.interaction_type}|${event.properties.href}|${event.properties.label}`;
+    const now = Date.now();
+    if (key === lastKey && now - lastAt < DEDUPE_WINDOW_MS) return null;
+    lastKey = key;
+    lastAt = now;
+    emit(event);
+    return event;
+  }
+  function capture(element) {
+    const event = build(element);
+    if (!event) return null;
+    return emitDeduped(event);
+  }
+  const onClick = (event) => {
+    if (requireTrusted && !event.isTrusted) return;
+    const target = event.target;
+    if (!target || !target.closest) return;
+    try {
+      capture(target);
+    } catch {
+    }
+  };
+  const onSubmit = (event) => {
+    if (requireTrusted && !event.isTrusted) return;
+    const form = event.target;
+    if (!form || !form.tagName) return;
+    try {
+      emitDeduped(buildSubmit(form));
+    } catch {
+    }
+  };
+  const tracker = {
+    start() {
+      if (listening) return;
+      const d = doc();
+      if (!d) return;
+      if (respectDoNotTrack && doNotTrackEnabled()) {
+        return;
+      }
+      if (boundDocuments.has(d) && !force) {
+        if (!warnedDoubleBind) {
+          warnedDoubleBind = true;
+          console.warn(
+            "[dcs-conversion] start() REFUSED: a delegated conversion listener is already bound to this document. Binding a second one counts every click twice \u2014 the defect class that put 52% duplicate page views in a live owner report (C-288). Since C-326 the tracker auto-installs with @duffcloudservices/cms, so a manual useConversionTracking() in App.vue is no longer needed; remove it, or pass { force: true } if you have genuinely torn the first one down."
+          );
+        }
+        return;
+      }
+      d.addEventListener("click", onClick, { capture: true });
+      if (captureFormSubmits) d.addEventListener("submit", onSubmit, { capture: true });
+      listening = true;
+      boundDocuments.add(d);
+      registeredTrackers.add(tracker);
+    },
+    stop() {
+      const d = doc();
+      if (d && listening) {
+        d.removeEventListener("click", onClick, { capture: true });
+        if (captureFormSubmits) d.removeEventListener("submit", onSubmit, { capture: true });
+        boundDocuments.delete(d);
+      }
+      listening = false;
+      buffer = [];
+      registeredTrackers.delete(tracker);
+    },
+    attachSink(next) {
+      sink = next;
+      const pending = buffer;
+      buffer = [];
+      for (const event of pending) {
+        try {
+          next(event);
+        } catch {
+        }
+      }
+    },
+    buffered() {
+      return [...buffer];
+    },
+    capture
+  };
+  return tracker;
+}
+function useConversionTracking(options = {}) {
+  const tracker = createConversionTracker(options);
+  if (getCurrentInstance()) {
+    onMounted(() => tracker.start());
+    onBeforeUnmount(() => tracker.stop());
+  } else {
+    tracker.start();
+  }
+  return tracker;
+}
+
+// src/conversionAutoInstall.ts
+var installed = null;
+function conversionWindow() {
+  return typeof window !== "undefined" ? window : null;
+}
+function conversionOptedOut() {
+  const w = conversionWindow();
+  if (w?.__dcsConversionOptOut === true) return true;
+  if (typeof document !== "undefined") {
+    const flag = document.documentElement?.getAttribute("data-dcs-analytics");
+    if (flag === "off" || flag === "false") return true;
+  }
+  return false;
+}
+function inFrame() {
+  const w = conversionWindow();
+  if (!w) return false;
+  try {
+    return w.parent !== w || w.top !== w.self;
+  } catch {
+    return true;
+  }
+}
+function gtagSink(event) {
+  const w = conversionWindow();
+  if (typeof w?.gtag !== "function") return;
+  w.gtag("event", event.name, { ...event.properties });
+}
+function installConversionCapture(options = {}) {
+  const skip = (reason) => ({
+    installed: false,
+    reason,
+    tracker: null
+  });
+  if (typeof document === "undefined") return skip("no-document");
+  const w = conversionWindow();
+  if (installed || w?.__dcsConversionInstalled === true) return skip("already-installed");
+  if (inFrame()) return skip("in-frame");
+  if ((options.respectDoNotTrack ?? true) && doNotTrackEnabled()) return skip("do-not-track");
+  if (conversionOptedOut()) return skip("opted-out");
+  const useGtag = options.gtag ?? true;
+  const tracker = createConversionTracker({
+    ...options,
+    sink: void 0,
+    mirrors: useGtag ? [gtagSink] : []
+  });
+  tracker.start();
+  installed = tracker;
+  if (w) {
+    w.__dcsConversionInstalled = true;
+    w.__dcsConversionAttach = (sink) => attachConversionSink(sink);
+  }
+  return { installed: true, reason: null, tracker };
+}
+function installedConversionTracker() {
+  return installed;
+}
+function resetConversionCapture() {
+  installed?.stop();
+  installed = null;
+  const w = conversionWindow();
+  if (w) {
+    delete w.__dcsConversionInstalled;
+    delete w.__dcsConversionAttach;
+  }
+}
 var fetchCache = /* @__PURE__ */ new Map();
 function getBuildTimeContent() {
   try {
@@ -102,7 +489,7 @@ function useTextContent(config) {
     error.value = null;
     try {
       const url = `${apiBaseUrl}/api/v1/pages/${pageSlug}/text`;
-      const response = await fetch(url, {
+      const response = await platformFetch(url, {
         headers: {
           Accept: "application/json"
         }
@@ -163,6 +550,15 @@ function getBuildTimeSeo() {
   }
   return void 0;
 }
+var HEAD_OVERRIDE_REFUSED_MESSAGE = "[dcs-seo] applyHead() was called WITH AN ARGUMENT and the argument was IGNORED. .dcs/seo.yaml is the only writer of title/description/keywords/canonical/OG/Twitter/JSON-LD (head-authority contract, C-356). A hardcoded value here overwrites the owner-approved baked head for Google and every human while non-JS crawlers keep receiving the approved one. Move the value into .dcs/seo.yaml and call applyHead() with no arguments.";
+function reportHeadOverrideRefused(pageSlug, refused) {
+  const keys = refused && typeof refused === "object" ? Object.keys(refused).join(", ") : String(refused);
+  console.error(
+    `${HEAD_OVERRIDE_REFUSED_MESSAGE}
+  page slug: ${pageSlug}
+  ignored keys: ${keys}`
+  );
+}
 function useSEO(pageSlug, pagePath) {
   const seoConfig = getBuildTimeSeo();
   const hasBuildTimeSeo = seoConfig !== void 0;
@@ -175,14 +571,11 @@ function useSEO(pageSlug, pagePath) {
   function getCanonical() {
     return config.value.canonical;
   }
-  function applyHead(overrides) {
-    const { title, meta, link, script } = buildHeadTags(pageSlug, pagePath, seoConfig, {
-      title: overrides?.title,
-      description: overrides?.description,
-      keywords: overrides?.keywords,
-      schemas: overrides?.schemas,
-      meta: overrides?.meta
-    });
+  function applyHeadImpl(...refused) {
+    if (refused.length > 0 && refused[0] !== void 0 && refused[0] !== null) {
+      reportHeadOverrideRefused(pageSlug, refused[0]);
+    }
+    const { title, meta, link, script } = buildHeadTags(pageSlug, pagePath, seoConfig);
     useHead({
       title,
       meta,
@@ -190,6 +583,7 @@ function useSEO(pageSlug, pagePath) {
       script
     });
   }
+  const applyHead = applyHeadImpl;
   return {
     config,
     applyHead,
@@ -233,7 +627,7 @@ function useReleaseNotes(version, options = {}) {
     error.value = null;
     try {
       const url = `${apiBaseUrl}/api/v1/release-notes/${version}`;
-      const response = await fetch(url, {
+      const response = await platformFetch(url, {
         headers: {
           Accept: "application/json"
         }
@@ -313,7 +707,7 @@ function useSiteVersion(options = {}) {
     isLoading.value = true;
     try {
       const url = `${apiBaseUrl}/api/v1/release-notes/latest`;
-      const response = await fetch(url, {
+      const response = await platformFetch(url, {
         headers: {
           Accept: "application/json"
         }
@@ -540,13 +934,16 @@ async function fetchSiteVisitorSession(options = {}) {
   const base = apiBase(options.apiBaseUrl);
   let response;
   try {
-    response = await fetch(`${base}/site-auth/session`, {
+    response = await platformFetch(`${base}/site-auth/session`, {
       method: "GET",
       credentials: "include",
       headers: { Accept: "application/json" },
       signal: options.signal
     });
-  } catch {
+  } catch (e) {
+    if (isPlatformFetchError(e)) {
+      return { visitor: null, authenticated: false, apiUnreachable: true };
+    }
     return SIGNED_OUT;
   }
   if (!response.ok) {
@@ -565,12 +962,14 @@ function useSiteVisitorSession(options = {}) {
   const { fetchOnMount = true, ...fetchOptions } = options;
   const visitor = ref(null);
   const isLoading = ref(false);
+  const apiUnreachable = ref(false);
   const isAuthenticated = computed(() => visitor.value !== null);
   async function refresh() {
     isLoading.value = true;
     try {
       const result = await fetchSiteVisitorSession(fetchOptions);
       visitor.value = result.visitor;
+      apiUnreachable.value = result.apiUnreachable === true;
     } finally {
       isLoading.value = false;
     }
@@ -580,9 +979,10 @@ function useSiteVisitorSession(options = {}) {
       void refresh();
     });
   }
-  return { visitor, isAuthenticated, isLoading, refresh };
+  return { visitor, isAuthenticated, isLoading, apiUnreachable, refresh };
 }
+installConversionCapture();
 
-export { createSiteSEO, fetchSiteVisitorSession, useMediaCarousel, useReleaseNotes, useResponsiveImage, useReviewContent, useSEO, useSiteVersion, useSiteVisitorSession, useTextContent };
+export { CONVERSION_CAPTURE_VERSION, CONVERSION_INTERACTION_TYPES, DEFAULT_BOOKING_HOSTS, DEFAULT_SOCIAL_HOSTS, attachConversionSink, classifyHref, conversionOptedOut, createConversionTracker, createSiteSEO, doNotTrackEnabled, fetchSiteVisitorSession, hashTarget, hrefScheme, inFrame, installConversionCapture, installedConversionTracker, isConversionType, isSubmitControl, redactHref, resetConversionCapture, useConversionTracking, useMediaCarousel, useReleaseNotes, useResponsiveImage, useReviewContent, useSEO, useSiteVersion, useSiteVisitorSession, useTextContent };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map