@jant/core 0.3.36 → 0.3.37

package/src/lib/tiptap-to-markdown.ts

@@ -0,0 +1,305 @@
+/**
+ * Tiptap JSON → Markdown Converter
+ *
+ * Server-side converter that transforms Tiptap JSON documents to Markdown strings.
+ * Pure string concatenation — no DOM required. Mirrors the node types
+ * supported by `tiptap-render.ts`.
+ */
+
+interface TiptapMark {
+  type: string;
+  attrs?: Record<string, unknown>;
+}
+
+interface TiptapNode {
+  type: string;
+  content?: TiptapNode[];
+  text?: string;
+  marks?: TiptapMark[];
+  attrs?: Record<string, unknown>;
+}
+
+/**
+ * Converts a Tiptap JSON document to a Markdown string.
+ *
+ * @param json - Tiptap JSON string or parsed document object
+ * @returns Markdown string
+ *
+ * @example
+ * ```ts
+ * const md = tiptapJsonToMarkdown('{"type":"doc","content":[{"type":"paragraph","content":[{"type":"text","text":"Hello"}]}]}');
+ * // "Hello"
+ * ```
+ */
+export function tiptapJsonToMarkdown(json: string): string {
+  try {
+    const doc = JSON.parse(json) as TiptapNode;
+    if (doc.type !== "doc") return "";
+    return renderBlocks(doc.content ?? []).trimEnd();
+  } catch {
+    return "";
+  }
+}
+
+function renderBlocks(nodes: TiptapNode[], indent = ""): string {
+  const parts: string[] = [];
+
+  for (const node of nodes) {
+    const rendered = renderBlockNode(node, indent);
+    if (rendered !== null) {
+      parts.push(rendered);
+    }
+  }
+
+  return parts.join("\n\n");
+}
+
+function renderBlockNode(node: TiptapNode, indent: string): string | null {
+  switch (node.type) {
+    case "paragraph": {
+      const text = renderInline(node.content ?? []);
+      return indent + text;
+    }
+
+    case "heading": {
+      const level = Math.min(Math.max(Number(node.attrs?.level ?? 1), 1), 6);
+      const prefix = "#".repeat(level);
+      const text = renderInline(node.content ?? []);
+      return `${indent}${prefix} ${text}`;
+    }
+
+    case "bulletList":
+      return renderList(node.content ?? [], indent, "bullet");
+
+    case "orderedList": {
+      const start = Number(node.attrs?.start ?? 1);
+      return renderList(node.content ?? [], indent, "ordered", start);
+    }
+
+    case "blockquote": {
+      const inner = renderBlocks(node.content ?? []);
+      return inner
+        .split("\n")
+        .map((line) => indent + (line ? `> ${line}` : ">"))
+        .join("\n");
+    }
+
+    case "codeBlock": {
+      const lang = node.attrs?.language ? String(node.attrs.language) : "";
+      const content = getPlainText(node.content ?? []);
+      const fence = chooseFence(content);
+      return `${indent}${fence}${lang}\n${content}\n${indent}${fence}`;
+    }
+
+    case "table":
+      return renderTable(node.content ?? [], indent);
+
+    case "horizontalRule":
+      return `${indent}---`;
+
+    case "hardBreak":
+      return null;
+
+    case "image": {
+      const src = String(node.attrs?.src ?? "");
+      const alt = node.attrs?.alt ? String(node.attrs.alt) : "";
+      const title = node.attrs?.title ? String(node.attrs.title) : "";
+      const titlePart = title ? ` "${title}"` : "";
+      return `${indent}![${alt}](${src}${titlePart})`;
+    }
+
+    case "moreBreak":
+      return `${indent}<!--more-->`;
+
+    default:
+      if (node.content) {
+        return renderBlocks(node.content, indent);
+      }
+      return null;
+  }
+}
+
+function renderList(
+  items: TiptapNode[],
+  indent: string,
+  type: "bullet" | "ordered",
+  start = 1,
+): string {
+  const lines: string[] = [];
+
+  for (let i = 0; i < items.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- index-bounded loop
+    const item = items[i]!;
+    const marker = type === "bullet" ? "-" : `${(start + i).toString()}.`;
+    const children = item.content ?? [];
+
+    for (let j = 0; j < children.length; j++) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- index-bounded loop
+      const child = children[j]!;
+      if (j === 0) {
+        // First child gets the list marker
+        if (child.type === "bulletList" || child.type === "orderedList") {
+          // Nested list as first child — render with increased indent
+          const nested = renderBlockNode(child, indent + "  ");
+          if (nested !== null) {
+            lines.push(`${indent}${marker} \n${nested}`);
+          }
+        } else {
+          const text = renderInline(child.content ?? []);
+          lines.push(`${indent}${marker} ${text}`);
+        }
+      } else {
+        // Subsequent children: indent to align with first line content
+        const childIndent = indent + " ".repeat(marker.length + 1);
+        if (child.type === "bulletList" || child.type === "orderedList") {
+          const nested = renderBlockNode(child, childIndent);
+          if (nested !== null) lines.push(nested);
+        } else if (child.type === "paragraph") {
+          const text = renderInline(child.content ?? []);
+          lines.push("");
+          lines.push(`${childIndent}${text}`);
+        } else {
+          const rendered = renderBlockNode(child, childIndent);
+          if (rendered !== null) {
+            lines.push("");
+            lines.push(rendered);
+          }
+        }
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function renderTable(rows: TiptapNode[], indent: string): string {
+  if (rows.length === 0) return "";
+
+  const matrix: string[][] = [];
+
+  for (const row of rows) {
+    const cells: string[] = [];
+    for (const cell of row.content ?? []) {
+      // Each cell may contain paragraphs — render inline content
+      const parts: string[] = [];
+      for (const child of cell.content ?? []) {
+        parts.push(renderInline(child.content ?? []));
+      }
+      cells.push(parts.join(" "));
+    }
+    matrix.push(cells);
+  }
+
+  // Calculate column widths
+  const colCount = Math.max(...matrix.map((r) => r.length));
+  const widths: number[] = [];
+  for (let c = 0; c < colCount; c++) {
+    widths.push(Math.max(3, ...matrix.map((r) => (r[c] ?? "").length)));
+  }
+
+  const lines: string[] = [];
+
+  // Header row
+  const headerRow = matrix[0] ?? [];
+  lines.push(
+    indent +
+      "| " +
+      widths.map((w, i) => (headerRow[i] ?? "").padEnd(w)).join(" | ") +
+      " |",
+  );
+
+  // Separator row (first row is always the header)
+  lines.push(
+    indent + "| " + widths.map((w) => "-".repeat(w)).join(" | ") + " |",
+  );
+
+  // Body rows
+  for (let r = 1; r < matrix.length; r++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- index-bounded loop
+    const row = matrix[r]!;
+    lines.push(
+      indent +
+        "| " +
+        widths.map((w, i) => (row[i] ?? "").padEnd(w)).join(" | ") +
+        " |",
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function renderInline(nodes: TiptapNode[]): string {
+  return nodes.map(renderInlineNode).join("");
+}
+
+function renderInlineNode(node: TiptapNode): string {
+  switch (node.type) {
+    case "text": {
+      let text = node.text ?? "";
+      if (node.marks && node.marks.length > 0) {
+        text = applyMarks(text, node.marks);
+      }
+      return text;
+    }
+
+    case "hardBreak":
+      return "  \n";
+
+    case "image": {
+      const src = String(node.attrs?.src ?? "");
+      const alt = node.attrs?.alt ? String(node.attrs.alt) : "";
+      const title = node.attrs?.title ? String(node.attrs.title) : "";
+      const titlePart = title ? ` "${title}"` : "";
+      return `![${alt}](${src}${titlePart})`;
+    }
+
+    default:
+      if (node.content) return renderInline(node.content);
+      return "";
+  }
+}
+
+function applyMarks(text: string, marks: TiptapMark[]): string {
+  let result = text;
+
+  for (const mark of marks) {
+    switch (mark.type) {
+      case "bold":
+        result = `**${result}**`;
+        break;
+      case "italic":
+        result = `*${result}*`;
+        break;
+      case "strike":
+        result = `~~${result}~~`;
+        break;
+      case "code":
+        result = `\`${result}\``;
+        break;
+      case "link": {
+        const href = String(mark.attrs?.href ?? "");
+        result = `[${result}](${href})`;
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+function getPlainText(nodes: TiptapNode[]): string {
+  return nodes.map((n) => n.text ?? "").join("");
+}
+
+function chooseFence(content: string): string {
+  let count = 3;
+  const regex = /(`{3,})/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const backticks = match[1] ?? "";
+    if (backticks.length >= count) {
+      count = backticks.length + 1;
+    }
+  }
+  return "`".repeat(count);
+}

package/src/lib/upload.ts

@@ -5,74 +5,219 @@
  */
 
 import { uuidv7 } from "uuidv7";
+import type { MediaKind } from "../types/constants.js";
 
-/** MIME types allowed for upload — images */
+/** MIME types — images */
 const IMAGE_MIME_TYPES = [
   "image/jpeg",
   "image/png",
   "image/gif",
   "image/webp",
   "image/svg+xml",
+  "image/avif",
+  "image/bmp",
+  "image/x-icon",
 ] as const;
 
-/** MIME types allowed for upload — video */
+/** MIME types — video */
 const VIDEO_MIME_TYPES = [
   "video/mp4",
   "video/webm",
   "video/quicktime",
+  "video/x-msvideo",
+  "video/x-matroska",
+  "video/mpeg",
+  "video/3gpp",
+  "video/x-flv",
+  "video/ogg",
 ] as const;
 
-/** MIME types allowed for upload — audio */
+/** MIME types — audio */
 const AUDIO_MIME_TYPES = [
   "audio/mpeg",
   "audio/ogg",
   "audio/wav",
   "audio/mp4",
   "audio/x-m4a",
+  "audio/flac",
+  "audio/aac",
+  "audio/webm",
+  "audio/x-aiff",
+  "audio/opus",
+  "audio/3gpp",
+  "audio/midi",
 ] as const;
 
-/** MIME types allowed for upload — documents */
-const DOCUMENT_MIME_TYPES = ["application/pdf"] as const;
+/** MIME types — documents (books, PDFs) */
+const DOCUMENT_MIME_TYPES = [
+  "application/pdf",
+  "application/epub+zip",
+  "application/x-mobipocket-ebook",
+  "application/vnd.amazon.ebook",
+] as const;
+
+/** MIME types — office documents */
+const OFFICE_MIME_TYPES = [
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.oasis.opendocument.text",
+  "application/vnd.oasis.opendocument.spreadsheet",
+  "application/vnd.oasis.opendocument.presentation",
+  "application/vnd.apple.pages",
+  "application/vnd.apple.numbers",
+  "application/vnd.apple.keynote",
+] as const;
+
+/** MIME types — text & structured data */
+const TEXT_MIME_TYPES = [
+  "text/plain",
+  "text/markdown",
+  "text/csv",
+  "text/x-tiptap+json",
+  "text/html",
+  "text/css",
+  "text/javascript",
+  "text/xml",
+  "text/rtf",
+  "text/tab-separated-values",
+  "text/calendar",
+  "application/json",
+  "application/xml",
+  "application/yaml",
+  "application/toml",
+] as const;
 
-/** All allowed MIME types */
-const ALLOWED_UPLOAD_TYPES = [
-  ...IMAGE_MIME_TYPES,
-  ...VIDEO_MIME_TYPES,
-  ...AUDIO_MIME_TYPES,
-  ...DOCUMENT_MIME_TYPES,
+/** MIME types — archives */
+const ARCHIVE_MIME_TYPES = [
+  "application/zip",
+  "application/x-tar",
+  "application/gzip",
+  "application/x-bzip2",
+  "application/x-7z-compressed",
+  "application/x-rar-compressed",
+  "application/zstd",
 ] as const;
 
+/** MIME types — fonts */
+const FONT_MIME_TYPES = [
+  "font/ttf",
+  "font/otf",
+  "font/woff",
+  "font/woff2",
+] as const;
+
+/** MIME types — 3D & design */
+const THREE_D_MIME_TYPES = [
+  "model/gltf+json",
+  "model/gltf-binary",
+  "model/obj",
+  "application/x-figma",
+  "image/vnd.dxf",
+] as const;
+
+/** MIME types — data & code */
+const CODE_MIME_TYPES = [
+  "application/sql",
+  "application/wasm",
+  "application/x-ipynb+json",
+  "application/x-sh",
+  "application/x-python-code",
+] as const;
+
+/** Lookup table from MIME type to category */
+const MIME_CATEGORY_MAP = new Map<string, MediaCategory>([
+  ...IMAGE_MIME_TYPES.map((t) => [t, "image" as const] as const),
+  ...VIDEO_MIME_TYPES.map((t) => [t, "video" as const] as const),
+  ...AUDIO_MIME_TYPES.map((t) => [t, "audio" as const] as const),
+  ...DOCUMENT_MIME_TYPES.map((t) => [t, "document" as const] as const),
+  ...OFFICE_MIME_TYPES.map((t) => [t, "office" as const] as const),
+  ...TEXT_MIME_TYPES.map((t) => [t, "text" as const] as const),
+  ...ARCHIVE_MIME_TYPES.map((t) => [t, "archive" as const] as const),
+  ...FONT_MIME_TYPES.map((t) => [t, "font" as const] as const),
+  ...THREE_D_MIME_TYPES.map((t) => [t, "3d" as const] as const),
+  ...CODE_MIME_TYPES.map((t) => [t, "code" as const] as const),
+]);
+
 /**
- * Accept string for file inputs, covering all allowed upload types.
+ * Accept string for file inputs. Accepts all file types.
  *
  * @example
  * ```ts
  * <input type="file" accept={UPLOAD_ACCEPT} />
  * ```
  */
-export const UPLOAD_ACCEPT = (ALLOWED_UPLOAD_TYPES as readonly string[]).join(
-  ",",
-);
+export const UPLOAD_ACCEPT = "*/*";
 
-export type MediaCategory = "image" | "video" | "audio" | "document";
+export type MediaCategory =
+  | "image"
+  | "video"
+  | "audio"
+  | "document"
+  | "office"
+  | "text"
+  | "archive"
+  | "font"
+  | "3d"
+  | "code";
 
 /**
  * Returns the media category for a given MIME type.
+ * Unrecognized types default to "archive".
  *
  * @param mimeType - The MIME type to classify
- * @returns The media category, or null if the MIME type is not supported
+ * @returns The media category
  * @example
  * ```ts
  * getMediaCategory("video/mp4"); // "video"
- * getMediaCategory("text/plain"); // null
+ * getMediaCategory("text/plain"); // "text"
+ * getMediaCategory("application/octet-stream"); // "archive"
  * ```
  */
-export function getMediaCategory(mimeType: string): MediaCategory | null {
+export function getMediaCategory(mimeType: string): MediaCategory {
+  // Exact match from known types
+  const exact = MIME_CATEGORY_MAP.get(mimeType);
+  if (exact) return exact;
+
+  // Prefix-based fallback for unknown subtypes
   if (mimeType.startsWith("image/")) return "image";
   if (mimeType.startsWith("video/")) return "video";
   if (mimeType.startsWith("audio/")) return "audio";
-  if (mimeType === "application/pdf") return "document";
-  return null;
+  if (mimeType.startsWith("font/")) return "font";
+  if (mimeType.startsWith("model/")) return "3d";
+  if (mimeType.startsWith("text/")) return "text";
+
+  // Unknown types default to archive
+  return "archive";
+}
+
+/**
+ * Maps a MIME type to one of the five media kind categories.
+ * image/video/audio/text pass through; everything else becomes "document".
+ *
+ * @param mimeType - The MIME type to classify
+ * @returns The media kind
+ * @example
+ * ```ts
+ * toMediaKind("image/jpeg"); // "image"
+ * toMediaKind("application/pdf"); // "document"
+ * toMediaKind("text/plain"); // "text"
+ * ```
+ */
+export function toMediaKind(mimeType: string): MediaKind {
+  const category = getMediaCategory(mimeType);
+  switch (category) {
+    case "image":
+    case "video":
+    case "audio":
+    case "text":
+      return category;
+    default:
+      return "document";
+  }
 }
 
 /**
@@ -112,20 +257,36 @@ export interface ValidateUploadOptions {
 export function validateUploadFile(
   file: File,
   options: ValidateUploadOptions,
+): string | null {
+  return validateUploadFileMetadata(file.type, file.size, options);
+}
+
+/**
+ * Validates file metadata (type and size) without requiring a File object.
+ * Used by the multipart upload initiation endpoint which receives JSON metadata.
+ * All MIME types are accepted; unrecognized types are categorized as archive.
+ *
+ * @param contentType - The MIME type of the file
+ * @param size - The file size in bytes
+ * @param options - Validation constraints
+ * @returns null if valid, error message string if invalid
+ * @example
+ * ```ts
+ * const error = validateUploadFileMetadata("image/jpeg", 1024000, { maxFileSizeMB: 500 });
+ * ```
+ */
+export function validateUploadFileMetadata(
+  contentType: string,
+  size: number,
+  options: ValidateUploadOptions,
 ): string | null {
   if (options?.imagesOnly) {
-    if (!isImageMimeType(file.type)) {
+    if (!isImageMimeType(contentType)) {
       return "File type not allowed.";
     }
-  } else if (
-    !ALLOWED_UPLOAD_TYPES.includes(
-      file.type as (typeof ALLOWED_UPLOAD_TYPES)[number],
-    )
-  ) {
-    return "File type not allowed.";
   }
   const maxMB = options.maxFileSizeMB;
-  if (file.size > maxMB * 1024 * 1024) {
+  if (size > maxMB * 1024 * 1024) {
     return `File too large (max ${maxMB}MB).`;
   }
   return null;

package/src/lib/url.ts

@@ -97,3 +97,34 @@ export function isFullUrl(str: string): boolean {
 export function slugify(text: string): string {
   return limax(text, { tone: false }).replace(/_/g, "-");
 }
+
+const SAFE_URL_PROTOCOLS = new Set(["http:", "https:", "mailto:"]);
+
+/**
+ * Sanitizes a URL by ensuring it uses a safe protocol.
+ *
+ * Returns the URL unchanged if it uses an allowed protocol (http:, https:, mailto:)
+ * or is a relative path. Returns an empty string for dangerous protocols like
+ * `javascript:`, `data:`, or `vbscript:`.
+ *
+ * @param url - The URL string to sanitize
+ * @returns The original URL if safe, or an empty string if the protocol is disallowed
+ *
+ * @example
+ * ```ts
+ * sanitizeUrl("https://example.com");       // "https://example.com"
+ * sanitizeUrl("/about");                     // "/about"
+ * sanitizeUrl("javascript:alert(1)");        // ""
+ * sanitizeUrl("data:text/html,<h1>Hi</h1>"); // ""
+ * ```
+ */
+export function sanitizeUrl(url: string): string {
+  try {
+    const parsed = new URL(url, "https://placeholder.invalid");
+    // Relative URLs resolve against the placeholder and get https: — allow them
+    if (SAFE_URL_PROTOCOLS.has(parsed.protocol)) return url;
+    return "";
+  } catch {
+    return "";
+  }
+}