rezo 1.0.66 → 1.0.68

package/dist/wget/asset-organizer.cjs

@@ -0,0 +1,230 @@
+const { createHash } = require("node:crypto");
+const { extname, basename, join } = require("node:path");
+const DEFAULT_ASSET_FOLDERS = exports.DEFAULT_ASSET_FOLDERS = {
+  css: "css",
+  js: "js",
+  images: "images",
+  fonts: "fonts",
+  audio: "audio",
+  video: "video",
+  other: "assets"
+};
+const MIME_TO_ASSET = {
+  "text/css": "css",
+  "application/javascript": "js",
+  "application/x-javascript": "js",
+  "text/javascript": "js",
+  "application/ecmascript": "js",
+  "image/jpeg": "images",
+  "image/png": "images",
+  "image/gif": "images",
+  "image/webp": "images",
+  "image/svg+xml": "images",
+  "image/x-icon": "images",
+  "image/vnd.microsoft.icon": "images",
+  "image/bmp": "images",
+  "image/tiff": "images",
+  "image/avif": "images",
+  "font/woff": "fonts",
+  "font/woff2": "fonts",
+  "font/ttf": "fonts",
+  "font/otf": "fonts",
+  "application/font-woff": "fonts",
+  "application/font-woff2": "fonts",
+  "application/x-font-ttf": "fonts",
+  "application/x-font-otf": "fonts",
+  "application/vnd.ms-fontobject": "fonts",
+  "audio/mpeg": "audio",
+  "audio/mp3": "audio",
+  "audio/wav": "audio",
+  "audio/ogg": "audio",
+  "audio/webm": "audio",
+  "audio/aac": "audio",
+  "audio/flac": "audio",
+  "video/mp4": "video",
+  "video/webm": "video",
+  "video/ogg": "video",
+  "video/quicktime": "video",
+  "video/x-msvideo": "video",
+  "video/x-ms-wmv": "video"
+};
+const EXT_TO_ASSET = {
+  ".css": "css",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jpg": "images",
+  ".jpeg": "images",
+  ".png": "images",
+  ".gif": "images",
+  ".webp": "images",
+  ".svg": "images",
+  ".ico": "images",
+  ".bmp": "images",
+  ".tiff": "images",
+  ".tif": "images",
+  ".avif": "images",
+  ".woff": "fonts",
+  ".woff2": "fonts",
+  ".ttf": "fonts",
+  ".otf": "fonts",
+  ".eot": "fonts",
+  ".mp3": "audio",
+  ".wav": "audio",
+  ".ogg": "audio",
+  ".aac": "audio",
+  ".flac": "audio",
+  ".m4a": "audio",
+  ".mp4": "video",
+  ".webm": "video",
+  ".ogv": "video",
+  ".mov": "video",
+  ".avi": "video",
+  ".wmv": "video",
+  ".mkv": "video"
+};
+
+class AssetOrganizer {
+  options;
+  hashCache;
+  urlToPath;
+  filenameVersions;
+  constructor(options) {
+    this.options = options;
+    this.hashCache = new Map;
+    this.urlToPath = new Map;
+    this.filenameVersions = new Map;
+  }
+  computeHash(content) {
+    return createHash("md5").update(content).digest("hex");
+  }
+  getAssetFolder(mimeType, url) {
+    const folders = {
+      ...DEFAULT_ASSET_FOLDERS,
+      ...this.options.assetFolders
+    };
+    if (mimeType) {
+      const normalizedMime = mimeType.split(";")[0].trim().toLowerCase();
+      const assetType = MIME_TO_ASSET[normalizedMime];
+      if (assetType) {
+        return folders[assetType];
+      }
+    }
+    try {
+      const urlPath = new URL(url).pathname;
+      const ext = extname(urlPath).toLowerCase();
+      const assetType = EXT_TO_ASSET[ext];
+      if (assetType) {
+        return folders[assetType];
+      }
+    } catch {}
+    return folders.other;
+  }
+  shouldOrganize(mimeType, url) {
+    if (!this.options.organizeAssets) {
+      return false;
+    }
+    if (mimeType) {
+      const normalizedMime = mimeType.split(";")[0].trim().toLowerCase();
+      if (normalizedMime === "text/html" || normalizedMime === "application/xhtml+xml" || normalizedMime === "text/xml" || normalizedMime === "application/xml") {
+        return false;
+      }
+    }
+    try {
+      const urlPath = new URL(url).pathname;
+      const ext = extname(urlPath).toLowerCase();
+      if (ext === ".html" || ext === ".htm" || ext === ".xhtml") {
+        return false;
+      }
+    } catch {}
+    return true;
+  }
+  getOrganizedPath(url, content, mimeType) {
+    const existingPath = this.urlToPath.get(url);
+    if (existingPath) {
+      return {
+        path: existingPath,
+        isDuplicate: false
+      };
+    }
+    const hash = this.computeHash(content);
+    const existing = this.hashCache.get(hash);
+    if (existing) {
+      this.urlToPath.set(url, existing.path);
+      return {
+        path: existing.path,
+        isDuplicate: true,
+        originalUrl: existing.originalUrl
+      };
+    }
+    const folder = this.getAssetFolder(mimeType, url);
+    let filename = this.getFilename(url);
+    const basePath = join(folder, filename);
+    const finalPath = this.resolveCollision(basePath, hash);
+    this.hashCache.set(hash, {
+      hash,
+      path: finalPath,
+      originalUrl: url
+    });
+    this.urlToPath.set(url, finalPath);
+    return {
+      path: finalPath,
+      isDuplicate: false
+    };
+  }
+  getFilename(url) {
+    try {
+      const urlObj = new URL(url);
+      let pathname = urlObj.pathname;
+      if (pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+      let filename = basename(pathname);
+      if (!filename || filename === "/") {
+        filename = "index";
+      }
+      const queryIndex = filename.indexOf("?");
+      if (queryIndex > 0) {
+        filename = filename.slice(0, queryIndex);
+      }
+      return filename;
+    } catch {
+      return "asset";
+    }
+  }
+  resolveCollision(basePath, hash) {
+    const existingVersion = this.filenameVersions.get(basePath);
+    if (existingVersion === undefined) {
+      this.filenameVersions.set(basePath, 1);
+      return basePath;
+    }
+    const ext = extname(basePath);
+    const nameWithoutExt = basePath.slice(0, -ext.length || undefined);
+    const newVersion = existingVersion + 1;
+    this.filenameVersions.set(basePath, newVersion);
+    const versionedPath = `${nameWithoutExt}_v${newVersion}${ext}`;
+    return versionedPath;
+  }
+  getPathForUrl(url) {
+    return this.urlToPath.get(url);
+  }
+  getUrlMappings() {
+    return new Map(this.urlToPath);
+  }
+  clear() {
+    this.hashCache.clear();
+    this.urlToPath.clear();
+    this.filenameVersions.clear();
+  }
+  getStats() {
+    return {
+      uniqueFiles: this.hashCache.size,
+      duplicatesFound: this.urlToPath.size - this.hashCache.size,
+      totalUrls: this.urlToPath.size
+    };
+  }
+}
+
+exports.AssetOrganizer = AssetOrganizer;
+exports.default = AssetOrganizer;
+module.exports = Object.assign(AssetOrganizer, exports);

package/dist/wget/asset-organizer.js

@@ -0,0 +1,227 @@
+import { createHash } from "node:crypto";
+import { extname, basename, join } from "node:path";
+export const DEFAULT_ASSET_FOLDERS = {
+  css: "css",
+  js: "js",
+  images: "images",
+  fonts: "fonts",
+  audio: "audio",
+  video: "video",
+  other: "assets"
+};
+const MIME_TO_ASSET = {
+  "text/css": "css",
+  "application/javascript": "js",
+  "application/x-javascript": "js",
+  "text/javascript": "js",
+  "application/ecmascript": "js",
+  "image/jpeg": "images",
+  "image/png": "images",
+  "image/gif": "images",
+  "image/webp": "images",
+  "image/svg+xml": "images",
+  "image/x-icon": "images",
+  "image/vnd.microsoft.icon": "images",
+  "image/bmp": "images",
+  "image/tiff": "images",
+  "image/avif": "images",
+  "font/woff": "fonts",
+  "font/woff2": "fonts",
+  "font/ttf": "fonts",
+  "font/otf": "fonts",
+  "application/font-woff": "fonts",
+  "application/font-woff2": "fonts",
+  "application/x-font-ttf": "fonts",
+  "application/x-font-otf": "fonts",
+  "application/vnd.ms-fontobject": "fonts",
+  "audio/mpeg": "audio",
+  "audio/mp3": "audio",
+  "audio/wav": "audio",
+  "audio/ogg": "audio",
+  "audio/webm": "audio",
+  "audio/aac": "audio",
+  "audio/flac": "audio",
+  "video/mp4": "video",
+  "video/webm": "video",
+  "video/ogg": "video",
+  "video/quicktime": "video",
+  "video/x-msvideo": "video",
+  "video/x-ms-wmv": "video"
+};
+const EXT_TO_ASSET = {
+  ".css": "css",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jpg": "images",
+  ".jpeg": "images",
+  ".png": "images",
+  ".gif": "images",
+  ".webp": "images",
+  ".svg": "images",
+  ".ico": "images",
+  ".bmp": "images",
+  ".tiff": "images",
+  ".tif": "images",
+  ".avif": "images",
+  ".woff": "fonts",
+  ".woff2": "fonts",
+  ".ttf": "fonts",
+  ".otf": "fonts",
+  ".eot": "fonts",
+  ".mp3": "audio",
+  ".wav": "audio",
+  ".ogg": "audio",
+  ".aac": "audio",
+  ".flac": "audio",
+  ".m4a": "audio",
+  ".mp4": "video",
+  ".webm": "video",
+  ".ogv": "video",
+  ".mov": "video",
+  ".avi": "video",
+  ".wmv": "video",
+  ".mkv": "video"
+};
+
+export class AssetOrganizer {
+  options;
+  hashCache;
+  urlToPath;
+  filenameVersions;
+  constructor(options) {
+    this.options = options;
+    this.hashCache = new Map;
+    this.urlToPath = new Map;
+    this.filenameVersions = new Map;
+  }
+  computeHash(content) {
+    return createHash("md5").update(content).digest("hex");
+  }
+  getAssetFolder(mimeType, url) {
+    const folders = {
+      ...DEFAULT_ASSET_FOLDERS,
+      ...this.options.assetFolders
+    };
+    if (mimeType) {
+      const normalizedMime = mimeType.split(";")[0].trim().toLowerCase();
+      const assetType = MIME_TO_ASSET[normalizedMime];
+      if (assetType) {
+        return folders[assetType];
+      }
+    }
+    try {
+      const urlPath = new URL(url).pathname;
+      const ext = extname(urlPath).toLowerCase();
+      const assetType = EXT_TO_ASSET[ext];
+      if (assetType) {
+        return folders[assetType];
+      }
+    } catch {}
+    return folders.other;
+  }
+  shouldOrganize(mimeType, url) {
+    if (!this.options.organizeAssets) {
+      return false;
+    }
+    if (mimeType) {
+      const normalizedMime = mimeType.split(";")[0].trim().toLowerCase();
+      if (normalizedMime === "text/html" || normalizedMime === "application/xhtml+xml" || normalizedMime === "text/xml" || normalizedMime === "application/xml") {
+        return false;
+      }
+    }
+    try {
+      const urlPath = new URL(url).pathname;
+      const ext = extname(urlPath).toLowerCase();
+      if (ext === ".html" || ext === ".htm" || ext === ".xhtml") {
+        return false;
+      }
+    } catch {}
+    return true;
+  }
+  getOrganizedPath(url, content, mimeType) {
+    const existingPath = this.urlToPath.get(url);
+    if (existingPath) {
+      return {
+        path: existingPath,
+        isDuplicate: false
+      };
+    }
+    const hash = this.computeHash(content);
+    const existing = this.hashCache.get(hash);
+    if (existing) {
+      this.urlToPath.set(url, existing.path);
+      return {
+        path: existing.path,
+        isDuplicate: true,
+        originalUrl: existing.originalUrl
+      };
+    }
+    const folder = this.getAssetFolder(mimeType, url);
+    let filename = this.getFilename(url);
+    const basePath = join(folder, filename);
+    const finalPath = this.resolveCollision(basePath, hash);
+    this.hashCache.set(hash, {
+      hash,
+      path: finalPath,
+      originalUrl: url
+    });
+    this.urlToPath.set(url, finalPath);
+    return {
+      path: finalPath,
+      isDuplicate: false
+    };
+  }
+  getFilename(url) {
+    try {
+      const urlObj = new URL(url);
+      let pathname = urlObj.pathname;
+      if (pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+      let filename = basename(pathname);
+      if (!filename || filename === "/") {
+        filename = "index";
+      }
+      const queryIndex = filename.indexOf("?");
+      if (queryIndex > 0) {
+        filename = filename.slice(0, queryIndex);
+      }
+      return filename;
+    } catch {
+      return "asset";
+    }
+  }
+  resolveCollision(basePath, hash) {
+    const existingVersion = this.filenameVersions.get(basePath);
+    if (existingVersion === undefined) {
+      this.filenameVersions.set(basePath, 1);
+      return basePath;
+    }
+    const ext = extname(basePath);
+    const nameWithoutExt = basePath.slice(0, -ext.length || undefined);
+    const newVersion = existingVersion + 1;
+    this.filenameVersions.set(basePath, newVersion);
+    const versionedPath = `${nameWithoutExt}_v${newVersion}${ext}`;
+    return versionedPath;
+  }
+  getPathForUrl(url) {
+    return this.urlToPath.get(url);
+  }
+  getUrlMappings() {
+    return new Map(this.urlToPath);
+  }
+  clear() {
+    this.hashCache.clear();
+    this.urlToPath.clear();
+    this.filenameVersions.clear();
+  }
+  getStats() {
+    return {
+      uniqueFiles: this.hashCache.size,
+      duplicatesFound: this.urlToPath.size - this.hashCache.size,
+      totalUrls: this.urlToPath.size
+    };
+  }
+}
+export default AssetOrganizer;

package/dist/wget/download-cache.cjs

@@ -0,0 +1,221 @@
+const { promises: fs } = require("node:fs");
+const { createHash } = require("node:crypto");
+const { join, dirname } = require("node:path");
+const { cwd } = require("node:process");
+
+class DownloadCache {
+  outputDir;
+  baseUrl;
+  cacheDir;
+  cacheFile;
+  data = null;
+  dirty = false;
+  saveTimeout = null;
+  static VERSION = 1;
+  static CACHE_DIR = ".rezo-wget";
+  constructor(outputDir, baseUrl) {
+    this.outputDir = outputDir;
+    this.baseUrl = baseUrl;
+    this.cacheDir = join(cwd(), DownloadCache.CACHE_DIR);
+    const hash = this.generateCacheHash();
+    this.cacheFile = join(this.cacheDir, `${hash}.json`);
+  }
+  generateCacheHash() {
+    return createHash("md5").update(this.baseUrl).digest("hex").slice(0, 12);
+  }
+  urlHash(url) {
+    return createHash("md5").update(url).digest("hex");
+  }
+  async load() {
+    try {
+      await fs.mkdir(this.cacheDir, { recursive: true });
+      const content = await fs.readFile(this.cacheFile, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version !== DownloadCache.VERSION) {
+        this.data = this.createEmptyCache();
+        return;
+      }
+      this.data = data;
+    } catch (error) {
+      this.data = this.createEmptyCache();
+    }
+  }
+  createEmptyCache() {
+    return {
+      version: DownloadCache.VERSION,
+      created: Date.now(),
+      updated: Date.now(),
+      configHash: this.generateCacheHash(),
+      baseUrl: this.baseUrl,
+      entries: {}
+    };
+  }
+  async check(url) {
+    if (!this.data) {
+      await this.load();
+    }
+    const key = this.urlHash(url);
+    const entry = this.data.entries[key];
+    if (!entry) {
+      return { cached: false, reason: "not-found" };
+    }
+    for (const filename of entry.filenames) {
+      const fullPath = join(this.outputDir, filename);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.size === entry.totalBytes) {
+          return {
+            cached: true,
+            entry,
+            filename
+          };
+        }
+      } catch {}
+    }
+    if (entry.filenames.length > 0) {
+      return { cached: false, reason: "file-missing", entry };
+    }
+    return { cached: false, reason: "size-mismatch", entry };
+  }
+  get(url) {
+    if (!this.data)
+      return;
+    return this.data.entries[this.urlHash(url)];
+  }
+  set(url, entry) {
+    if (!this.data) {
+      this.data = this.createEmptyCache();
+    }
+    const key = this.urlHash(url);
+    const existing = this.data.entries[key];
+    this.data.entries[key] = {
+      url,
+      ...entry,
+      filenames: existing ? [...new Set([...existing.filenames, ...entry.filenames])] : entry.filenames
+    };
+    this.data.updated = Date.now();
+    this.dirty = true;
+    this.scheduleSave();
+  }
+  addFilename(url, filename) {
+    if (!this.data)
+      return;
+    const key = this.urlHash(url);
+    const entry = this.data.entries[key];
+    if (entry && !entry.filenames.includes(filename)) {
+      entry.filenames.push(filename);
+      this.data.updated = Date.now();
+      this.dirty = true;
+      this.scheduleSave();
+    }
+  }
+  delete(url) {
+    if (!this.data)
+      return;
+    const key = this.urlHash(url);
+    if (this.data.entries[key]) {
+      delete this.data.entries[key];
+      this.data.updated = Date.now();
+      this.dirty = true;
+      this.scheduleSave();
+    }
+  }
+  has(url) {
+    if (!this.data)
+      return false;
+    return this.urlHash(url) in this.data.entries;
+  }
+  urls() {
+    if (!this.data)
+      return [];
+    return Object.values(this.data.entries).map((e) => e.url);
+  }
+  stats() {
+    if (!this.data) {
+      return { entries: 0, totalBytes: 0, filesCount: 0 };
+    }
+    const entries = Object.values(this.data.entries);
+    return {
+      entries: entries.length,
+      totalBytes: entries.reduce((sum, e) => sum + e.totalBytes, 0),
+      filesCount: entries.reduce((sum, e) => sum + e.filenames.length, 0)
+    };
+  }
+  scheduleSave() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => this.save(), 1000);
+  }
+  async save() {
+    if (!this.data || !this.dirty)
+      return;
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = null;
+    }
+    try {
+      await fs.mkdir(dirname(this.cacheFile), { recursive: true });
+      await fs.writeFile(this.cacheFile, JSON.stringify(this.data, null, 2), "utf-8");
+      this.dirty = false;
+    } catch (error) {
+      console.error("Failed to save download cache:", error);
+    }
+  }
+  clear() {
+    if (this.data) {
+      this.data.entries = {};
+      this.data.updated = Date.now();
+      this.dirty = true;
+      this.scheduleSave();
+    }
+  }
+  async cleanup() {
+    if (!this.data)
+      return 0;
+    let removed = 0;
+    const entries = Object.entries(this.data.entries);
+    for (const [key, entry] of entries) {
+      let hasValidFile = false;
+      const validFilenames = [];
+      for (const filename of entry.filenames) {
+        const fullPath = join(this.outputDir, filename);
+        try {
+          await fs.stat(fullPath);
+          validFilenames.push(filename);
+          hasValidFile = true;
+        } catch {}
+      }
+      if (!hasValidFile) {
+        delete this.data.entries[key];
+        removed++;
+      } else if (validFilenames.length !== entry.filenames.length) {
+        entry.filenames = validFilenames;
+      }
+    }
+    if (removed > 0) {
+      this.data.updated = Date.now();
+      this.dirty = true;
+      await this.save();
+    }
+    return removed;
+  }
+  async destroy() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = null;
+    }
+    await this.save();
+    this.data = null;
+  }
+  get filePath() {
+    return this.cacheFile;
+  }
+  get dirPath() {
+    return this.cacheDir;
+  }
+}
+
+exports.DownloadCache = DownloadCache;
+exports.default = DownloadCache;
+module.exports = Object.assign(DownloadCache, exports);