rezo 1.0.66 → 1.0.68

package/dist/wget/link-converter.cjs

@@ -0,0 +1,297 @@
+const { promises: fs } = require("node:fs");
+const { dirname, relative, join, extname } = require("node:path");
+const { parseHTML } = require('../dom/index.cjs');
+
+class LinkConverter {
+  options;
+  onEvent;
+  constructor(options) {
+    this.options = options;
+  }
+  setEventHandler(handler) {
+    this.onEvent = handler;
+  }
+  async convertLinks(outputDir, urlMap) {
+    const stats = {
+      filesProcessed: 0,
+      filesModified: 0,
+      linksConverted: 0,
+      linksToRelative: 0,
+      linksToAbsolute: 0
+    };
+    const filesToProcess = Array.from(urlMap.values()).filter((path) => {
+      const ext = extname(path).toLowerCase();
+      return [".html", ".htm", ".xhtml", ".css"].includes(ext);
+    });
+    this.emitEvent({
+      phase: "start",
+      totalFiles: filesToProcess.length
+    });
+    for (const relativePath of filesToProcess) {
+      const fullPath = join(outputDir, relativePath);
+      try {
+        const ext = extname(relativePath).toLowerCase();
+        const content = await fs.readFile(fullPath, "utf-8");
+        let converted;
+        let linkCount;
+        if (ext === ".css") {
+          const result = this.convertCSSLinks(content, urlMap, relativePath, outputDir);
+          converted = result.content;
+          linkCount = result.linksConverted;
+          stats.linksToRelative += result.linksToRelative;
+          stats.linksToAbsolute += result.linksToAbsolute;
+        } else {
+          const result = this.convertHTMLLinks(content, urlMap, relativePath, outputDir);
+          converted = result.content;
+          linkCount = result.linksConverted;
+          stats.linksToRelative += result.linksToRelative;
+          stats.linksToAbsolute += result.linksToAbsolute;
+        }
+        stats.filesProcessed++;
+        stats.linksConverted += linkCount;
+        if (converted !== content) {
+          if (this.options.backupConverted) {
+            await fs.copyFile(fullPath, fullPath + ".orig");
+          }
+          await fs.writeFile(fullPath, converted, "utf-8");
+          stats.filesModified++;
+        }
+      } catch (error) {
+        console.warn(`Failed to convert links in ${fullPath}:`, error);
+      }
+    }
+    this.emitEvent({
+      phase: "complete",
+      totalFiles: filesToProcess.length,
+      convertedFiles: stats.filesModified,
+      linksConverted: stats.linksConverted
+    });
+    return stats;
+  }
+  convertHTMLLinks(html, urlMap, baseFile, outputDir) {
+    let linksConverted = 0;
+    let linksToRelative = 0;
+    let linksToAbsolute = 0;
+    const { document } = parseHTML(html);
+    const urlAttributes = {
+      a: ["href"],
+      area: ["href"],
+      link: ["href"],
+      script: ["src"],
+      img: ["src", "srcset"],
+      source: ["src", "srcset"],
+      video: ["src", "poster"],
+      audio: ["src"],
+      track: ["src"],
+      iframe: ["src"],
+      frame: ["src"],
+      embed: ["src"],
+      object: ["data"],
+      form: ["action"],
+      input: ["src"]
+    };
+    for (const [tag, attrs] of Object.entries(urlAttributes)) {
+      const elements = Array.from(document.querySelectorAll(tag));
+      for (const element of elements) {
+        for (const attr of attrs) {
+          const value = element.getAttribute(attr);
+          if (!value)
+            continue;
+          if (attr === "srcset") {
+            const converted = this.convertSrcset(value, urlMap, baseFile);
+            if (converted !== value) {
+              element.setAttribute(attr, converted);
+              linksConverted++;
+            }
+            continue;
+          }
+          if (this.isSpecialUrl(value))
+            continue;
+          const result = this.convertUrl(value, urlMap, baseFile);
+          if (result.converted !== value) {
+            element.setAttribute(attr, result.converted);
+            linksConverted++;
+            if (result.type === "relative") {
+              linksToRelative++;
+            } else {
+              linksToAbsolute++;
+            }
+          }
+        }
+      }
+    }
+    const elementsWithStyle = Array.from(document.querySelectorAll("[style]"));
+    for (const element of elementsWithStyle) {
+      const style = element.getAttribute("style");
+      if (style && style.includes("url(")) {
+        const converted = this.convertCSSUrls(style, urlMap, baseFile);
+        if (converted !== style) {
+          element.setAttribute("style", converted);
+          linksConverted++;
+        }
+      }
+    }
+    const styleTags = Array.from(document.querySelectorAll("style"));
+    for (const styleTag of styleTags) {
+      const content = styleTag.textContent;
+      if (content && content.includes("url(")) {
+        const converted = this.convertCSSUrls(content, urlMap, baseFile);
+        if (converted !== content) {
+          styleTag.textContent = converted;
+          linksConverted++;
+        }
+      }
+    }
+    const serialized = document.toString();
+    return {
+      content: serialized,
+      linksConverted,
+      linksToRelative,
+      linksToAbsolute
+    };
+  }
+  convertCSSLinks(css, urlMap, baseFile, outputDir) {
+    let linksConverted = 0;
+    let linksToRelative = 0;
+    let linksToAbsolute = 0;
+    let converted = css.replace(/@import\s+(?:url\s*\(\s*)?(['"]?)([^'"\)\s;]+)\1\s*\)?/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      if (result.converted !== url) {
+        linksConverted++;
+        if (result.type === "relative") {
+          linksToRelative++;
+        } else {
+          linksToAbsolute++;
+        }
+      }
+      return `@import url(${quote}${result.converted}${quote})`;
+    });
+    converted = converted.replace(/url\s*\(\s*(['"]?)([^'"\)]+)\1\s*\)/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      if (result.converted !== url) {
+        linksConverted++;
+        if (result.type === "relative") {
+          linksToRelative++;
+        } else {
+          linksToAbsolute++;
+        }
+      }
+      return `url(${quote}${result.converted}${quote})`;
+    });
+    return {
+      content: converted,
+      linksConverted,
+      linksToRelative,
+      linksToAbsolute
+    };
+  }
+  convertCSSUrls(css, urlMap, baseFile) {
+    return css.replace(/url\s*\(\s*(['"]?)([^'"\)]+)\1\s*\)/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      return `url(${quote}${result.converted}${quote})`;
+    });
+  }
+  convertSrcset(srcset, urlMap, baseFile) {
+    const parts = srcset.split(",").map((part) => {
+      const trimmed = part.trim();
+      const spaceIndex = trimmed.search(/\s/);
+      if (spaceIndex === -1) {
+        const result = this.convertUrl(trimmed, urlMap, baseFile);
+        return result.converted;
+      }
+      const url = trimmed.substring(0, spaceIndex);
+      const descriptor = trimmed.substring(spaceIndex);
+      const result = this.convertUrl(url, urlMap, baseFile);
+      return result.converted + descriptor;
+    });
+    return parts.join(", ");
+  }
+  convertUrl(url, urlMap, baseFile) {
+    const normalizedUrl = this.normalizeUrl(url);
+    const localPath = urlMap.get(normalizedUrl) || urlMap.get(url);
+    if (localPath) {
+      const baseDir = dirname(baseFile);
+      const relativePath = this.getRelativePath(baseDir, localPath);
+      return { converted: relativePath, type: "relative" };
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return { converted: url, type: "absolute" };
+    }
+    if (url.startsWith("/")) {
+      const baseDir = dirname(baseFile);
+      const parts = baseDir.split("/").filter((p) => p && p !== ".");
+      if (parts.length > 0) {
+        const firstPart = parts[0];
+        if (firstPart.includes(".")) {
+          const targetPath = firstPart + url;
+          const relativePath = this.getRelativePath(baseDir, targetPath);
+          return { converted: relativePath, type: "relative" };
+        }
+        const matchingPath = this.findSiteRootUrlInMap(url, urlMap);
+        if (matchingPath) {
+          const relativePath = this.getRelativePath(baseDir, matchingPath);
+          return { converted: relativePath, type: "relative" };
+        }
+        const depth = parts.length;
+        const prefix = depth > 0 ? "../".repeat(depth) : "./";
+        return { converted: prefix + url.slice(1), type: "relative" };
+      }
+      return { converted: "." + url, type: "relative" };
+    }
+    if (!url.startsWith("./") && !url.startsWith("../")) {
+      return { converted: "./" + url, type: "relative" };
+    }
+    return { converted: url, type: "relative" };
+  }
+  getRelativePath(from, to) {
+    let relativePath = relative(from, to);
+    relativePath = relativePath.replace(/\\/g, "/");
+    if (!relativePath.startsWith("../") && !relativePath.startsWith("./")) {
+      relativePath = "./" + relativePath;
+    }
+    return relativePath;
+  }
+  findSiteRootUrlInMap(siteRootUrl, urlMap) {
+    for (const [fullUrl, localPath] of urlMap) {
+      try {
+        const parsed = new URL(fullUrl);
+        if (parsed.pathname === siteRootUrl) {
+          return localPath;
+        }
+      } catch {}
+    }
+    return;
+  }
+  normalizeUrl(url) {
+    try {
+      const parsed = new URL(url);
+      if (parsed.pathname !== "/" && parsed.pathname.endsWith("/")) {
+        parsed.pathname = parsed.pathname.slice(0, -1);
+      }
+      if (parsed.protocol === "http:" && parsed.port === "80" || parsed.protocol === "https:" && parsed.port === "443") {
+        parsed.port = "";
+      }
+      return parsed.href;
+    } catch {
+      return url;
+    }
+  }
+  isSpecialUrl(url) {
+    return url.startsWith("data:") || url.startsWith("javascript:") || url.startsWith("mailto:") || url.startsWith("tel:") || url.startsWith("#") || url.startsWith("blob:");
+  }
+  emitEvent(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+}
+
+exports.LinkConverter = LinkConverter;
+exports.default = LinkConverter;
+module.exports = Object.assign(LinkConverter, exports);

package/dist/wget/link-converter.js

@@ -0,0 +1,294 @@
+import { promises as fs } from "node:fs";
+import { dirname, relative, join, extname } from "node:path";
+import { parseHTML } from '../dom/index.js';
+
+export class LinkConverter {
+  options;
+  onEvent;
+  constructor(options) {
+    this.options = options;
+  }
+  setEventHandler(handler) {
+    this.onEvent = handler;
+  }
+  async convertLinks(outputDir, urlMap) {
+    const stats = {
+      filesProcessed: 0,
+      filesModified: 0,
+      linksConverted: 0,
+      linksToRelative: 0,
+      linksToAbsolute: 0
+    };
+    const filesToProcess = Array.from(urlMap.values()).filter((path) => {
+      const ext = extname(path).toLowerCase();
+      return [".html", ".htm", ".xhtml", ".css"].includes(ext);
+    });
+    this.emitEvent({
+      phase: "start",
+      totalFiles: filesToProcess.length
+    });
+    for (const relativePath of filesToProcess) {
+      const fullPath = join(outputDir, relativePath);
+      try {
+        const ext = extname(relativePath).toLowerCase();
+        const content = await fs.readFile(fullPath, "utf-8");
+        let converted;
+        let linkCount;
+        if (ext === ".css") {
+          const result = this.convertCSSLinks(content, urlMap, relativePath, outputDir);
+          converted = result.content;
+          linkCount = result.linksConverted;
+          stats.linksToRelative += result.linksToRelative;
+          stats.linksToAbsolute += result.linksToAbsolute;
+        } else {
+          const result = this.convertHTMLLinks(content, urlMap, relativePath, outputDir);
+          converted = result.content;
+          linkCount = result.linksConverted;
+          stats.linksToRelative += result.linksToRelative;
+          stats.linksToAbsolute += result.linksToAbsolute;
+        }
+        stats.filesProcessed++;
+        stats.linksConverted += linkCount;
+        if (converted !== content) {
+          if (this.options.backupConverted) {
+            await fs.copyFile(fullPath, fullPath + ".orig");
+          }
+          await fs.writeFile(fullPath, converted, "utf-8");
+          stats.filesModified++;
+        }
+      } catch (error) {
+        console.warn(`Failed to convert links in ${fullPath}:`, error);
+      }
+    }
+    this.emitEvent({
+      phase: "complete",
+      totalFiles: filesToProcess.length,
+      convertedFiles: stats.filesModified,
+      linksConverted: stats.linksConverted
+    });
+    return stats;
+  }
+  convertHTMLLinks(html, urlMap, baseFile, outputDir) {
+    let linksConverted = 0;
+    let linksToRelative = 0;
+    let linksToAbsolute = 0;
+    const { document } = parseHTML(html);
+    const urlAttributes = {
+      a: ["href"],
+      area: ["href"],
+      link: ["href"],
+      script: ["src"],
+      img: ["src", "srcset"],
+      source: ["src", "srcset"],
+      video: ["src", "poster"],
+      audio: ["src"],
+      track: ["src"],
+      iframe: ["src"],
+      frame: ["src"],
+      embed: ["src"],
+      object: ["data"],
+      form: ["action"],
+      input: ["src"]
+    };
+    for (const [tag, attrs] of Object.entries(urlAttributes)) {
+      const elements = Array.from(document.querySelectorAll(tag));
+      for (const element of elements) {
+        for (const attr of attrs) {
+          const value = element.getAttribute(attr);
+          if (!value)
+            continue;
+          if (attr === "srcset") {
+            const converted = this.convertSrcset(value, urlMap, baseFile);
+            if (converted !== value) {
+              element.setAttribute(attr, converted);
+              linksConverted++;
+            }
+            continue;
+          }
+          if (this.isSpecialUrl(value))
+            continue;
+          const result = this.convertUrl(value, urlMap, baseFile);
+          if (result.converted !== value) {
+            element.setAttribute(attr, result.converted);
+            linksConverted++;
+            if (result.type === "relative") {
+              linksToRelative++;
+            } else {
+              linksToAbsolute++;
+            }
+          }
+        }
+      }
+    }
+    const elementsWithStyle = Array.from(document.querySelectorAll("[style]"));
+    for (const element of elementsWithStyle) {
+      const style = element.getAttribute("style");
+      if (style && style.includes("url(")) {
+        const converted = this.convertCSSUrls(style, urlMap, baseFile);
+        if (converted !== style) {
+          element.setAttribute("style", converted);
+          linksConverted++;
+        }
+      }
+    }
+    const styleTags = Array.from(document.querySelectorAll("style"));
+    for (const styleTag of styleTags) {
+      const content = styleTag.textContent;
+      if (content && content.includes("url(")) {
+        const converted = this.convertCSSUrls(content, urlMap, baseFile);
+        if (converted !== content) {
+          styleTag.textContent = converted;
+          linksConverted++;
+        }
+      }
+    }
+    const serialized = document.toString();
+    return {
+      content: serialized,
+      linksConverted,
+      linksToRelative,
+      linksToAbsolute
+    };
+  }
+  convertCSSLinks(css, urlMap, baseFile, outputDir) {
+    let linksConverted = 0;
+    let linksToRelative = 0;
+    let linksToAbsolute = 0;
+    let converted = css.replace(/@import\s+(?:url\s*\(\s*)?(['"]?)([^'"\)\s;]+)\1\s*\)?/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      if (result.converted !== url) {
+        linksConverted++;
+        if (result.type === "relative") {
+          linksToRelative++;
+        } else {
+          linksToAbsolute++;
+        }
+      }
+      return `@import url(${quote}${result.converted}${quote})`;
+    });
+    converted = converted.replace(/url\s*\(\s*(['"]?)([^'"\)]+)\1\s*\)/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      if (result.converted !== url) {
+        linksConverted++;
+        if (result.type === "relative") {
+          linksToRelative++;
+        } else {
+          linksToAbsolute++;
+        }
+      }
+      return `url(${quote}${result.converted}${quote})`;
+    });
+    return {
+      content: converted,
+      linksConverted,
+      linksToRelative,
+      linksToAbsolute
+    };
+  }
+  convertCSSUrls(css, urlMap, baseFile) {
+    return css.replace(/url\s*\(\s*(['"]?)([^'"\)]+)\1\s*\)/gi, (match, quote, url) => {
+      if (this.isSpecialUrl(url))
+        return match;
+      const result = this.convertUrl(url, urlMap, baseFile);
+      return `url(${quote}${result.converted}${quote})`;
+    });
+  }
+  convertSrcset(srcset, urlMap, baseFile) {
+    const parts = srcset.split(",").map((part) => {
+      const trimmed = part.trim();
+      const spaceIndex = trimmed.search(/\s/);
+      if (spaceIndex === -1) {
+        const result = this.convertUrl(trimmed, urlMap, baseFile);
+        return result.converted;
+      }
+      const url = trimmed.substring(0, spaceIndex);
+      const descriptor = trimmed.substring(spaceIndex);
+      const result = this.convertUrl(url, urlMap, baseFile);
+      return result.converted + descriptor;
+    });
+    return parts.join(", ");
+  }
+  convertUrl(url, urlMap, baseFile) {
+    const normalizedUrl = this.normalizeUrl(url);
+    const localPath = urlMap.get(normalizedUrl) || urlMap.get(url);
+    if (localPath) {
+      const baseDir = dirname(baseFile);
+      const relativePath = this.getRelativePath(baseDir, localPath);
+      return { converted: relativePath, type: "relative" };
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return { converted: url, type: "absolute" };
+    }
+    if (url.startsWith("/")) {
+      const baseDir = dirname(baseFile);
+      const parts = baseDir.split("/").filter((p) => p && p !== ".");
+      if (parts.length > 0) {
+        const firstPart = parts[0];
+        if (firstPart.includes(".")) {
+          const targetPath = firstPart + url;
+          const relativePath = this.getRelativePath(baseDir, targetPath);
+          return { converted: relativePath, type: "relative" };
+        }
+        const matchingPath = this.findSiteRootUrlInMap(url, urlMap);
+        if (matchingPath) {
+          const relativePath = this.getRelativePath(baseDir, matchingPath);
+          return { converted: relativePath, type: "relative" };
+        }
+        const depth = parts.length;
+        const prefix = depth > 0 ? "../".repeat(depth) : "./";
+        return { converted: prefix + url.slice(1), type: "relative" };
+      }
+      return { converted: "." + url, type: "relative" };
+    }
+    if (!url.startsWith("./") && !url.startsWith("../")) {
+      return { converted: "./" + url, type: "relative" };
+    }
+    return { converted: url, type: "relative" };
+  }
+  getRelativePath(from, to) {
+    let relativePath = relative(from, to);
+    relativePath = relativePath.replace(/\\/g, "/");
+    if (!relativePath.startsWith("../") && !relativePath.startsWith("./")) {
+      relativePath = "./" + relativePath;
+    }
+    return relativePath;
+  }
+  findSiteRootUrlInMap(siteRootUrl, urlMap) {
+    for (const [fullUrl, localPath] of urlMap) {
+      try {
+        const parsed = new URL(fullUrl);
+        if (parsed.pathname === siteRootUrl) {
+          return localPath;
+        }
+      } catch {}
+    }
+    return;
+  }
+  normalizeUrl(url) {
+    try {
+      const parsed = new URL(url);
+      if (parsed.pathname !== "/" && parsed.pathname.endsWith("/")) {
+        parsed.pathname = parsed.pathname.slice(0, -1);
+      }
+      if (parsed.protocol === "http:" && parsed.port === "80" || parsed.protocol === "https:" && parsed.port === "443") {
+        parsed.port = "";
+      }
+      return parsed.href;
+    } catch {
+      return url;
+    }
+  }
+  isSpecialUrl(url) {
+    return url.startsWith("data:") || url.startsWith("javascript:") || url.startsWith("mailto:") || url.startsWith("tel:") || url.startsWith("#") || url.startsWith("blob:");
+  }
+  emitEvent(event) {
+    if (this.onEvent) {
+      this.onEvent(event);
+    }
+  }
+}
+export default LinkConverter;