@seo-partner/adapters 0.0.0-stage → 1.0.3

package/src/parsers/remix-parser.ts

@@ -0,0 +1,161 @@
+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 function parseRemixRoute(
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  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;
+
+  const openGraph: Record<string, string> = {};
+  const hreflang: Array<{ lang: string; url: string }> = [];
+  const headings: HeadingItem[] = [];
+  const images: ImageItem[] = [];
+  const links: LinkItem[] = [];
+  const jsonLdItems: JsonLdItem[] = [];
+
+  // 1. Check for <html lang="..."> in JSX (e.g. app/root.tsx)
+  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),
+      };
+    }
+  }
+
+  // 2. Scan for export const meta = ...
+  // Pattern 1: array return in arrow function or array literal
+  // export const meta = () => [ ... ]; or export const meta = [ ... ];
+  const metaMatch = /export\s+const\s+meta\b[^=]*=\s*(?:(?:\([^)]*\)|[a-zA-Z0-9_]+)\s*=>\s*)?(?:\{[\s\S]*?return\s+)?\[([\s\S]*?)\]/i.exec(fileContent);
+  if (metaMatch && metaMatch[1]) {
+    const metaArrayContent = metaMatch[1];
+    const metaOffset = metaMatch.index;
+    const metaLine = lineNumberAtOffset(fileContent, metaOffset);
+
+    // Extract { title: "..." }
+    const titleMatch = /\{\s*title\s*:\s*["']([^"']+)["']\s*\}/i.exec(metaArrayContent);
+    if (titleMatch) {
+      title = { value: titleMatch[1] ?? '', line: metaLine };
+    } else {
+      // Dynamic title expression: { title: data?.title || "..." } or { title: data ? ... }
+      const fallbackTitle = /\{\s*title\s*:\s*[^"'\n\r}]*?["']([^"']+)["']/i.exec(metaArrayContent);
+      if (fallbackTitle) {
+        title = { value: fallbackTitle[1] ?? '', line: metaLine };
+      } else if (/\{\s*title\s*:/i.test(metaArrayContent)) {
+        title = { value: '[Valeur dynamique]', line: metaLine };
+        isDynamic = true;
+      }
+    }
+
+    // Extract { name: "description", content: "..." }
+    const descMatch = /\{\s*name\s*:\s*["']description["']\s*,\s*content\s*:\s*["']([^"']+)["']/i.exec(metaArrayContent);
+    if (descMatch) {
+      description = { value: descMatch[1] ?? '', line: metaLine };
+    }
+
+    // Extract { name: "robots", content: "..." }
+    const robotsMatch = /\{\s*name\s*:\s*["']robots["']\s*,\s*content\s*:\s*["']([^"']+)["']/i.exec(metaArrayContent);
+    if (robotsMatch) {
+      robots = { value: robotsMatch[1] ?? '', line: metaLine };
+    }
+
+    // Extract canonical: { tagName: "link", rel: "canonical", href: "..." }
+    const canonicalMatch = /rel\s*:\s*["']canonical["']\s*,\s*href\s*:\s*["']([^"']+)["']/i.exec(metaArrayContent);
+    if (canonicalMatch) {
+      canonical = { value: canonicalMatch[1] ?? '', line: metaLine };
+    }
+  }
+
+  // 3. Headings in JSX: <h1> to <h6>
+  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(/\{[^}]+\}/g, '').replace(/\s+/g, ' ').trim();
+    headings.push({
+      level,
+      text,
+      line: lineNumberAtOffset(fileContent, hMatch.index),
+    });
+  }
+
+  // 4. Links: <Link to="..."> or <a href="...">
+  const linkRegex = /<(?:Link|NavLink)\b([^>]*?)>([\s\S]*?)<\/(?:Link|NavLink)>/gi;
+  let lMatch: RegExpExecArray | null;
+  while ((lMatch = linkRegex.exec(fileContent)) !== null) {
+    const attrs = lMatch[1] ?? '';
+    const to = getAttr(attrs, 'to') || getAttr(attrs, 'href');
+    if (to) {
+      const anchorText = (lMatch[2] ?? '').replace(/<[^>]+>/g, '').trim();
+      links.push({
+        toUrl: to,
+        anchorText,
+        kind: to.startsWith('http://') || to.startsWith('https://') ? 'external' : 'internal',
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, lMatch.index),
+      });
+    }
+  }
+
+  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();
+      links.push({
+        toUrl: href,
+        anchorText,
+        kind: href.startsWith('http://') || href.startsWith('https://') ? 'external' : 'internal',
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, aMatch.index),
+      });
+    }
+  }
+
+  return {
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    htmlLang,
+    headings,
+    openGraph,
+    hreflang,
+    images,
+    links,
+    jsonLdItems,
+    isDynamic,
+  };
+}
+

package/src/parsers/robots-sitemap-parser.ts

@@ -0,0 +1,128 @@
+export interface RobotsInfo {
+  readonly exists: boolean;
+  readonly filePath: string | null;
+  readonly hasUserAgent: boolean;
+  readonly sitemapUrls: ReadonlyArray<string>;
+  readonly disallowPaths: ReadonlyArray<string>;
+}
+
+export interface SitemapInfo {
+  readonly exists: boolean;
+  readonly filePath: string | null;
+  readonly routePaths: ReadonlySet<string>;
+}
+
+export function parseRobotsFiles(
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): RobotsInfo {
+  const robotsPath = filePaths.find(
+    (p) =>
+      p === 'public/robots.txt' ||
+      p === 'robots.txt' ||
+      p === 'src/app/robots.ts' ||
+      p === 'src/app/robots.js' ||
+      p === 'app/robots.ts' ||
+      p === 'app/robots.js',
+  );
+
+  if (!robotsPath) {
+    return {
+      exists: false,
+      filePath: null,
+      hasUserAgent: false,
+      sitemapUrls: [],
+      disallowPaths: [],
+    };
+  }
+
+  const content = contentsByPath.get(robotsPath) ?? '';
+  const sitemapUrls: string[] = [];
+  const disallowPaths: string[] = [];
+  let hasUserAgent = false;
+
+  if (robotsPath.endsWith('.txt')) {
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (/^user-agent:/i.test(trimmed)) {
+        hasUserAgent = true;
+      } else if (/^sitemap:/i.test(trimmed)) {
+        sitemapUrls.push(trimmed.replace(/^sitemap:\s*/i, '').trim());
+      } else if (/^disallow:/i.test(trimmed)) {
+        const p = trimmed.replace(/^disallow:\s*/i, '').trim();
+        if (p) disallowPaths.push(p);
+      }
+    }
+  } else {
+    hasUserAgent = /userAgent/i.test(content);
+    const smMatch = /sitemap:\s*['"]([^'"]+)['"]/i.exec(content);
+    if (smMatch?.[1]) sitemapUrls.push(smMatch[1]);
+  }
+
+  return {
+    exists: true,
+    filePath: robotsPath,
+    hasUserAgent,
+    sitemapUrls,
+    disallowPaths,
+  };
+}
+
+export function parseSitemapFiles(
+  filePaths: ReadonlyArray<string>,
+  contentsByPath: ReadonlyMap<string, string>,
+): SitemapInfo {
+  const sitemapPath = filePaths.find(
+    (p) =>
+      p === 'public/sitemap.xml' ||
+      p === 'sitemap.xml' ||
+      p === 'src/app/sitemap.ts' ||
+      p === 'src/app/sitemap.js' ||
+      p === 'app/sitemap.ts' ||
+      p === 'app/sitemap.js',
+  );
+
+  if (!sitemapPath) {
+    return {
+      exists: false,
+      filePath: null,
+      routePaths: new Set(),
+    };
+  }
+
+  const content = contentsByPath.get(sitemapPath) ?? '';
+  const routePaths = new Set<string>();
+
+  const locRegex = /<loc>\s*([^<\s]+)\s*<\/loc>/gi;
+  let m: RegExpExecArray | null;
+  while ((m = locRegex.exec(content)) !== null) {
+    const rawUrl = m[1] ?? '';
+    try {
+      const u = new URL(rawUrl);
+      routePaths.add(u.pathname || '/');
+    } catch {
+      if (rawUrl.startsWith('/')) routePaths.add(rawUrl);
+    }
+  }
+
+  const urlPropRegex = /url:\s*[`'"]([^`'"]+)[`'"]/g;
+  while ((m = urlPropRegex.exec(content)) !== null) {
+    const rawUrl = m[1] ?? '';
+    try {
+      const u = new URL(rawUrl);
+      routePaths.add(u.pathname || '/');
+    } catch {
+      const slashIdx = rawUrl.indexOf('/');
+      if (slashIdx >= 0) {
+        routePaths.add(rawUrl.slice(slashIdx));
+      }
+    }
+  }
+
+  return {
+    exists: true,
+    filePath: sitemapPath,
+    routePaths,
+  };
+}
+

package/src/parsers/route-normalizer.ts

@@ -0,0 +1,70 @@
+import type { RouterKind } from '@seo-partner/core';
+
+/**
+ * Normalizes framework-specific route file names and path declarations
+ * into a unified standard route pattern:
+ * - Dynamic parameter: `:param`
+ * - Catch-all parameter: `*rest`
+ * - Root path: `/`
+ * - Slashes: single leading slash, no trailing slash (unless root `/`)
+ */
+export function normalizeRoutePattern(rawPath: string, routerKind?: RouterKind): string {
+  let cleaned = rawPath.replace(/\\/g, '/').trim();
+
+  // Strip leading folder roots if passed as full file paths
+  cleaned = cleaned.replace(/^(?:src\/)?(?:pages|routes|app\/routes)\//i, '');
+
+  // Strip file extensions if present (.astro, .vue, .svelte, .tsx, .jsx, .md, .mdx, .html, .php)
+  cleaned = cleaned.replace(/\.(astro|vue|svelte|tsx|jsx|ts|js|md|mdx|html|php)$/i, '');
+
+  // Strip route file conventions (e.g. Next.js page, SvelteKit +page, Remix route, index)
+  cleaned = cleaned.replace(/(?:^|\/)(?:page|\+page|route|index|_index)$/i, '');
+
+  if (routerKind === 'remix') {
+    // Remix flat route conventions:
+    // "blog.$slug" -> "blog/:slug"
+    // "docs.$" -> "docs/*"
+    // "$slug" -> ":slug"
+    // "$" -> "*"
+    cleaned = cleaned.replace(/\.\$([a-zA-Z0-9_]+)/g, '/:$1');
+    cleaned = cleaned.replace(/\.\$/g, '/*');
+    cleaned = cleaned.replace(/^\$([a-zA-Z0-9_]+)/g, ':$1');
+    cleaned = cleaned.replace(/^\$$/g, '*');
+    cleaned = cleaned.replace(/\./g, '/');
+  }
+
+  if (routerKind === 'django') {
+    // Django re_path named groups: (?P<slug>[-\w]+) -> :slug (run before <param> replacement)
+    cleaned = cleaned.replace(/\(\?P<([a-zA-Z0-9_]+)>[^)]+\)/g, ':$1');
+    // Django path converters: <int:id>, <slug:slug>, <str:username>, <uuid:pk>, <path:subpath>
+    cleaned = cleaned.replace(/<path:([a-zA-Z0-9_]+)>/g, '*$1');
+    cleaned = cleaned.replace(/<[a-zA-Z0-9_]+:([a-zA-Z0-9_]+)>/g, ':$1');
+    cleaned = cleaned.replace(/<([a-zA-Z0-9_]+)>/g, ':$1');
+    // Strip regex markers ^ and $
+    cleaned = cleaned.replace(/^\^/, '').replace(/\$$/, '');
+  }
+
+  // Next.js, Astro, Nuxt, SvelteKit brackets:
+  // Catch-all: [[...rest]] or [...rest] -> *rest
+  cleaned = cleaned.replace(/\[\[\.\.\.([a-zA-Z0-9_]+)\]\]/g, '*$1');
+  cleaned = cleaned.replace(/\[\.\.\.([a-zA-Z0-9_]+)\]/g, '*$1');
+  // Single dynamic: [param] -> :param
+  cleaned = cleaned.replace(/\[([a-zA-Z0-9_]+)\]/g, ':$1');
+
+  // Nuxt 3 catch-all with triple dots or just [...slug]
+  cleaned = cleaned.replace(/\[\.\.\.\]/g, '*');
+
+  // Remove parenthesis group folders: e.g. Next.js / Astro (marketing) -> ignored
+  cleaned = cleaned.replace(/\([a-zA-Z0-9_-]+\)\/?/g, '');
+
+  // Normalize slashes
+  cleaned = cleaned.replace(/\/+/g, '/');
+  if (!cleaned.startsWith('/')) {
+    cleaned = `/${cleaned}`;
+  }
+  if (cleaned.length > 1 && cleaned.endsWith('/')) {
+    cleaned = cleaned.slice(0, -1);
+  }
+
+  return cleaned || '/';
+}

package/src/parsers/svelte-parser.ts

@@ -0,0 +1,167 @@
+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 function parseSvelteComponent(
+  route: DiscoveredRoute,
+  fileContent: string,
+): ExtractedRouteData {
+  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;
+
+  const openGraph: Record<string, string> = {};
+  const hreflang: Array<{ lang: string; url: string }> = [];
+  const headings: HeadingItem[] = [];
+  const images: ImageItem[] = [];
+  const links: LinkItem[] = [];
+  const jsonLdItems: JsonLdItem[] = [];
+
+  // 1. <html lang="..."> (common in +layout.svelte or root template)
+  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),
+      };
+    }
+  }
+
+  // 2. <svelte:head> block
+  const svelteHeadMatch = /<svelte:head>([\s\S]*?)<\/svelte:head>/i.exec(fileContent);
+  const headContent = svelteHeadMatch && svelteHeadMatch[1] ? svelteHeadMatch[1] : '';
+  const headOffset = svelteHeadMatch ? svelteHeadMatch.index : 0;
+
+  if (headContent) {
+    // Title inside <svelte:head>
+    const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(headContent);
+    if (titleMatch) {
+      const rawVal = (titleMatch[1] ?? '').trim();
+      const line = lineNumberAtOffset(fileContent, headOffset + titleMatch.index);
+      if (/\{[^}]+\}/.test(rawVal)) {
+        title = { value: '[Valeur dynamique]', line };
+        isDynamic = true;
+      } else {
+        title = { value: rawVal.replace(/\s+/g, ' '), line };
+      }
+    }
+
+    // Meta tags inside <svelte:head>
+    const metaRegex = /<meta\b([^>]*?)\/?>/gi;
+    let mMatch: RegExpExecArray | null;
+    while ((mMatch = metaRegex.exec(headContent)) !== null) {
+      const attrs = mMatch[1] ?? '';
+      const line = lineNumberAtOffset(fileContent, headOffset + mMatch.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;
+      }
+    }
+
+    // Canonical link inside <svelte:head>
+    const linkRegex = /<link\b([^>]*?)\/?>/gi;
+    let lMatch: RegExpExecArray | null;
+    while ((lMatch = linkRegex.exec(headContent)) !== null) {
+      const attrs = lMatch[1] ?? '';
+      const line = lineNumberAtOffset(fileContent, headOffset + lMatch.index);
+      const relVal = getAttr(attrs, 'rel')?.toLowerCase();
+      const hrefVal = getAttr(attrs, 'href');
+      if (relVal === 'canonical' && hrefVal !== null && !canonical) {
+        canonical = { value: hrefVal, line };
+      }
+    }
+  }
+
+  // Fallback direct <title> if outside <svelte:head>
+  if (!title) {
+    const directTitleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(fileContent);
+    if (directTitleMatch) {
+      const rawVal = (directTitleMatch[1] ?? '').trim();
+      const line = lineNumberAtOffset(fileContent, directTitleMatch.index);
+      if (/\{[^}]+\}/.test(rawVal)) {
+        title = { value: '[Valeur dynamique]', line };
+        isDynamic = true;
+      } else {
+        title = { value: rawVal.replace(/\s+/g, ' '), line };
+      }
+    }
+  }
+
+  // 3. Headings: <h1> to <h6>
+  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),
+    });
+  }
+
+  // 4. 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();
+      links.push({
+        toUrl: href,
+        anchorText,
+        kind: href.startsWith('http://') || href.startsWith('https://') ? 'external' : 'internal',
+        rel: getAttr(attrs, 'rel'),
+        line: lineNumberAtOffset(fileContent, aMatch.index),
+      });
+    }
+  }
+
+  return {
+    route,
+    title,
+    description,
+    canonical,
+    robots,
+    htmlLang,
+    headings,
+    openGraph,
+    hreflang,
+    images,
+    links,
+    jsonLdItems,
+    isDynamic,
+  };
+}
+