@artinstack/migrator 0.1.2 → 0.1.3

package/dist/{chunk-VXEHAQKK.js → chunk-QEXTXHFG.js}

@@ -7,13 +7,138 @@ import {
   validateSquarespaceExportFile
 } from "./chunk-HH7666MQ.js";
 import {
-  discoverContentAssetUrls
+  discoverContentAssetUrls,
+  normalizeAssetUrl
 } from "./chunk-2PNSVE5Y.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/`
+      }
+    ]
+  };
+}
+
 // src/parsers/wordpress/parse-wxr.ts
 import { readFile } from "fs/promises";
 import { basename } from "path";
 import { XMLParser } from "fast-xml-parser";
+
+// src/parsers/wordpress/builders/registry.ts
+var WORDPRESS_BUILDER_REGISTRY = [
+  {
+    id: "tatsu",
+    detect: /\[(?:\/)?tatsu_/i,
+    contentRules: [
+      { shortcodePrefix: "tatsu_image", urlParams: ["image", "url", "src"], tag: "img" },
+      { shortcodePrefix: "tatsu_video", urlParams: ["video", "src", "url"], tag: "video" }
+    ],
+    scaffoldingPrefix: "tatsu_"
+  },
+  {
+    id: "divi",
+    detect: /\[(?:\/)?et_pb_/i,
+    contentRules: [{ shortcodePrefix: "et_pb_image", urlParams: ["src", "url"], tag: "img" }],
+    scaffoldingPrefix: "et_pb_"
+  },
+  {
+    id: "elementor",
+    detect: /\[(?:\/)?elementor[-_]/i,
+    contentRules: [
+      { shortcodePrefix: "elementor-widget", urlParams: ["url", "src", "image"], tag: "img" }
+    ],
+    scaffoldingPrefix: "elementor_"
+  }
+];
+
+// src/parsers/wordpress/builders/flatten.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractShortcodeParam(params, names) {
+  for (const name of names) {
+    const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*["']([^"']+)["']`, "i");
+    const match = params.match(pattern);
+    if (match?.[1]?.trim()) return match[1].trim();
+  }
+  return void 0;
+}
+function emitHtmlTag(tag, url) {
+  const normalized = normalizeAssetUrl(url) ?? url;
+  const escaped = normalized.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  switch (tag) {
+    case "img":
+      return `<img src="${escaped}" alt="" />`;
+    case "video":
+      return `<video src="${escaped}" controls></video>`;
+    case "iframe":
+      return `<iframe src="${escaped}" loading="lazy"></iframe>`;
+  }
+}
+function convertContentBlocker(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}([^\\]]*)\\]\\s*(?:\\[\\/${prefix}[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, (block, params) => {
+    const url = extractShortcodeParam(params, rule.urlParams);
+    if (!url) return block;
+    return emitHtmlTag(rule.tag, url);
+  });
+}
+function stripScaffolding(content, prefix) {
+  const escaped = escapeRegExp(prefix);
+  const opener = new RegExp(`\\[${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  const closer = new RegExp(`\\[\\/${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  return content.replace(opener, "").replace(closer, "");
+}
+function detectThemes(content, registry) {
+  return registry.filter((theme) => theme.detect.test(content));
+}
+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;
+  for (const theme of themes) {
+    for (const rule of theme.contentRules) {
+      html = convertContentBlocker(html, rule);
+    }
+    html = stripScaffolding(html, theme.scaffoldingPrefix);
+  }
+  html = html.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    html,
+    detectedThemes: themes.map((theme) => theme.id)
+  };
+}
+
+// src/parsers/wordpress/parse-wxr.ts
 var PLATFORM = "wordpress";
 function asArray(value) {
   if (value === void 0) return [];
@@ -80,13 +205,16 @@ function parseItems(xml) {
   const doc = parser.parse(xml);
   return asArray(doc.rss?.channel?.item);
 }
-function buildAttachmentIndex(items) {
+function buildAttachmentIndex(items, originUrlRewrite) {
   const index = /* @__PURE__ */ new Map();
   for (const item of items) {
     if (textValue(item.post_type) !== "attachment") continue;
     const id = textValue(item.post_id);
-    const url = textValue(item.attachment_url) || textValue(item.link);
+    let url = textValue(item.attachment_url) || textValue(item.link);
     if (!id || !url) continue;
+    if (originUrlRewrite) {
+      url = rewriteOriginUrlsInText(url, originUrlRewrite);
+    }
     const filename = basename(new URL(url, "http://local.invalid").pathname) || `attachment-${id}`;
     index.set(id, {
       sourceUrl: url,
@@ -171,10 +299,27 @@ function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt) {
   }
   return assets;
 }
+function preprocessContent(rawHtml, options) {
+  let html = rawHtml;
+  if (options.originUrlRewrite) {
+    html = rewriteOriginUrlsInText(html, options.originUrlRewrite);
+  }
+  if (options.flattenBuilders !== false) {
+    html = flattenWordPressBuilders(html).html;
+  }
+  return html;
+}
+function resolveFeaturedAssetSourceId(thumbnailId, attachmentIndex, contentHtml) {
+  if (thumbnailId && attachmentIndex.has(thumbnailId)) {
+    return thumbnailId;
+  }
+  const firstInline = discoverContentAssetUrls(contentHtml)[0];
+  return firstInline ? `url:${firstInline}` : void 0;
+}
 async function* enumerateWxrEntities(options) {
   const xml = await readFile(options.filePath, "utf8");
   const items = parseItems(xml);
-  const attachmentIndex = buildAttachmentIndex(items);
+  const attachmentIndex = buildAttachmentIndex(items, options.originUrlRewrite);
   const { categories, tags } = collectTaxonomies(items);
   const seenAssetUrls = /* @__PURE__ */ new Set();
   const emittedAttachmentIds = /* @__PURE__ */ new Set();
@@ -203,9 +348,9 @@ async function* enumerateWxrEntities(options) {
     const id = textValue(item.post_id);
     const link = textValue(item.link);
     const slug = sanitizeSlug(textValue(item.post_name) || textValue(item.title) || id);
-    const rawHtml = getContentEncoded(item);
+    const contentHtml = preprocessContent(getContentEncoded(item), options);
     for (const asset of collectInlineAssets(
-      rawHtml,
+      contentHtml,
       attachmentIndex,
       seenAssetUrls,
       options.exportedAt
@@ -223,10 +368,11 @@ async function* enumerateWxrEntities(options) {
     }
     if (postType === "post") {
       const thumbnailId = getPostMeta(item, "_thumbnail_id");
-      let featuredAssetSourceId;
-      if (thumbnailId && attachmentIndex.has(thumbnailId)) {
-        featuredAssetSourceId = thumbnailId;
-      }
+      const featuredAssetSourceId = resolveFeaturedAssetSourceId(
+        thumbnailId,
+        attachmentIndex,
+        contentHtml
+      );
       const post = {
         type: "post",
         source: sourceMeta(id, link, options.exportedAt),
@@ -234,7 +380,7 @@ async function* enumerateWxrEntities(options) {
         title: textValue(item.title) || slug,
         slug,
         excerpt: getExcerpt(item) || void 0,
-        contentHtml: rawHtml,
+        contentHtml,
         publishedAt: textValue(item.post_date) || void 0,
         status: mapPublishStatus(textValue(item.status)),
         categorySlugs: categorySlugs.length ? categorySlugs : void 0,
@@ -251,7 +397,7 @@ async function* enumerateWxrEntities(options) {
         sourceId: id,
         title: textValue(item.title) || slug,
         slug,
-        contentHtml: rawHtml,
+        contentHtml,
         isHomePage: isHomePage || void 0,
         status: mapPublishStatus(textValue(item.status))
       };
@@ -291,18 +437,25 @@ async function validateWxrFile(filePath) {
 }
 
 // src/parsers/wordpress/index.ts
-function resolvePath(input) {
-  if (typeof input === "string") return input;
+function resolveWxrOptions(input) {
+  if (typeof input === "string") {
+    return { filePath: input };
+  }
   if (input && typeof input === "object" && "path" in input) {
-    return String(input.path);
+    const obj = input;
+    return {
+      filePath: String(obj.path),
+      originUrlRewrite: obj.originUrlRewrite,
+      flattenBuilders: obj.flattenBuilders
+    };
   }
-  throw new Error("WordPress adapter requires input path (string or { path })");
+  throw new Error("WordPress adapter requires input path (string or { path, originUrlRewrite?, flattenBuilders? })");
 }
 var wordpressAdapter = {
   platform: "wordpress",
   async validateInput(input) {
-    const path = resolvePath(input);
-    const result = await validateWxrFile(path);
+    const { filePath } = resolveWxrOptions(input);
+    const result = await validateWxrFile(filePath);
     return {
       ok: result.ok,
       issues: result.issues,
@@ -310,8 +463,7 @@ var wordpressAdapter = {
     };
   },
   enumerateEntities(ctx) {
-    const path = resolvePath(ctx.input);
-    return enumerateWxrEntities({ filePath: path });
+    return enumerateWxrEntities(resolveWxrOptions(ctx.input));
   }
 };
 
@@ -2272,6 +2424,8 @@ function getAdapter(platform) {
 }
 
 export {
+  rewriteOriginUrlsInText,
+  createWpContentGatewayRewrite,
   wordpressAdapter,
   SMUGMUG_API_BASE,
   SMUGMUG_OAUTH_ENDPOINTS,
@@ -2287,4 +2441,4 @@ export {
   wixAdapter,
   getAdapter
 };
-//# sourceMappingURL=chunk-VXEHAQKK.js.map
+//# sourceMappingURL=chunk-QEXTXHFG.js.map