@seo-partner/adapters 0.0.0-stage → 1.0.3

package/src/index.ts

@@ -0,0 +1,31 @@
+export * from './contract.js';
+export * from './detector.js';
+export * from './nextjs-adapter.js';
+export * from './astro-adapter.js';
+export * from './nuxt-adapter.js';
+export * from './sveltekit-adapter.js';
+export * from './remix-adapter.js';
+export * from './django-adapter.js';
+export * from './php-adapter.js';
+export * from './laravel-adapter.js';
+export * from './symfony-adapter.js';
+export * from './php-native-adapter.js';
+export * from './static-adapter.js';
+export * from './parsers/tsx-ast-parser.js';
+export * from './parsers/html-parser.js';
+export * from './parsers/astro-parser.js';
+export * from './parsers/vue-sfc-parser.js';
+export * from './parsers/svelte-parser.js';
+export * from './parsers/remix-parser.js';
+export * from './parsers/python-url-parser.js';
+export * from './parsers/dtl-parser.js';
+export * from './parsers/php-route-parser.js';
+export * from './parsers/php-template-parser.js';
+export * from './parsers/robots-sitemap-parser.js';
+export * from './parsers/route-normalizer.js';
+export * from './parsers/layout-resolver.js';
+export * from './sitemap-builder.js';
+export * from './skeleton-detector.js';
+export * from './ast-merger.js';
+export * from './layout-title-resolver.js';
+export * from './blog-scaffold-generator.js';

package/src/laravel-adapter.ts

@@ -0,0 +1,45 @@
+export interface LaravelMetaFields {
+  title?: string;
+  description?: string;
+  canonical?: string;
+}
+
+export function patchLaravelBladeTemplate(
+  sourceCode: string,
+  meta: LaravelMetaFields,
+): string {
+  let result = sourceCode;
+
+  // Title section
+  if (meta.title && !/@section\(\s*['"]title['"]/i.test(result)) {
+    const sectionTitle = `@section('title', '${meta.title.replace(/'/g, "\\'")}')\n`;
+    if (/@extends\([^)]+\)/i.test(result)) {
+      result = result.replace(/(@extends\([^)]+\)\s*\n)/i, `$1${sectionTitle}`);
+    } else {
+      result = sectionTitle + result;
+    }
+  }
+
+  // Meta push
+  if ((meta.description || meta.canonical) && !/@push\(\s*['"]meta['"]/i.test(result)) {
+    const metaTags: string[] = ["@push('meta')"];
+    if (meta.description) {
+      metaTags.push(`  <meta name="description" content="${meta.description.replace(/"/g, '&quot;')}">`);
+    }
+    if (meta.canonical) {
+      metaTags.push(`  <link rel="canonical" href="${meta.canonical}">`);
+    }
+    metaTags.push('@endpush\n');
+
+    if (/@section\(\s*['"]title['"][^)]*\)/i.test(result)) {
+      result = result.replace(/(@section\(\s*['"]title['"][^)]*\)\s*\n)/i, `$1${metaTags.join('\n')}`);
+    } else if (/@extends\([^)]+\)/i.test(result)) {
+      result = result.replace(/(@extends\([^)]+\)\s*\n)/i, `$1${metaTags.join('\n')}`);
+    } else {
+      result = metaTags.join('\n') + result;
+    }
+  }
+
+  return result;
+}
+

package/src/layout-title-resolver.ts

@@ -0,0 +1,37 @@
+export interface LayoutTitleTemplate {
+  template?: string;
+  defaultTitle?: string;
+  brandName?: string;
+}
+
+export function extractLayoutTitleTemplate(layoutCode: string): LayoutTitleTemplate | null {
+  const match = /title\s*:\s*\{([^}]+)\}/m.exec(layoutCode);
+  if (!match || !match[1]) return null;
+
+  const body = match[1];
+  const templateMatch = /template\s*:\s*['"`]([^'"`]+)['"`]/.exec(body);
+  const defaultMatch = /default\s*:\s*['"`]([^'"`]+)['"`]/.exec(body);
+
+  const template = templateMatch?.[1];
+  const defaultTitle = defaultMatch?.[1];
+
+  let brandName: string | undefined;
+  if (template && template.includes('%s')) {
+    brandName = template.replace('%s', '').replace(/^[| -]+|[| -]+$/g, '').trim();
+  }
+
+  return {
+    template,
+    defaultTitle,
+    brandName,
+  };
+}
+
+export function sanitizePageTitleForLayout(pageTitle: string, layoutTemplate: LayoutTitleTemplate | null): string {
+  if (!layoutTemplate?.brandName) {
+    return pageTitle;
+  }
+  const brand = layoutTemplate.brandName;
+  const regex = new RegExp(`(\\s*[|\\-]\\s*${brand.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')})+$`, 'i');
+  return pageTitle.replace(regex, '').trim();
+}

package/src/nextjs-adapter.ts

@@ -0,0 +1,116 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, FrameworkAdapter } from './contract.js';
+import {
+  detectRenderingModeFromTsx,
+  parseTsxRouteFile,
+} from './parsers/tsx-ast-parser.js';
+
+const PRIVATE_ROUTE_PREFIXES = ['/admin', '/dashboard', '/login', '/auth', '/api', '/account'];
+
+export function isPrivateRoutePattern(pattern: string): boolean {
+  const lower = pattern.toLowerCase();
+  return PRIVATE_ROUTE_PREFIXES.some(
+    (prefix) => lower === prefix || lower.startsWith(`${prefix}/`),
+  );
+}
+
+export function appRouterPathToPattern(relPath: string): string {
+  const withoutPrefix = relPath.replace(/^(src\/)?app\//, '');
+  const withoutPage = withoutPrefix.replace(/\/?page\.(tsx|ts|jsx|js|mdx)$/, '');
+  const segments = withoutPage
+    .split('/')
+    .filter((s) => s.length > 0 && !(s.startsWith('(') && s.endsWith(')')));
+  return segments.length === 0 ? '/' : `/${segments.join('/')}`;
+}
+
+export function pagesRouterPathToPattern(relPath: string): string {
+  const withoutPrefix = relPath.replace(/^(src\/)?pages\//, '');
+  const withoutExt = withoutPrefix.replace(/\.(tsx|ts|jsx|js)$/, '');
+  if (withoutExt === 'index') return '/';
+  const cleaned = withoutExt.replace(/\/index$/, '');
+  return `/${cleaned}`;
+}
+
+export class NextJsAdapter implements FrameworkAdapter {
+  public readonly id = 'nextjs';
+  public readonly name = 'Next.js (App Router & Pages Router)';
+  public readonly version = '1.0' as const;
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  public async detect(
+    _projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    const pkgJson = contentsByPath.get('package.json');
+    if (pkgJson && /"next"\s*:/.test(pkgJson)) {
+      return true;
+    }
+    return filePaths.some(
+      (p) =>
+        /^next\.config\.(js|mjs|ts|cjs)$/.test(p) ||
+        /^(src\/)?app\/.*page\.(tsx|ts|jsx|js)$/.test(p) ||
+        /^(src\/)?pages\/.*\.(tsx|ts|jsx|js)$/.test(p),
+    );
+  }
+
+  public async discoverRoutes(
+    _projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    for (const filePath of filePaths) {
+      if (/^(src\/)?app\/(.*\/)?page\.(tsx|ts|jsx|js)$/.test(filePath)) {
+        const pattern = appRouterPathToPattern(filePath);
+        const content = contentsByPath.get(filePath) ?? '';
+        routes.push({
+          pattern,
+          filePath,
+          routerKind: 'nextjs-app',
+          renderingMode: detectRenderingModeFromTsx(content),
+          isPrivate: isPrivateRoutePattern(pattern),
+          inSitemap: sitemapPaths.has(pattern),
+        });
+      } else if (
+        /^(src\/)?pages\/.*\.(tsx|ts|jsx|js)$/.test(filePath) &&
+        !/\/_app\./.test(filePath) &&
+        !/\/_document\./.test(filePath) &&
+        !/\/_error\./.test(filePath) &&
+        !/^(src\/)?pages\/api\//.test(filePath)
+      ) {
+        const pattern = pagesRouterPathToPattern(filePath);
+        const content = contentsByPath.get(filePath) ?? '';
+        routes.push({
+          pattern,
+          filePath,
+          routerKind: 'nextjs-pages',
+          renderingMode: detectRenderingModeFromTsx(content),
+          isPrivate: isPrivateRoutePattern(pattern),
+          inSitemap: sitemapPaths.has(pattern),
+        });
+      }
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    _projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    return parseTsxRouteFile(route, fileContent);
+  }
+}
+

package/src/nuxt-adapter.ts

@@ -0,0 +1,148 @@
+import type { DiscoveredRoute, ExtractedRouteData } from '@seo-partner/core';
+import type { AdapterCapabilities, AdapterVersion, FrameworkAdapter } from './contract.js';
+import { parseVueSfc } from './parsers/vue-sfc-parser.js';
+import { normalizeRoutePattern } from './parsers/route-normalizer.js';
+import { LayoutResolver } from './parsers/layout-resolver.js';
+
+export class NuxtAdapter implements FrameworkAdapter {
+  public readonly id = 'nuxt';
+  public readonly name = 'Nuxt 3';
+  public readonly version: AdapterVersion = '1.0';
+  public readonly capabilities: AdapterCapabilities = {
+    routes: true,
+    metadata: true,
+    headings: true,
+    internalLinks: true,
+    jsonLd: true,
+    images: true,
+    robotsAndSitemap: true,
+  };
+
+  private readonly layoutResolver = new LayoutResolver();
+
+  public async detect(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+  ): Promise<boolean> {
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (
+        normalized === 'nuxt.config.ts' ||
+        normalized === 'nuxt.config.js' ||
+        normalized === 'nuxt.config.mjs'
+      ) {
+        return true;
+      }
+      if (normalized === 'package.json') {
+        const content = contentsByPath.get(filePath) ?? '';
+        if (content.includes('"nuxt"') || content.includes('"@nuxt/')) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  public async discoverRoutes(
+    projectRoot: string,
+    filePaths: ReadonlyArray<string>,
+    contentsByPath: ReadonlyMap<string, string>,
+    sitemapPaths: ReadonlySet<string>,
+  ): Promise<ReadonlyArray<DiscoveredRoute>> {
+    const routes: DiscoveredRoute[] = [];
+
+    // Pre-cache layouts from layouts/**
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (normalized.startsWith('layouts/') && normalized.endsWith('.vue')) {
+        const content = contentsByPath.get(filePath) ?? '';
+        const parsed = parseVueSfc(
+          {
+            pattern: '',
+            filePath,
+            routerKind: 'nuxt',
+            renderingMode: 'ssr-ssg',
+            isPrivate: false,
+            inSitemap: false,
+          },
+          content,
+        );
+        this.layoutResolver.registerLayout({
+          filePath,
+          htmlLang: parsed.htmlLang,
+          title: parsed.title,
+          description: parsed.description,
+          canonical: parsed.canonical,
+          robots: parsed.robots,
+        });
+      }
+    }
+
+    for (const filePath of filePaths) {
+      const normalized = filePath.replace(/\\/g, '/');
+      if (!normalized.startsWith('pages/')) continue;
+      if (!normalized.endsWith('.vue')) continue;
+
+      const relativeInsidePages = normalized.slice('pages/'.length);
+      const pattern = normalizeRoutePattern(relativeInsidePages, 'nuxt');
+      const inSitemap = sitemapPaths.has(pattern);
+
+      routes.push({
+        pattern,
+        filePath,
+        routerKind: 'nuxt',
+        renderingMode: 'ssr-ssg',
+        isPrivate: false,
+        inSitemap,
+      });
+    }
+
+    return routes;
+  }
+
+  public async extractRoute(
+    projectRoot: string,
+    route: DiscoveredRoute,
+    fileContent: string,
+  ): Promise<ExtractedRouteData> {
+    let extracted = parseVueSfc(route, fileContent);
+
+    // Inherit from default layout if present
+    const layoutCandidates = ['layouts/default.vue', 'layouts/main.vue'];
+    extracted = this.layoutResolver.applyInheritance(extracted, layoutCandidates);
+
+    return extracted;
+  }
+}
+
+
+export interface NuxtMetaFields {
+  title?: string;
+  description?: string;
+  canonical?: string;
+}
+
+export function patchNuxtTemplate(
+  sourceCode: string,
+  meta: NuxtMetaFields,
+): string {
+  let result = sourceCode;
+
+  const entries: string[] = [];
+  if (meta.title) entries.push(`  title: '${meta.title.replace(/'/g, "\\'")}',`);
+  if (meta.description) entries.push(`  description: '${meta.description.replace(/'/g, "\\'")}',`);
+  if (meta.canonical) entries.push(`  canonical: '${meta.canonical}',`);
+
+  const seoMetaCall = `useSeoMeta({\n${entries.join('\n')}\n});\n`;
+
+  if (/<script\s+setup[^>]*>/i.test(result)) {
+    if (!/useSeoMeta\s*\(/i.test(result)) {
+      result = result.replace(/(<script\s+setup[^>]*>\s*\n)/i, `$1${seoMetaCall}`);
+    }
+  } else {
+    result = `<script setup lang="ts">\n${seoMetaCall}</script>\n\n` + result;
+  }
+
+  return result;
+}

package/src/parsers/astro-parser.ts

@@ -0,0 +1,249 @@
+import type {
+  DiscoveredRoute,
+  ExtractedRouteData,
+  HeadingItem,
+  ImageItem,
+  JsonLdItem,
+  LinkItem,
+} from '@seo-partner/core';
+
+function lineNumberAtOffset(content: string, offset: number): number {
+  let line = 1;
+  for (let i = 0; i < offset && i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) line += 1;
+  }
+  return line;
+}
+
+function getAttr(attrsRaw: string, attrName: string): string | null {
+  const re = new RegExp(`\\b${attrName}\\s*=\\s*["']([^"']*)["']`, 'i');
+  const m = re.exec(attrsRaw);
+  return m ? (m[1] ?? null) : null;
+}
+
+export interface AstroParseResult {
+  readonly routeData: ExtractedRouteData;
+  readonly layoutReference?: string;
+  readonly layoutProps?: Record<string, string>;
+}
+
+export function parseAstroOrMarkdown(
+  route: DiscoveredRoute,
+  fileContent: string,
+): AstroParseResult {
+  let title: { value: string; line: number } | null = null;
+  let description: { value: string; line: number } | null = null;
+  let canonical: { value: string; line: number } | null = null;
+  let robots: { value: string; line: number } | null = null;
+  let htmlLang: { value: string; line: number } | null | undefined = undefined;
+  let isDynamic = false;
+  let layoutReference: string | undefined = undefined;
+  const layoutProps: Record<string, string> = {};
+
+  const openGraph: Record<string, string> = {};
+  const hreflang: Array<{ lang: string; url: string }> = [];
+  const headings: HeadingItem[] = [];
+  const images: ImageItem[] = [];
+  const links: LinkItem[] = [];
+  const jsonLdItems: JsonLdItem[] = [];
+
+  const lines = fileContent.split(/\r?\n/);
+
+  // 1. Check for YAML frontmatter (Astro / Markdown / MDX)
+  const frontmatterMatch = fileContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (frontmatterMatch && frontmatterMatch[1]) {
+    const fmLines = frontmatterMatch[1].split(/\r?\n/);
+    for (let i = 0; i < fmLines.length; i += 1) {
+      const lineText = (fmLines[i] ?? '').trim();
+      const lineNum = i + 2; // 1-based, after opening '---'
+
+      // YAML: title: "..."
+      const yTitle = /^title:\s*["']?(.+?)["']?$/i.exec(lineText);
+      if (yTitle && !title) {
+        title = { value: (yTitle[1] ?? '').trim(), line: lineNum };
+      }
+
+      // YAML: description: "..."
+      const yDesc = /^description:\s*["']?(.+?)["']?$/i.exec(lineText);
+      if (yDesc && !description) {
+        description = { value: (yDesc[1] ?? '').trim(), line: lineNum };
+      }
+
+      // YAML: layout: "..."
+      const yLayout = /^layout:\s*["']?(.+?)["']?$/i.exec(lineText);
+      if (yLayout && !layoutReference) {
+        layoutReference = (yLayout[1] ?? '').trim();
+      }
+
+      // JS frontmatter: const title = "..." or const title = `...`
+      const jsConstTitle = /(?:const|let|var)\s+title\s*=\s*["']([^"']+)["']/i.exec(lineText);
+      if (jsConstTitle && !title) {
+        title = { value: jsConstTitle[1] ?? '', line: lineNum };
+      } else {
+        // Dynamic expression: e.g. const title = `...${slug}...`
+        const jsDynamicTitle = /(?:const|let|var)\s+title\s*=\s*[`{]/i.exec(lineText);
+        if (jsDynamicTitle && !title) {
+          title = { value: '[Valeur dynamique]', line: lineNum };
+          isDynamic = true;
+        }
+      }
+
+      // JS frontmatter: const description = "..."
+      const jsConstDesc = /(?:const|let|var)\s+description\s*=\s*["']([^"']+)["']/i.exec(lineText);
+      if (jsConstDesc && !description) {
+        description = { value: jsConstDesc[1] ?? '', line: lineNum };
+      }
+    }
+  }
+
+  // 2. Look for Layout component in template: e.g. <BaseLayout title="My Title" ...>
+  const layoutComponentMatch = /<([A-Z][a-zA-Z0-9]*Layout)\b([^>]*?)>/i.exec(fileContent);
+  if (layoutComponentMatch) {
+    const layoutTag = layoutComponentMatch[1] ?? '';
+    layoutReference = layoutTag;
+    const attrs = layoutComponentMatch[2] ?? '';
+    const line = lineNumberAtOffset(fileContent, layoutComponentMatch.index);
+
+    // Check title prop: title="..." or title={...}
+    const propTitle = getAttr(attrs, 'title');
+    if (propTitle && !title) {
+      title = { value: propTitle, line };
+    } else if (/\btitle=\{([^}]+)\}/i.test(attrs) && !title) {
+      // If title={title} and title was already set from frontmatter const, keep it; else dynamic
+      if (!title) {
+        title = { value: '[Valeur dynamique]', line };
+        isDynamic = true;
+      }
+    }
+
+    const propDesc = getAttr(attrs, 'description');
+    if (propDesc && !description) {
+      description = { value: propDesc, line };
+    }
+  }
+
+  // 3. Direct HTML tags: <html lang="...">
+  const htmlTagMatch = /<html\b([^>]*?)>/i.exec(fileContent);
+  if (htmlTagMatch) {
+    const langVal = getAttr(htmlTagMatch[1] ?? '', 'lang');
+    if (langVal) {
+      htmlLang = {
+        value: langVal.trim(),
+        line: lineNumberAtOffset(fileContent, htmlTagMatch.index),
+      };
+    }
+  }
+
+  // Direct <title>
+  const titleTagMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(fileContent);
+  if (titleTagMatch && !title) {
+    const rawVal = (titleTagMatch[1] ?? '').trim();
+    const line = lineNumberAtOffset(fileContent, titleTagMatch.index);
+    if (/\{[^}]+\}/.test(rawVal)) {
+      title = { value: '[Valeur dynamique]', line };
+      isDynamic = true;
+    } else {
+      title = { value: rawVal.replace(/\s+/g, ' '), line };
+    }
+  }
+
+  // Direct <meta name="description">, <meta name="robots">, <link rel="canonical">
+  const metaRegex = /<meta\b([^>]*?)\/?>/gi;
+  let metaMatch: RegExpExecArray | null;
+  while ((metaMatch = metaRegex.exec(fileContent)) !== null) {
+    const attrs = metaMatch[1] ?? '';
+    const line = lineNumberAtOffset(fileContent, metaMatch.index);
+    const nameVal = getAttr(attrs, 'name')?.toLowerCase();
+    const propVal = getAttr(attrs, 'property')?.toLowerCase();
+    const contentVal = getAttr(attrs, 'content');
+    if (nameVal === 'description' && contentVal !== null && !description) {
+      description = { value: contentVal, line };
+    } else if (nameVal === 'robots' && contentVal !== null && !robots) {
+      robots = { value: contentVal, line };
+    } else if (propVal?.startsWith('og:') && contentVal !== null) {
+      openGraph[propVal.slice(3)] = contentVal;
+    }
+  }
+
+  const linkRegex = /<link\b([^>]*?)\/?>/gi;
+  let linkMatch: RegExpExecArray | null;
+  while ((linkMatch = linkRegex.exec(fileContent)) !== null) {
+    const attrs = linkMatch[1] ?? '';
+    const line = lineNumberAtOffset(fileContent, linkMatch.index);
+    const relVal = getAttr(attrs, 'rel')?.toLowerCase();
+    const hrefVal = getAttr(attrs, 'href');
+    if (relVal === 'canonical' && hrefVal !== null && !canonical) {
+      canonical = { value: hrefVal, line };
+    } else if (relVal === 'alternate' && hrefVal !== null) {
+      const hl = getAttr(attrs, 'hreflang');
+      if (hl) hreflang.push({ lang: hl, url: hrefVal });
+    }
+  }
+
+  // 4. Headings: HTML <h1>-<h6> or Markdown #
+  const headingRegex = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let hMatch: RegExpExecArray | null;
+  while ((hMatch = headingRegex.exec(fileContent)) !== null) {
+    const level = Number(hMatch[1]) as 1 | 2 | 3 | 4 | 5 | 6;
+    const text = (hMatch[2] ?? '').replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+    headings.push({
+      level,
+      text,
+      line: lineNumberAtOffset(fileContent, hMatch.index),
+    });
+  }
+
+  // Markdown headings (# Title)
+  for (let i = 0; i < lines.length; i += 1) {
+    const lineText = lines[i] ?? '';
+    const mdHMatch = /^(#{1,6})\s+(.+)$/.exec(lineText.trim());
+    if (mdHMatch) {
+      const level = (mdHMatch[1]?.length ?? 1) as 1 | 2 | 3 | 4 | 5 | 6;
+      headings.push({
+        level,
+        text: (mdHMatch[2] ?? '').trim(),
+        line: i + 1,
+      });
+    }
+  }
+
+  // 5. Links: <a href="...">
+  const aRegex = /<a\b([^>]*?)>([\s\S]*?)<\/a>/gi;
+  let aMatch: RegExpExecArray | null;
+  while ((aMatch = aRegex.exec(fileContent)) !== null) {
+    const attrs = aMatch[1] ?? '';
+    const href = getAttr(attrs, 'href');
+    if (href) {
+      const anchorText = (aMatch[2] ?? '').replace(/<[^>]+>/g, '').trim();
+      const kind = href.startsWith('http://') || href.startsWith('https://') ? 'external' : 'internal';
+      links.push({
+        toUrl: href,
+        anchorText,
+        kind,
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, aMatch.index),
+      });
+    }
+  }
+
+  return {
+    routeData: {
+      route,
+      title,
+      description,
+      canonical,
+      robots,
+      htmlLang,
+      headings,
+      openGraph,
+      hreflang,
+      images,
+      links,
+      jsonLdItems,
+      isDynamic,
+    },
+    layoutReference,
+    layoutProps,
+  };
+}
+