@otl-core/cms-utils 1.0.0 → 1.0.4

package/dist/index.cjs

@@ -0,0 +1,1062 @@
+'use strict';
+
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+
+// src/abn-resolver.utils.ts
+function selectVariant(bucket, variants) {
+  if (variants.length === 0) {
+    throw new Error("selectVariant: variants array must not be empty");
+  }
+  const totalWeight = variants.reduce((sum, v) => sum + v.weight, 0);
+  let cumulative = 0;
+  for (const variant of variants) {
+    cumulative += variant.weight / totalWeight;
+    if (bucket < cumulative) {
+      return variant.id;
+    }
+  }
+  return variants[variants.length - 1].id;
+}
+function isMultivariateContent(content) {
+  return content.multivariate === true && Array.isArray(content.variants);
+}
+function resolvePageVariant(content, bucket) {
+  const variantId = selectVariant(bucket, content.variants);
+  const selectedVariant = content.variants.find((v) => v.id === variantId);
+  if (!selectedVariant) {
+    return {
+      sections: content.variants[0].sections,
+      variantId: content.variants[0].id
+    };
+  }
+  return { sections: selectedVariant.sections, variantId };
+}
+function resolveBlogPostVariant(content, bucket) {
+  if (!content.multivariate || !Array.isArray(content.variants)) return;
+  const variants = content.variants;
+  const variantConfigs = variants.map((v) => ({
+    id: String(v.id),
+    weight: Number(v.weight)
+  }));
+  const selectedId = selectVariant(bucket, variantConfigs);
+  const selectedVariant = variants.find((v) => v.id === selectedId);
+  if (selectedVariant) {
+    content.blocks = selectedVariant.blocks;
+  } else if (variants.length > 0) {
+    content.blocks = variants[0].blocks;
+  }
+  delete content.multivariate;
+  delete content.variants;
+}
+function resolveFormVariantsInSections(sections, bucket) {
+  if (!Array.isArray(sections)) return sections;
+  return sections.map((section) => {
+    if (!isRecord(section)) return section;
+    const config = section.config;
+    if (!isRecord(config)) return section;
+    const children = config.children;
+    if (!Array.isArray(children)) return section;
+    const resolvedChildren = children.map(
+      (block) => resolveBlockVariant(block, bucket)
+    );
+    return {
+      ...section,
+      config: {
+        ...config,
+        children: resolvedChildren
+      }
+    };
+  });
+}
+function resolveBlockVariant(block, bucket) {
+  if (!isRecord(block)) return block;
+  const blockType = block.type;
+  if (blockType === "form") {
+    const data = block.data;
+    if (!isRecord(data) || data.multivariate !== true) return block;
+    const variants = data.variants;
+    if (!Array.isArray(variants) || variants.length === 0) return block;
+    const variantConfigs = variants.filter(isRecord).map((v) => ({
+      id: String(v.id),
+      weight: Number(v.weight)
+    }));
+    const selectedId = selectVariant(bucket, variantConfigs);
+    const selectedVariant = variants.find(
+      (v) => isRecord(v) && v.id === selectedId
+    );
+    if (!selectedVariant || !isRecord(selectedVariant)) return block;
+    return {
+      ...block,
+      data: {
+        definition: data.definition,
+        document: selectedVariant.document
+      }
+    };
+  }
+  const config = block.config;
+  if (!isRecord(config)) return block;
+  const childKey = Array.isArray(config.children) ? "children" : Array.isArray(config.child) ? "child" : null;
+  if (!childKey) return block;
+  const children = config[childKey];
+  const resolvedChildren = children.map(
+    (child) => resolveBlockVariant(child, bucket)
+  );
+  return {
+    ...block,
+    config: {
+      ...config,
+      [childKey]: resolvedChildren
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/category.utils.ts
+function buildCategoryTree(categories) {
+  const categoryMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  categories.forEach((category) => {
+    categoryMap.set(category.id, { ...category, children: [] });
+  });
+  categories.forEach((category) => {
+    const node = categoryMap.get(category.id);
+    if (!node) return;
+    if (category.parent_id) {
+      const parent = categoryMap.get(category.parent_id);
+      if (parent) {
+        parent.children.push(node);
+      } else {
+        roots.push(node);
+      }
+    } else {
+      roots.push(node);
+    }
+  });
+  const sortByOrder = (a, b) => a.sort_order - b.sort_order;
+  roots.sort(sortByOrder);
+  categoryMap.forEach((node) => {
+    node.children.sort(sortByOrder);
+  });
+  return roots;
+}
+function flattenCategoryTree(tree) {
+  const result = [];
+  const flatten = (nodes) => {
+    nodes.forEach((node) => {
+      const { children, ...category } = node;
+      result.push(category);
+      if (children.length > 0) {
+        flatten(children);
+      }
+    });
+  };
+  flatten(tree);
+  return result;
+}
+function getCategoryPath(categoryId, categories, locale) {
+  const categoryMap = /* @__PURE__ */ new Map();
+  categories.forEach((cat) => categoryMap.set(cat.id, cat));
+  const path = [];
+  let currentId = categoryId;
+  while (currentId) {
+    const category = categoryMap.get(currentId);
+    if (!category) break;
+    path.unshift(category);
+    currentId = category.parent_id;
+  }
+  return path;
+}
+function getCategoryName(category, locale, fallbackLocale = "en") {
+  if (typeof category.name === "string") {
+    return category.name;
+  }
+  return category.name[locale] || category.name[fallbackLocale] || Object.values(category.name)[0] || "Untitled";
+}
+function getCategorySlug(category, locale, fallbackLocale = "en") {
+  if (typeof category.slug === "string") {
+    return category.slug;
+  }
+  return category.slug[locale] || category.slug[fallbackLocale] || Object.values(category.slug)[0] || "";
+}
+function isAncestor(ancestorId, descendantId, categories) {
+  const categoryMap = /* @__PURE__ */ new Map();
+  categories.forEach((cat) => categoryMap.set(cat.id, cat));
+  let currentId = descendantId;
+  while (currentId) {
+    const category = categoryMap.get(currentId);
+    if (!category) break;
+    if (category.parent_id === ancestorId) {
+      return true;
+    }
+    currentId = category.parent_id;
+  }
+  return false;
+}
+function getDescendants(categoryId, categories) {
+  const descendants = [];
+  const findChildren = (parentId) => {
+    const children = categories.filter((cat) => cat.parent_id === parentId);
+    children.forEach((child) => {
+      descendants.push(child);
+      findChildren(child.id);
+    });
+  };
+  findChildren(categoryId);
+  return descendants;
+}
+function findCategoryBySlug(slug, locale, categories) {
+  return categories.find((cat) => {
+    const categorySlug = typeof cat.slug === "string" ? cat.slug : cat.slug[locale];
+    return categorySlug === slug;
+  });
+}
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+
+// src/responsive.utils.ts
+function normalizeResponsiveValue(value) {
+  if (!value) return {};
+  if (typeof value === "object" && value !== null && "base" in value) {
+    return value;
+  }
+  return { base: value };
+}
+function isResponsiveConfig(value) {
+  return typeof value === "object" && value !== null && "base" in value && !Array.isArray(value);
+}
+function getBreakpointValue(value, breakpoint) {
+  if (!isResponsiveConfig(value)) {
+    return value;
+  }
+  return value[breakpoint] ?? value.base;
+}
+function getDefinedBreakpoints(value) {
+  if (!isResponsiveConfig(value)) {
+    return ["base"];
+  }
+  const breakpoints = ["base"];
+  if (value.sm !== void 0) breakpoints.push("sm");
+  if (value.md !== void 0) breakpoints.push("md");
+  if (value.lg !== void 0) breakpoints.push("lg");
+  if (value.xl !== void 0) breakpoints.push("xl");
+  if (value["2xl"] !== void 0) breakpoints.push("2xl");
+  return breakpoints;
+}
+function toResponsiveConfig(fields) {
+  const config = { base: fields.base };
+  if (fields.sm !== void 0) config.sm = fields.sm;
+  if (fields.md !== void 0) config.md = fields.md;
+  if (fields.lg !== void 0) config.lg = fields.lg;
+  if (fields.xl !== void 0) config.xl = fields.xl;
+  if (fields["2xl"] !== void 0) config["2xl"] = fields["2xl"];
+  return config;
+}
+function fromResponsiveConfig(value) {
+  if (!isResponsiveConfig(value)) {
+    return { base: value };
+  }
+  return {
+    base: value.base,
+    sm: value.sm,
+    md: value.md,
+    lg: value.lg,
+    xl: value.xl,
+    "2xl": value["2xl"]
+  };
+}
+
+// src/css.utils.ts
+function minifyCSS(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~()[\]])\s*/g, "$1").replace(/:\s+/g, ":").replace(/;}/g, "}").replace(/:0px/g, ":0").replace(/:0em/g, ":0").replace(/:0rem/g, ":0").trim();
+}
+function resolveColorToCSS(colorRef, target) {
+  if (!colorRef) return void 0;
+  if (typeof colorRef !== "object") return void 0;
+  const resolvedTarget = target ?? (colorRef.type !== "custom" ? colorRef.target : void 0) ?? "background";
+  if (colorRef.type === "custom") {
+    if (typeof colorRef.value === "string") {
+      return resolvedTarget === "foreground" ? void 0 : colorRef.value;
+    }
+    return resolvedTarget === "foreground" ? colorRef.value.foreground : colorRef.value.background;
+  } else if (colorRef.type === "theme") {
+    return resolvedTarget === "foreground" ? `var(--${colorRef.value}-foreground)` : `var(--${colorRef.value})`;
+  } else if (colorRef.type === "variable") {
+    return resolvedTarget === "foreground" ? `var(--${colorRef.value}-foreground)` : `var(--${colorRef.value})`;
+  }
+  return void 0;
+}
+function resolveColorsToCSS(colorRefs) {
+  const resolved = {};
+  for (const key in colorRefs) {
+    const colorRef = colorRefs[key];
+    if (colorRef) {
+      const color = resolveColorToCSS(colorRef);
+      if (color) {
+        resolved[key] = color;
+      }
+    }
+  }
+  return resolved;
+}
+function resolveBorderToCSS(borderConfig) {
+  if (!borderConfig) return void 0;
+  const result = {};
+  const resolveSide = (side, defaultWidth, defaultStyle, defaultColor) => {
+    const width = side?.width || defaultWidth;
+    const style = side?.style || defaultStyle;
+    const color = side?.color || defaultColor;
+    if (!width || !style || !color) return void 0;
+    const resolvedColor = resolveColorToCSS(color);
+    if (!resolvedColor) return void 0;
+    return `${width} ${style} ${resolvedColor}`;
+  };
+  const hasIndividualSides = borderConfig.top || borderConfig.right || borderConfig.bottom || borderConfig.left;
+  if (hasIndividualSides) {
+    const topBorder = resolveSide(
+      borderConfig.top,
+      borderConfig.width,
+      borderConfig.style,
+      borderConfig.color
+    );
+    if (topBorder) result.borderTop = topBorder;
+    const rightBorder = resolveSide(
+      borderConfig.right,
+      borderConfig.width,
+      borderConfig.style,
+      borderConfig.color
+    );
+    if (rightBorder) result.borderRight = rightBorder;
+    const bottomBorder = resolveSide(
+      borderConfig.bottom,
+      borderConfig.width,
+      borderConfig.style,
+      borderConfig.color
+    );
+    if (bottomBorder) result.borderBottom = bottomBorder;
+    const leftBorder = resolveSide(
+      borderConfig.left,
+      borderConfig.width,
+      borderConfig.style,
+      borderConfig.color
+    );
+    if (leftBorder) result.borderLeft = leftBorder;
+  } else if (borderConfig.width && borderConfig.style && borderConfig.color) {
+    const color = resolveColorToCSS(borderConfig.color);
+    if (color) {
+      result.border = `${borderConfig.width} ${borderConfig.style} ${color}`;
+    }
+  }
+  if (borderConfig.radius) {
+    result.borderRadius = borderConfig.radius;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function normalizeResponsiveValue2(value) {
+  if (!value) return {};
+  if (isResponsiveConfig(value)) {
+    return {
+      base: value.base,
+      sm: value.sm,
+      md: value.md,
+      lg: value.lg,
+      xl: value.xl
+    };
+  }
+  return { base: value };
+}
+var BREAKPOINTS = [
+  { key: "Sm", minWidth: "640px" },
+  { key: "Md", minWidth: "768px" },
+  { key: "Lg", minWidth: "1024px" },
+  { key: "Xl", minWidth: "1280px" }
+];
+function generateResponsiveSpacingCSS(className, config) {
+  const css = [];
+  const targetClass = `.${className}`;
+  const normalizedBorder = normalizeResponsiveValue2(config.border);
+  const normalizedMargin = normalizeResponsiveValue2(config.margin);
+  const normalizedPadding = normalizeResponsiveValue2(config.padding);
+  const normalizedGap = normalizeResponsiveValue2(config.gap);
+  const normalizedShadow = normalizeResponsiveValue2(config.shadow);
+  const border = {
+    base: normalizedBorder.base,
+    sm: normalizedBorder.sm,
+    md: normalizedBorder.md,
+    lg: normalizedBorder.lg,
+    xl: normalizedBorder.xl
+  };
+  const margin = {
+    base: normalizedMargin.base,
+    sm: normalizedMargin.sm,
+    md: normalizedMargin.md,
+    lg: normalizedMargin.lg,
+    xl: normalizedMargin.xl
+  };
+  const padding = {
+    base: normalizedPadding.base,
+    sm: normalizedPadding.sm,
+    md: normalizedPadding.md,
+    lg: normalizedPadding.lg,
+    xl: normalizedPadding.xl
+  };
+  const gap = {
+    base: normalizedGap.base,
+    sm: normalizedGap.sm,
+    md: normalizedGap.md,
+    lg: normalizedGap.lg,
+    xl: normalizedGap.xl
+  };
+  const shadow = {
+    base: normalizedShadow.base,
+    sm: normalizedShadow.sm,
+    md: normalizedShadow.md,
+    lg: normalizedShadow.lg,
+    xl: normalizedShadow.xl
+  };
+  const shadowToCSS = (s) => {
+    const parts = [s.offsetX, s.offsetY, s.blurRadius, s.spreadRadius, s.color];
+    return s.inset ? `inset ${parts.join(" ")}` : parts.join(" ");
+  };
+  const baseStyles = [];
+  if (border.base) {
+    const resolvedBorder = resolveBorderToCSS(border.base);
+    if (resolvedBorder) {
+      Object.entries(resolvedBorder).forEach(([prop, value]) => {
+        if (value) {
+          const cssProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+          baseStyles.push(`${cssProp}:${value}`);
+        }
+      });
+    }
+  }
+  if (margin.base) {
+    baseStyles.push(`margin:${margin.base}`);
+  }
+  if (padding.base) {
+    baseStyles.push(`padding:${padding.base}`);
+  }
+  if (gap.base) {
+    baseStyles.push(`gap:${gap.base}`);
+  }
+  if (shadow.base) {
+    baseStyles.push(`box-shadow:${shadowToCSS(shadow.base)}`);
+  }
+  if (baseStyles.length > 0) {
+    css.push(`${targetClass}{${baseStyles.join(";")}}`);
+  }
+  BREAKPOINTS.forEach(({ key, minWidth }) => {
+    const bpKey = key.toLowerCase();
+    const borderBp = border[bpKey];
+    const marginBp = margin[bpKey];
+    const paddingBp = padding[bpKey];
+    const gapBp = gap[bpKey];
+    const shadowBp = shadow[bpKey];
+    if (borderBp || marginBp || paddingBp || gapBp || shadowBp) {
+      const styles = [];
+      if (borderBp) {
+        const resolvedBorderBp = resolveBorderToCSS(borderBp);
+        if (resolvedBorderBp) {
+          Object.entries(resolvedBorderBp).forEach(([prop, value]) => {
+            if (value) {
+              const cssProp = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+              styles.push(`${cssProp}:${value}`);
+            }
+          });
+        }
+      }
+      if (marginBp) {
+        styles.push(`margin:${marginBp}`);
+      }
+      if (paddingBp) {
+        styles.push(`padding:${paddingBp}`);
+      }
+      if (gapBp) {
+        styles.push(`gap:${gapBp}`);
+      }
+      if (shadowBp) {
+        styles.push(`box-shadow:${shadowToCSS(shadowBp)}`);
+      }
+      if (styles.length > 0) {
+        css.push(
+          `@media(min-width:${minWidth}){${targetClass}{${styles.join(";")}}}`
+        );
+      }
+    }
+  });
+  return css.length > 0 ? minifyCSS(css.join("")) : null;
+}
+function hasAnyMargin(config) {
+  if (config.margin) {
+    if (isResponsiveConfig(config.margin)) {
+      return !!(config.margin.base || config.margin.sm || config.margin.md || config.margin.lg || config.margin.xl);
+    }
+    return true;
+  }
+  return false;
+}
+function getAnimationTimingFunction(timing = "ease-in-out") {
+  switch (timing) {
+    case "ease":
+      return "ease";
+    case "ease-in":
+      return "ease-in";
+    case "ease-out":
+      return "ease-out";
+    case "ease-in-out":
+      return "ease-in-out";
+    case "linear":
+      return "linear";
+    case "spring":
+      return "cubic-bezier(0.68,-0.55,0.265,1.55)";
+    default:
+      return "ease-in-out";
+  }
+}
+
+// src/localization.utils.ts
+function getLocalizedString(value, options) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  const preferredLocale = options?.preferredLocale || options?.defaultLocale || "en";
+  if (preferredLocale in value && value[preferredLocale]) {
+    return value[preferredLocale];
+  }
+  if (options?.defaultLocale && options.defaultLocale in value && value[options.defaultLocale]) {
+    return value[options.defaultLocale];
+  }
+  if ("en" in value && value.en) {
+    return value.en;
+  }
+  if (options?.supportedLocales) {
+    for (const locale of options.supportedLocales) {
+      if (locale in value && value[locale]) {
+        return value[locale];
+      }
+    }
+  }
+  const keys = Object.keys(value);
+  if (keys.length > 0 && value[keys[0]]) {
+    return value[keys[0]];
+  }
+  return "";
+}
+function getAvailableLocales(value) {
+  if (typeof value === "string") return [];
+  return Object.keys(value).filter((key) => value[key]);
+}
+function isLocalizedString(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function detectLocale(defaultLocale = "en", supportedLocales = ["en"]) {
+  const glob = globalThis;
+  if (typeof glob.window === "undefined") {
+    return defaultLocale;
+  }
+  const urlParams = new URLSearchParams(glob.window.location.search);
+  const urlLang = urlParams.get("lang");
+  if (urlLang && supportedLocales.includes(urlLang)) {
+    return urlLang;
+  }
+  const pathSegments = glob.window.location.pathname.split("/").filter(Boolean);
+  if (pathSegments[0] && supportedLocales.includes(pathSegments[0])) {
+    return pathSegments[0];
+  }
+  if (typeof glob.navigator !== "undefined") {
+    const browserLang = glob.navigator.language.split("-")[0];
+    if (supportedLocales.includes(browserLang)) {
+      return browserLang;
+    }
+  }
+  return defaultLocale;
+}
+function formatLocaleForHtml(locale) {
+  const localeMap = {
+    en: "en-US",
+    de: "de-DE",
+    fr: "fr-FR",
+    es: "es-ES",
+    it: "it-IT",
+    pt: "pt-PT",
+    nl: "nl-NL",
+    pl: "pl-PL"
+  };
+  return localeMap[locale] || locale;
+}
+
+// src/schedule-resolver.utils.ts
+function isContentVisible(publishAt, expiresAt, now) {
+  const currentTime = now || /* @__PURE__ */ new Date();
+  if (publishAt) {
+    const publishDate = new Date(publishAt);
+    if (currentTime < publishDate) return false;
+  }
+  if (expiresAt) {
+    const expiryDate = new Date(expiresAt);
+    if (currentTime >= expiryDate) return false;
+  }
+  return true;
+}
+function filterScheduledContent(items, now) {
+  return items.filter(
+    (item) => isContentVisible(item.publish_at, item.expires_at, now)
+  );
+}
+
+// src/style.utils.ts
+function getResponsiveBase(value) {
+  if (!value) return void 0;
+  if (isResponsiveConfig(value)) {
+    return value.base;
+  }
+  return value;
+}
+function borderToStyle(border) {
+  if (!border) return "";
+  const borderValue = getResponsiveBase(border);
+  if (!borderValue) return "";
+  const width = borderValue.width || "1px";
+  const style = borderValue.style || "solid";
+  const color = borderValue.color || "currentColor";
+  return `${width} ${style} ${color}`;
+}
+function formatShadow(shadow) {
+  if (!shadow) return "";
+  const { offsetX, offsetY, blurRadius, spreadRadius, color } = shadow;
+  return `${offsetX} ${offsetY} ${blurRadius} ${spreadRadius} ${color}`;
+}
+function paddingToClass(padding) {
+  if (!padding) return "";
+  const paddingMap = {
+    none: "p-0",
+    sm: "p-4",
+    normal: "p-8",
+    lg: "p-12",
+    xl: "p-16"
+  };
+  return paddingMap[padding] || paddingMap["normal"];
+}
+function paddingTopToClass(paddingTop) {
+  if (!paddingTop) return "";
+  const paddingMap = {
+    none: "pt-0",
+    sm: "pt-4",
+    normal: "pt-8",
+    lg: "pt-12",
+    xl: "pt-16"
+  };
+  return paddingMap[paddingTop] || paddingMap["normal"];
+}
+function paddingBottomToClass(paddingBottom) {
+  if (!paddingBottom) return "";
+  const paddingMap = {
+    none: "pb-0",
+    sm: "pb-4",
+    normal: "pb-8",
+    lg: "pb-12",
+    xl: "pb-16"
+  };
+  return paddingMap[paddingBottom] || paddingMap["normal"];
+}
+function spacingToClass(spacing) {
+  if (!spacing) return "";
+  const spacingMap = {
+    tight: "space-y-2",
+    normal: "space-y-4",
+    relaxed: "space-y-6",
+    loose: "space-y-8"
+  };
+  return spacingMap[spacing] || spacingMap["normal"];
+}
+function widthToClass(width) {
+  if (!width) return "";
+  const widthMap = {
+    full: "w-full",
+    container: "max-w-7xl mx-auto",
+    wide: "max-w-6xl mx-auto",
+    prose: "max-w-4xl mx-auto",
+    narrow: "max-w-2xl mx-auto"
+  };
+  return widthMap[width] || widthMap["container"];
+}
+function colorToStyle(color) {
+  if (!color) return {};
+  return {
+    backgroundColor: color
+  };
+}
+function gapToClass(gap) {
+  if (gap === void 0 || gap === null) return "";
+  if (gap === 0) return "gap-0";
+  if (gap <= 4) return "gap-1";
+  if (gap <= 8) return "gap-2";
+  if (gap <= 12) return "gap-3";
+  if (gap <= 16) return "gap-4";
+  if (gap <= 24) return "gap-6";
+  if (gap <= 32) return "gap-8";
+  if (gap <= 48) return "gap-12";
+  return "gap-16";
+}
+
+// src/password-resolver.utils.ts
+function isPasswordProtected(password_protected) {
+  return password_protected === true;
+}
+function filterPasswordProtectedContent(items) {
+  return items.filter((item) => !isPasswordProtected(item.password_protected));
+}
+
+// src/json-ld.utils.ts
+function buildBreadcrumbs(path, pageTitle) {
+  const crumbs = [
+    { name: "Home", path: "/" }
+  ];
+  if (path === "/" || path === "") {
+    return crumbs;
+  }
+  const segments = path.replace(/^\//, "").split("/").filter(Boolean);
+  for (let i = 0; i < segments.length; i++) {
+    const segPath = "/" + segments.slice(0, i + 1).join("/");
+    const isLast = i === segments.length - 1;
+    const name = isLast ? pageTitle : slugToTitle(segments[i]);
+    crumbs.push({ name, path: segPath });
+  }
+  return crumbs;
+}
+function generateJsonLd(input) {
+  const {
+    siteUrl,
+    path,
+    locale,
+    siteName,
+    siteDescription,
+    organization,
+    page,
+    blogPost
+  } = input;
+  const canonicalUrl = siteUrl + path;
+  const graph = [];
+  const websiteNode = {
+    "@type": "WebSite",
+    "@id": `${siteUrl}/#website`,
+    url: siteUrl,
+    name: siteName,
+    inLanguage: locale
+  };
+  if (siteDescription) {
+    websiteNode.description = siteDescription;
+  }
+  if (organization) {
+    websiteNode.publisher = { "@id": `${siteUrl}/#organization` };
+  }
+  graph.push(websiteNode);
+  if (organization && hasOrganizationData(organization)) {
+    const orgNode = {
+      "@type": "Organization",
+      "@id": `${siteUrl}/#organization`
+    };
+    if (organization.name) orgNode.name = organization.name;
+    if (organization.legal_name) orgNode.legalName = organization.legal_name;
+    if (organization.logo) {
+      orgNode.logo = {
+        "@type": "ImageObject",
+        "@id": `${siteUrl}/#logo`,
+        url: organization.logo,
+        contentUrl: organization.logo
+      };
+      orgNode.image = { "@id": `${siteUrl}/#logo` };
+    }
+    if (organization.url) orgNode.url = organization.url;
+    if (organization.email) orgNode.email = organization.email;
+    if (organization.phone) orgNode.telephone = organization.phone;
+    if (organization.description)
+      orgNode.description = organization.description;
+    if (organization.address) {
+      const addr = organization.address;
+      const addressNode = {
+        "@type": "PostalAddress"
+      };
+      if (addr.street) addressNode.streetAddress = addr.street;
+      if (addr.city) addressNode.addressLocality = addr.city;
+      if (addr.region) addressNode.addressRegion = addr.region;
+      if (addr.postal_code) addressNode.postalCode = addr.postal_code;
+      if (addr.country) addressNode.addressCountry = addr.country;
+      orgNode.address = addressNode;
+    }
+    if (organization.social_profiles && organization.social_profiles.length > 0) {
+      orgNode.sameAs = organization.social_profiles.map((sp) => sp.url);
+    }
+    graph.push(orgNode);
+  }
+  const breadcrumbs = input.breadcrumbs ?? buildBreadcrumbs(path, page?.title ?? blogPost?.title ?? siteName);
+  const breadcrumbNode = {
+    "@type": "BreadcrumbList",
+    "@id": `${canonicalUrl}#breadcrumb`,
+    itemListElement: breadcrumbs.map((crumb, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: crumb.name,
+      item: siteUrl + crumb.path
+    }))
+  };
+  graph.push(breadcrumbNode);
+  if (page) {
+    const schemaType = page.schemaType || "WebPage";
+    const pageNode = {
+      "@type": schemaType,
+      "@id": `${canonicalUrl}#webpage`,
+      url: canonicalUrl,
+      name: page.title,
+      isPartOf: { "@id": `${siteUrl}/#website` },
+      breadcrumb: { "@id": `${canonicalUrl}#breadcrumb` },
+      inLanguage: locale
+    };
+    if (page.description) pageNode.description = page.description;
+    if (page.datePublished) pageNode.datePublished = page.datePublished;
+    if (page.dateModified) pageNode.dateModified = page.dateModified;
+    if (page.ogImage) {
+      pageNode.primaryImageOfPage = {
+        "@type": "ImageObject",
+        url: page.ogImage
+      };
+    }
+    graph.push(pageNode);
+  }
+  if (blogPost) {
+    const articleNode = {
+      "@type": "BlogPosting",
+      "@id": `${canonicalUrl}#article`,
+      headline: blogPost.title,
+      url: canonicalUrl,
+      isPartOf: { "@id": `${siteUrl}/#website` },
+      mainEntityOfPage: { "@id": `${canonicalUrl}#webpage` },
+      inLanguage: locale,
+      datePublished: blogPost.datePublished
+    };
+    if (blogPost.dateModified) articleNode.dateModified = blogPost.dateModified;
+    if (blogPost.excerpt) articleNode.description = blogPost.excerpt;
+    if (blogPost.featuredImage) {
+      articleNode.image = {
+        "@type": "ImageObject",
+        url: blogPost.featuredImage
+      };
+    }
+    if (blogPost.categories && blogPost.categories.length > 0) {
+      articleNode.articleSection = blogPost.categories;
+    }
+    if (organization) {
+      articleNode.publisher = { "@id": `${siteUrl}/#organization` };
+    }
+    if (blogPost.authorName) {
+      const personNode = {
+        "@type": "Person",
+        "@id": `${siteUrl}/#author`,
+        name: blogPost.authorName
+      };
+      if (blogPost.authorUrl) personNode.url = blogPost.authorUrl;
+      graph.push(personNode);
+      articleNode.author = { "@id": `${siteUrl}/#author` };
+    }
+    if (!page) {
+      graph.push({
+        "@type": "WebPage",
+        "@id": `${canonicalUrl}#webpage`,
+        url: canonicalUrl,
+        name: blogPost.title,
+        isPartOf: { "@id": `${siteUrl}/#website` },
+        breadcrumb: { "@id": `${canonicalUrl}#breadcrumb` },
+        inLanguage: locale
+      });
+    }
+    graph.push(articleNode);
+  }
+  return {
+    "@context": "https://schema.org",
+    "@graph": graph
+  };
+}
+function slugToTitle(slug) {
+  return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function hasOrganizationData(org) {
+  return !!(org.name || org.legal_name || org.logo || org.url || org.email || org.phone || org.description);
+}
+
+// src/seo.utils.ts
+function deriveSiteUrl(configs, siteUrlOverride) {
+  let url = "";
+  if (siteUrlOverride) {
+    url = siteUrlOverride;
+  } else {
+    const deployment = configs.deployment;
+    const customDomains = deployment?.custom_domains;
+    if (customDomains?.[0]) {
+      url = `https://${customDomains[0]}`;
+    } else {
+      const subdomain = deployment?.subdomain;
+      if (subdomain) url = `https://${subdomain}.otl.studio`;
+    }
+  }
+  return url.replace(/\/+$/, "");
+}
+function deriveSiteName(configs, locale) {
+  const website = configs.website;
+  if (!website?.site_name) return "Website";
+  if (typeof website.site_name === "string") return website.site_name;
+  const names = website.site_name;
+  return names[locale] || names.en || "Website";
+}
+function deriveSiteDescription(configs, locale) {
+  const website = configs.website;
+  if (!website?.description) return void 0;
+  if (typeof website.description === "string") return website.description;
+  const descs = website.description;
+  return descs[locale] || void 0;
+}
+function detectLocaleFromSegments(segments, fullPath, supportedLocales, defaultLocale) {
+  const normalizedLocales = supportedLocales.map((l) => l.toLowerCase());
+  const firstSegment = segments[0];
+  const localeIndex = normalizedLocales.indexOf(firstSegment?.toLowerCase());
+  if (localeIndex !== -1) {
+    return [
+      supportedLocales[localeIndex],
+      "/" + segments.slice(1).join("/") || "/"
+    ];
+  }
+  return [defaultLocale, fullPath];
+}
+function localeToOgFormat(locale) {
+  if (locale.includes("_")) return locale;
+  const map = {
+    en: "en_US",
+    de: "de_DE",
+    fr: "fr_FR",
+    es: "es_ES",
+    it: "it_IT",
+    pt: "pt_BR",
+    nl: "nl_NL",
+    ja: "ja_JP",
+    zh: "zh_CN",
+    ko: "ko_KR",
+    ru: "ru_RU",
+    ar: "ar_SA",
+    pl: "pl_PL",
+    sv: "sv_SE",
+    da: "da_DK",
+    fi: "fi_FI",
+    nb: "nb_NO",
+    tr: "tr_TR"
+  };
+  return map[locale.toLowerCase()] || `${locale}_${locale.toUpperCase()}`;
+}
+function buildHreflangAlternates(siteUrl, path, supportedLocales, defaultLocale) {
+  if (!siteUrl || supportedLocales.length <= 1) return void 0;
+  const languages = {};
+  for (const loc of supportedLocales) {
+    if (loc === defaultLocale) {
+      languages[loc] = `${siteUrl}${path}`;
+    } else {
+      languages[loc] = `${siteUrl}/${loc}${path}`;
+    }
+  }
+  languages["x-default"] = `${siteUrl}${path}`;
+  return languages;
+}
+function extractPaginationFromLayout(layout) {
+  if (!layout) return null;
+  for (const section of layout) {
+    const sConfig = section?.config;
+    if (!sConfig) continue;
+    const result = findPaginationInBlocks(
+      sConfig.children || []
+    );
+    if (result) return result;
+  }
+  return null;
+}
+function findPaginationInBlocks(blocks) {
+  for (const block of blocks) {
+    const b = block;
+    const config = b?.config;
+    if (!config) continue;
+    const data = config.data;
+    if (data?.pagination) {
+      const p = data.pagination;
+      return {
+        page: p.page || 1,
+        totalPages: p.totalPages || 1,
+        hasNext: p.hasNext || false,
+        hasPrev: p.hasPrev || false
+      };
+    }
+    if (config.children) {
+      const nested = findPaginationInBlocks(config.children);
+      if (nested) return nested;
+    }
+    if (config.child) {
+      const nested = findPaginationInBlocks(config.child);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+exports.borderToStyle = borderToStyle;
+exports.buildBreadcrumbs = buildBreadcrumbs;
+exports.buildCategoryTree = buildCategoryTree;
+exports.buildHreflangAlternates = buildHreflangAlternates;
+exports.cn = cn;
+exports.colorToStyle = colorToStyle;
+exports.deriveSiteDescription = deriveSiteDescription;
+exports.deriveSiteName = deriveSiteName;
+exports.deriveSiteUrl = deriveSiteUrl;
+exports.detectLocale = detectLocale;
+exports.detectLocaleFromSegments = detectLocaleFromSegments;
+exports.extractPaginationFromLayout = extractPaginationFromLayout;
+exports.filterPasswordProtectedContent = filterPasswordProtectedContent;
+exports.filterScheduledContent = filterScheduledContent;
+exports.findCategoryBySlug = findCategoryBySlug;
+exports.flattenCategoryTree = flattenCategoryTree;
+exports.formatLocaleForHtml = formatLocaleForHtml;
+exports.formatShadow = formatShadow;
+exports.fromResponsiveConfig = fromResponsiveConfig;
+exports.gapToClass = gapToClass;
+exports.generateJsonLd = generateJsonLd;
+exports.generateResponsiveSpacingCSS = generateResponsiveSpacingCSS;
+exports.getAnimationTimingFunction = getAnimationTimingFunction;
+exports.getAvailableLocales = getAvailableLocales;
+exports.getBreakpointValue = getBreakpointValue;
+exports.getCategoryName = getCategoryName;
+exports.getCategoryPath = getCategoryPath;
+exports.getCategorySlug = getCategorySlug;
+exports.getDefinedBreakpoints = getDefinedBreakpoints;
+exports.getDescendants = getDescendants;
+exports.getLocalizedString = getLocalizedString;
+exports.hasAnyMargin = hasAnyMargin;
+exports.isAncestor = isAncestor;
+exports.isContentVisible = isContentVisible;
+exports.isLocalizedString = isLocalizedString;
+exports.isMultivariateContent = isMultivariateContent;
+exports.isPasswordProtected = isPasswordProtected;
+exports.isResponsiveConfig = isResponsiveConfig;
+exports.localeToOgFormat = localeToOgFormat;
+exports.minifyCSS = minifyCSS;
+exports.normalizeResponsiveValue = normalizeResponsiveValue;
+exports.paddingBottomToClass = paddingBottomToClass;
+exports.paddingToClass = paddingToClass;
+exports.paddingTopToClass = paddingTopToClass;
+exports.resolveBlogPostVariant = resolveBlogPostVariant;
+exports.resolveBorderToCSS = resolveBorderToCSS;
+exports.resolveColorToCSS = resolveColorToCSS;
+exports.resolveColorsToCSS = resolveColorsToCSS;
+exports.resolveFormVariantsInSections = resolveFormVariantsInSections;
+exports.resolvePageVariant = resolvePageVariant;
+exports.selectVariant = selectVariant;
+exports.spacingToClass = spacingToClass;
+exports.toResponsiveConfig = toResponsiveConfig;
+exports.widthToClass = widthToClass;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map