@xleddyl/nuxt-cms 0.1.25 → 0.1.27

package/dist/runtime/server/utils/media-sync.js

@@ -0,0 +1,227 @@
+import { open, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+export const MEDIA_SYNC_MIME_TYPES = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp",
+  avif: "image/avif",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  pdf: "application/pdf"
+};
+const HEADER_BYTES = 65536;
+export function mediaSyncExtension(key) {
+  const name = key.split("/").pop() ?? key;
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return null;
+  return name.slice(dot + 1).toLowerCase();
+}
+export function isSyncableMediaKey(key) {
+  const name = key.split("/").pop() ?? key;
+  if (!name || name.startsWith(".")) return false;
+  const extension = mediaSyncExtension(key);
+  return !!extension && extension in MEDIA_SYNC_MIME_TYPES;
+}
+export function mediaMimeForKey(key) {
+  const extension = mediaSyncExtension(key);
+  return (extension && MEDIA_SYNC_MIME_TYPES[extension]) ?? null;
+}
+export function mediaSyncFolder(key) {
+  const slash = key.lastIndexOf("/");
+  return slash === -1 ? null : key.slice(0, slash) || null;
+}
+function view(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function ascii(bytes, offset, length) {
+  let out = "";
+  for (let i = offset; i < offset + length && i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i]);
+  }
+  return out;
+}
+function startsWith(bytes, offset, signature) {
+  if (bytes.length < offset + signature.length) return false;
+  return signature.every((byte, index) => bytes[offset + index] === byte);
+}
+const PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+export function pngImageSize(bytes) {
+  if (!startsWith(bytes, 0, PNG_SIGNATURE)) return null;
+  if (bytes.length < 24 || ascii(bytes, 12, 4) !== "IHDR") return null;
+  const data = view(bytes);
+  const width = data.getUint32(16);
+  const height = data.getUint32(20);
+  return width && height ? { width, height } : null;
+}
+const JPEG_STANDALONE_MARKERS = /* @__PURE__ */ new Set([
+  1,
+  216,
+  208,
+  209,
+  210,
+  211,
+  212,
+  213,
+  214,
+  215
+]);
+const JPEG_SOF_MARKERS = /* @__PURE__ */ new Set([
+  192,
+  193,
+  194,
+  195,
+  197,
+  198,
+  199,
+  201,
+  202,
+  203,
+  205,
+  206,
+  207
+]);
+export function jpegImageSize(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return null;
+  const data = view(bytes);
+  let offset = 2;
+  while (offset + 3 < bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    let marker = bytes[offset + 1];
+    while (marker === 255 && offset + 2 < bytes.length) {
+      offset++;
+      marker = bytes[offset + 1];
+    }
+    if (JPEG_STANDALONE_MARKERS.has(marker)) {
+      offset += 2;
+      continue;
+    }
+    if (marker === 217 || marker === 218) return null;
+    const segmentLength = data.getUint16(offset + 2);
+    if (segmentLength < 2) return null;
+    if (JPEG_SOF_MARKERS.has(marker)) {
+      if (offset + 9 > bytes.length) return null;
+      const height = data.getUint16(offset + 5);
+      const width = data.getUint16(offset + 7);
+      return width && height ? { width, height } : null;
+    }
+    offset += 2 + segmentLength;
+  }
+  return null;
+}
+export function webpImageSize(bytes) {
+  if (bytes.length < 16 || ascii(bytes, 0, 4) !== "RIFF" || ascii(bytes, 8, 4) !== "WEBP") {
+    return null;
+  }
+  const data = view(bytes);
+  const format = ascii(bytes, 12, 4);
+  if (format === "VP8 ") {
+    if (bytes.length < 30) return null;
+    if (bytes[23] !== 157 || bytes[24] !== 1 || bytes[25] !== 42) return null;
+    const width = data.getUint16(26, true) & 16383;
+    const height = data.getUint16(28, true) & 16383;
+    return width && height ? { width, height } : null;
+  }
+  if (format === "VP8L") {
+    if (bytes.length < 25 || bytes[20] !== 47) return null;
+    const bits = data.getUint32(21, true);
+    return { width: (bits & 16383) + 1, height: (bits >>> 14 & 16383) + 1 };
+  }
+  if (format === "VP8X") {
+    if (bytes.length < 30) return null;
+    const width = 1 + (bytes[24] | bytes[25] << 8 | bytes[26] << 16);
+    const height = 1 + (bytes[27] | bytes[28] << 8 | bytes[29] << 16);
+    return { width, height };
+  }
+  return null;
+}
+export function gifImageSize(bytes) {
+  if (bytes.length < 10 || ascii(bytes, 0, 3) !== "GIF") return null;
+  const version = ascii(bytes, 3, 3);
+  if (version !== "87a" && version !== "89a") return null;
+  const data = view(bytes);
+  const width = data.getUint16(6, true);
+  const height = data.getUint16(8, true);
+  return width && height ? { width, height } : null;
+}
+export function imageSizeFromBuffer(bytes) {
+  return pngImageSize(bytes) ?? gifImageSize(bytes) ?? webpImageSize(bytes) ?? jpegImageSize(bytes);
+}
+async function readHeader(path, size) {
+  const length = Math.min(size, HEADER_BYTES);
+  if (length <= 0) return null;
+  const handle = await open(path, "r");
+  try {
+    const buffer = new Uint8Array(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+export async function scanMediaDirectory(root) {
+  const files = [];
+  const walk = async (dir, prefix) => {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const key = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path, key);
+        continue;
+      }
+      if (!entry.isFile() || !isSyncableMediaKey(key)) continue;
+      const info = await stat(path);
+      files.push({ key, size: info.size });
+    }
+  };
+  await walk(root, "");
+  return files.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+}
+export function planMediaSync(files, rows) {
+  const rowByKey = new Map(rows.map((row) => [row.key, row]));
+  const insert = [];
+  const update = [];
+  for (const file of files) {
+    const row = rowByKey.get(file.key);
+    if (!row) insert.push(file);
+    else if (row.size !== file.size) update.push(file);
+  }
+  const scanned = new Set(files.map((file) => file.key));
+  const remove = rows.filter((row) => !scanned.has(row.key)).map((row) => row.key);
+  return { insert, update, remove };
+}
+export async function readMediaFileMeta(root, file) {
+  const mime = mediaMimeForKey(file.key);
+  let size = null;
+  if (mime === "image/png" || mime === "image/jpeg" || mime === "image/webp" || mime === "image/gif") {
+    const header = await readHeader(join(root, ...file.key.split("/")), file.size);
+    size = header ? imageSizeFromBuffer(header) : null;
+  }
+  return {
+    key: file.key,
+    folder: mediaSyncFolder(file.key),
+    mime,
+    size: file.size,
+    width: size?.width ?? null,
+    height: size?.height ?? null
+  };
+}
+export function chunked(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}

package/dist/runtime/shared/index.d.ts

@@ -15,6 +15,8 @@ export declare function mediaTypeFor(mime: string | null | undefined, key: strin
 export declare function mediaIconFor(type: MediaType): string;
 export declare function mediaPublicUrl(baseUrl: string | null | undefined, key: string): string | null;
 export declare function slugify(value: string): string;
+export declare const MEDIA_FOLDER_MAX_DEPTH = 4;
+export declare function normalizeMediaFolder(value: string | null | undefined): string | null;
 export interface MediaItem {
     id: number;
     key: string;

package/dist/runtime/shared/index.js

@@ -44,6 +44,12 @@ export function mediaPublicUrl(baseUrl, key) {
 export function slugify(value) {
   return value.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036F]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+export const MEDIA_FOLDER_MAX_DEPTH = 4;
+export function normalizeMediaFolder(value) {
+  if (!value) return null;
+  const segments = value.split("/").map(slugify).filter(Boolean).slice(0, MEDIA_FOLDER_MAX_DEPTH);
+  return segments.length ? segments.join("/") : null;
+}
 export function isTranslatableField(field) {
   return !!field.translatable && (field.type === "text" || field.type === "richtext");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Lightweight CMS that ships with your Nuxt app: runs on the Nitro server, content types defined in code, /cms admin panel, GraphQL API, SQLite or Postgres. No external CMS needed!",
   "license": "MIT",
   "author": "Edoardo Alberti (https://github.com/xleddyl)",