@artinstack/migrator 0.1.6 → 0.1.8

package/dist/{chunk-XQVKA54A.js → chunk-CB5KRANW.js}

@@ -1,44 +1,28 @@
 import {
   SquarespaceCollectionClient,
   WORDPRESS_BUILDER_REGISTRY,
+  WORDPRESS_WIDGET_REGISTRY,
+  WP_WIDGET_PLACEHOLDER,
   enumerateSquarespaceEntities,
-  linkToPath,
-  sanitizeSlug,
   summarizeSquarespaceExport,
   validateSquarespaceExportFile
-} from "./chunk-IPYHS5R2.js";
+} from "./chunk-Z3L6N63Y.js";
+import {
+  stampMigrationMediaRefs
+} from "./chunk-KYNKJ4XV.js";
+import {
+  linkToPath,
+  sanitizeSlug
+} from "./chunk-XRCF73DA.js";
 import {
+  buildContentMediaUrlIndex,
+  canonicalizeInlineAssetUrl,
   discoverContentAssetUrls,
   normalizeAssetUrl,
-  resolveFeaturedContentAssetUrl
-} from "./chunk-XYP3VYDH.js";
-
-// src/lib/origin-url-rewrite.ts
-function rewriteOriginUrlsInText(text, config) {
-  if (!text || config.rules.length === 0) return text;
-  let result = text;
-  for (const rule of config.rules) {
-    if (typeof rule.match === "string") {
-      if (!rule.match) continue;
-      result = result.split(rule.match).join(rule.replace);
-      continue;
-    }
-    result = result.replace(rule.match, rule.replace);
-  }
-  return result;
-}
-function createWpContentGatewayRewrite(gatewayBase, publicOrigin) {
-  const normalizedGateway = gatewayBase.replace(/\/$/, "");
-  const normalizedPublic = publicOrigin.replace(/\/$/, "");
-  return {
-    rules: [
-      {
-        match: `${normalizedGateway}/wp-content/`,
-        replace: `${normalizedPublic}/wp-content/`
-      }
-    ]
-  };
-}
+  parseMigrationMediaRef,
+  resolveFeaturedContentAssetUrl,
+  rewriteOriginUrlsInText
+} from "./chunk-WHGUE5FC.js";
 
 // src/parsers/wordpress/parse-wxr.ts
 import { readFile } from "fs/promises";
@@ -312,16 +296,195 @@ function stripLegacyTokens(content, tokens) {
 function detectThemes(content, registry) {
   return registry.filter((theme) => theme.detect.test(content));
 }
+function extractBareOrQuotedParam(params, name) {
+  const quoted = extractQuotedParam(params, name);
+  if (quoted) return quoted;
+  const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*([^\\s"'\\]]+)`, "i");
+  const match = pattern.exec(params);
+  return match?.[1]?.trim() || void 0;
+}
+function emitWidgetStub(widget, attrs, tag = "div") {
+  const parts = [`data-wp-widget="${escapeLayoutAttr(widget)}"`];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value) parts.push(`${key}="${escapeLayoutAttr(value)}"`);
+  }
+  return `<${tag} ${parts.join(" ")}>${WP_WIDGET_PLACEHOLDER}</${tag}>`;
+}
+function normalizeVideoEmbedUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.startsWith("data:")) return void 0;
+  try {
+    const url = new URL(trimmed.startsWith("//") ? `https:${trimmed}` : trimmed);
+    const host = url.hostname.replace(/^www\./, "").replace(/^m\./, "");
+    if (host === "youtu.be") {
+      const id = url.pathname.split("/").filter(Boolean)[0];
+      if (id) {
+        return { provider: "youtube", embedUrl: `https://www.youtube-nocookie.com/embed/${id}` };
+      }
+    }
+    if (host === "youtube.com" || host === "youtube-nocookie.com") {
+      const embedMatch = url.pathname.match(/\/embed\/([^/?#]+)/);
+      if (embedMatch?.[1]) {
+        const start = url.searchParams.get("start");
+        const suffix = start ? `?start=${start}` : "";
+        return {
+          provider: "youtube",
+          embedUrl: `https://www.youtube-nocookie.com/embed/${embedMatch[1]}${suffix}`
+        };
+      }
+      const videoId = url.searchParams.get("v");
+      if (videoId) {
+        const t = url.searchParams.get("t") ?? url.searchParams.get("start");
+        const startSeconds = t?.endsWith("s") ? t.slice(0, -1) : t;
+        const suffix = startSeconds ? `?start=${startSeconds}` : "";
+        return {
+          provider: "youtube",
+          embedUrl: `https://www.youtube-nocookie.com/embed/${videoId}${suffix}`
+        };
+      }
+    }
+    if (host === "vimeo.com") {
+      const segments = url.pathname.split("/").filter(Boolean);
+      const id = segments[segments.length - 1];
+      if (id && /^\d+$/.test(id)) {
+        return { provider: "vimeo", embedUrl: `https://player.vimeo.com/video/${id}` };
+      }
+    }
+    if (host === "player.vimeo.com") {
+      const match = url.pathname.match(/\/video\/(\d+)/);
+      if (match?.[1]) {
+        return { provider: "vimeo", embedUrl: `https://player.vimeo.com/video/${match[1]}` };
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function emitVideoWidgetFromParams(params, inner) {
+  const url = extractShortcodeParam(params, ["url", "src", "video", "link", "youtube_url", "vimeo_url"]) ?? inner.trim().match(/^https?:\/\/\S+/)?.[0];
+  if (!url) {
+    return emitWidgetStub("video", { "data-video-provider": "external" });
+  }
+  const normalized = normalizeVideoEmbedUrl(url);
+  if (normalized) {
+    return emitWidgetStub("video", {
+      "data-video-provider": normalized.provider,
+      "data-embed-url": normalized.embedUrl
+    });
+  }
+  if (/\.(mp4|webm|ogg)(\?|#|$)/i.test(url)) {
+    return emitHtmlTag("video", url);
+  }
+  return emitWidgetStub("video", {
+    "data-video-provider": "external",
+    "data-embed-url": url
+  });
+}
+function flattenMapShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const prefix of widgetRegistry.mapShortcodePrefixes) {
+    const pattern = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]\\s*(?:\\[\\/${escapeRegExp(prefix)}\\b[^\\]]*\\])?`,
+      "gi"
+    );
+    html = html.replace(pattern, (_, params) => {
+      const embedUrl = extractShortcodeParam(params, ["embed_url", "url", "src", "map_url"]);
+      const query = extractBareOrQuotedParam(params, "address") ?? extractBareOrQuotedParam(params, "q");
+      return emitWidgetStub("map", {
+        ...embedUrl?.includes("google.com/maps") ? { "data-embed-url": embedUrl } : {},
+        ...query && !embedUrl ? { "data-wp-map-query": query } : {}
+      });
+    });
+  }
+  return html;
+}
+function flattenContactFormShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const rule of widgetRegistry.contactFormRules) {
+    const pattern = new RegExp(
+      `\\[${escapeRegExp(rule.tag)}\\b([^\\]]*)\\]\\s*(?:\\[\\/${escapeRegExp(rule.tag)}\\b[^\\]]*\\])?`,
+      "gi"
+    );
+    html = html.replace(pattern, (_, params) => {
+      const id = extractBareOrQuotedParam(params, rule.idParam);
+      return emitWidgetStub(
+        "contact-form",
+        {
+          "data-wp-form-source": rule.source,
+          ...id ? { "data-wp-form-id": id } : {}
+        },
+        "section"
+      );
+    });
+  }
+  return html;
+}
+function flattenGalleryShortcodes(content, widgetRegistry) {
+  const tag = escapeRegExp(widgetRegistry.galleryShortcode);
+  const pattern = new RegExp(`\\[${tag}\\b([^\\]]*)\\](?:\\s*\\[\\/${tag}\\])?`, "gi");
+  return content.replace(pattern, (_, params) => {
+    const ids = extractBareOrQuotedParam(params, "ids");
+    const idList = ids?.split(",").map((part) => part.trim()).filter((part) => /^\d+$/.test(part));
+    if (idList?.length) {
+      const images = idList.map((id) => `<img data-wp-attachment-id="${escapeLayoutAttr(id)}" alt="" />`).join("");
+      return `<figure data-wp-inline-gallery>${images}</figure>`;
+    }
+    const category = extractBareOrQuotedParam(params, "category") ?? extractBareOrQuotedParam(params, "type");
+    return emitWidgetStub("portfolio", {
+      "data-wp-gallery-dynamic": "1",
+      ...category ? { "data-wp-portfolio-category": category } : {}
+    });
+  });
+}
+function flattenPortfolioShortcodes(content, widgetRegistry) {
+  const tag = escapeRegExp(widgetRegistry.portfolioShortcode);
+  const pattern = new RegExp(`\\[${tag}\\b([^\\]]*)\\](?:\\s*\\[\\/${tag}\\])?`, "gi");
+  return content.replace(pattern, (_, params) => {
+    const category = extractBareOrQuotedParam(params, "category");
+    const slug = extractBareOrQuotedParam(params, "slug");
+    return emitWidgetStub("portfolio", {
+      ...category ? { "data-wp-portfolio-category": category } : {},
+      ...slug ? { "data-wp-portfolio-slug": slug } : {}
+    });
+  });
+}
+function flattenVideoShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const prefix of widgetRegistry.videoShortcodePrefixes) {
+    const wrapped = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]([\\s\\S]*?)\\[\\/${escapeRegExp(prefix)}\\b[^\\]]*\\]`,
+      "gi"
+    );
+    html = html.replace(
+      wrapped,
+      (_, params, inner) => emitVideoWidgetFromParams(params, inner)
+    );
+    const selfClosing = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]`,
+      "gi"
+    );
+    html = html.replace(selfClosing, (_, params) => emitVideoWidgetFromParams(params, ""));
+  }
+  return html;
+}
+function flattenWordPressWidgets(content, widgetRegistry = WORDPRESS_WIDGET_REGISTRY) {
+  let html = content;
+  html = flattenGalleryShortcodes(html, widgetRegistry);
+  html = flattenPortfolioShortcodes(html, widgetRegistry);
+  html = flattenMapShortcodes(html, widgetRegistry);
+  html = flattenContactFormShortcodes(html, widgetRegistry);
+  html = flattenVideoShortcodes(html, widgetRegistry);
+  return html;
+}
 function flattenWordPressBuilders(content, options = {}) {
   if (!content.trim()) {
     return { html: content, detectedThemes: [] };
   }
   const registry = options.registry ?? WORDPRESS_BUILDER_REGISTRY;
   const themes = detectThemes(content, registry);
-  if (themes.length === 0) {
-    return { html: content, detectedThemes: [] };
-  }
-  let html = content;
+  const widgetRegistry = options.widgetRegistry ?? WORDPRESS_WIDGET_REGISTRY;
+  let html = flattenWordPressWidgets(content, widgetRegistry);
   for (const theme of themes) {
     for (const rule of theme.wrapperRules ?? []) {
       html = convertWrapperRule(html, rule);
@@ -435,11 +598,11 @@ function buildAttachmentIndex(items, originUrlRewrite) {
   for (const item of items) {
     if (textValue(item.post_type) !== "attachment") continue;
     const id = textValue(item.post_id);
-    let url = textValue(item.attachment_url) || textValue(item.link);
-    if (!id || !url) continue;
-    if (originUrlRewrite) {
-      url = rewriteOriginUrlsInText(url, originUrlRewrite);
-    }
+    const rawUrl = textValue(item.attachment_url) || textValue(item.link);
+    if (!id || !rawUrl) continue;
+    const canonical = canonicalizeInlineAssetUrl(rawUrl, originUrlRewrite);
+    if (!canonical) continue;
+    const url = canonical.canonicalUrl;
     const filename = basename(new URL(url, "http://local.invalid").pathname) || `attachment-${id}`;
     index.set(id, {
       sourceUrl: url,
@@ -498,22 +661,24 @@ function collectTaxonomies(items) {
   }
   return { categories, tags };
 }
-function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt) {
+function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt, originUrlRewrite) {
   const assets = [];
-  for (const src of discoverContentAssetUrls(html)) {
-    if (seenUrls.has(src)) continue;
-    seenUrls.add(src);
+  for (const discovered of discoverContentAssetUrls(html)) {
+    const canonical = canonicalizeInlineAssetUrl(discovered, originUrlRewrite);
+    if (!canonical) continue;
+    if (seenUrls.has(canonical.canonicalUrl)) continue;
+    seenUrls.add(canonical.canonicalUrl);
     let filename;
     try {
-      filename = basename(new URL(src, "http://local.invalid").pathname) || "inline-asset";
+      filename = basename(new URL(canonical.canonicalUrl, "http://local.invalid").pathname) || "inline-asset";
     } catch {
       filename = "inline-asset";
     }
     assets.push({
       type: "asset",
-      source: sourceMeta(`url:${src}`, src, exportedAt),
-      sourceId: `url:${src}`,
-      sourceUrl: src,
+      source: sourceMeta(canonical.sourceId, canonical.canonicalUrl, exportedAt),
+      sourceId: canonical.sourceId,
+      sourceUrl: canonical.canonicalUrl,
       filename,
       mimeType: guessMime(filename)
     });
@@ -534,12 +699,15 @@ function preprocessContent(rawHtml, options) {
   }
   return html;
 }
-function resolveFeaturedAssetSourceId(thumbnailId, attachmentIndex, contentHtml) {
+function resolveFeaturedAssetSourceId(thumbnailId, attachmentIndex, contentHtml, originUrlRewrite) {
   if (thumbnailId && attachmentIndex.has(thumbnailId)) {
     return thumbnailId;
   }
   const featuredUrl = resolveFeaturedContentAssetUrl(contentHtml);
-  return featuredUrl ? `url:${featuredUrl}` : void 0;
+  if (!featuredUrl) return void 0;
+  const fromRef = parseMigrationMediaRef(featuredUrl);
+  if (fromRef) return fromRef;
+  return canonicalizeInlineAssetUrl(featuredUrl, originUrlRewrite)?.sourceId;
 }
 function maybeRewriteUrl(url, config) {
   if (!url) return void 0;
@@ -578,18 +746,39 @@ async function* enumerateWxrEntities(options) {
     const id = textValue(item.post_id);
     const link = maybeRewriteUrl(textValue(item.link), options.originUrlRewrite);
     const slug = sanitizeSlug(textValue(item.post_name) || textValue(item.title) || id);
-    const contentHtml = preprocessContent(getContentEncoded(item), options);
+    let contentHtml = preprocessContent(getContentEncoded(item), options);
     if (postType === "page" && options.skipWooCommerceStubPages !== false && isWooCommerceStubPage(slug, contentHtml)) {
       continue;
     }
-    for (const asset of collectInlineAssets(
+    const inlineAssets = collectInlineAssets(
       contentHtml,
       attachmentIndex,
       seenAssetUrls,
-      options.exportedAt
-    )) {
+      options.exportedAt,
+      options.originUrlRewrite
+    );
+    for (const asset of inlineAssets) {
       yield asset;
     }
+    if (options.stampMigrationMediaRefs !== false) {
+      const urlIndex = buildContentMediaUrlIndex(
+        [
+          ...[...attachmentIndex.entries()].map(([sourceId, entry]) => ({
+            sourceId,
+            sourceUrl: entry.sourceUrl
+          })),
+          ...inlineAssets.map((asset) => ({
+            sourceId: asset.sourceId,
+            sourceUrl: asset.sourceUrl
+          }))
+        ],
+        options.originUrlRewrite
+      );
+      contentHtml = stampMigrationMediaRefs(contentHtml, {
+        urlToSourceId: urlIndex,
+        originUrlRewrite: options.originUrlRewrite
+      }).html;
+    }
     const categorySlugs = [];
     const tagSlugs = [];
     for (const cat of asArray(item.category)) {
@@ -604,7 +793,8 @@ async function* enumerateWxrEntities(options) {
       const featuredAssetSourceId = resolveFeaturedAssetSourceId(
         thumbnailId,
         attachmentIndex,
-        contentHtml
+        contentHtml,
+        options.originUrlRewrite
       );
       const post = {
         type: "post",
@@ -2660,8 +2850,6 @@ function getAdapter(platform) {
 }
 
 export {
-  rewriteOriginUrlsInText,
-  createWpContentGatewayRewrite,
   wordpressAdapter,
   SMUGMUG_API_BASE,
   SMUGMUG_OAUTH_ENDPOINTS,
@@ -2677,4 +2865,4 @@ export {
   wixAdapter,
   getAdapter
 };
-//# sourceMappingURL=chunk-XQVKA54A.js.map
+//# sourceMappingURL=chunk-CB5KRANW.js.map