@jant/core 0.3.27 → 0.3.28

package/dist/lib/favicon.js

@@ -1,102 +0,0 @@
-/**
- * Favicon Utilities
- *
- * Sizes and ICO encoding for generated favicon variants.
- * Favicon data is stored as base64 in the settings table (not R2)
- * since the files are tiny and accessed on every page load.
- */ /**
- * Favicon variant sizes (width x height in pixels)
- */ export const FAVICON_SIZES = {
-    ICO_16: 16,
-    ICO_32: 32,
-    APPLE_TOUCH: 180
-};
-/**
- * Encode PNG images into an ICO file.
- *
- * ICO format (with PNG payloads):
- * - Header: 6 bytes (reserved=0, type=1, count=N)
- * - Directory: 16 bytes per entry (width, height, colors, reserved, planes, bpp, size, offset)
- * - Data: raw PNG bytes for each entry
- *
- * @param entries - Array of { size, png } where png is an ArrayBuffer of PNG data
- * @returns ICO file as a Blob
- *
- * @example
- * ```ts
- * const ico = encodeIco([
- *   { size: 16, png: png16ArrayBuffer },
- *   { size: 32, png: png32ArrayBuffer },
- * ]);
- * ```
- */ export function encodeIco(entries) {
-    const headerSize = 6;
-    const dirEntrySize = 16;
-    const dirSize = entries.length * dirEntrySize;
-    let dataOffset = headerSize + dirSize;
-    // Build header + directory
-    const header = new ArrayBuffer(headerSize + dirSize);
-    const view = new DataView(header);
-    // ICO header
-    view.setUint16(0, 0, true); // reserved
-    view.setUint16(2, 1, true); // type = icon
-    view.setUint16(4, entries.length, true); // count
-    const pngBuffers = [];
-    for(let i = 0; i < entries.length; i++){
-        const entry = entries[i];
-        const offset = headerSize + i * dirEntrySize;
-        // Width/height: 0 means 256
-        view.setUint8(offset + 0, entry.size < 256 ? entry.size : 0);
-        view.setUint8(offset + 1, entry.size < 256 ? entry.size : 0);
-        view.setUint8(offset + 2, 0); // color count (0 for >256 colors)
-        view.setUint8(offset + 3, 0); // reserved
-        view.setUint16(offset + 4, 1, true); // color planes
-        view.setUint16(offset + 6, 32, true); // bits per pixel
-        view.setUint32(offset + 8, entry.png.byteLength, true); // image size
-        view.setUint32(offset + 12, dataOffset, true); // image offset
-        dataOffset += entry.png.byteLength;
-        pngBuffers.push(entry.png);
-    }
-    return new Blob([
-        header,
-        ...pngBuffers
-    ], {
-        type: "image/x-icon"
-    });
-}
-/**
- * Convert an ArrayBuffer to a base64 string.
- *
- * @param buffer - The ArrayBuffer to encode
- * @returns base64-encoded string
- *
- * @example
- * ```ts
- * const b64 = arrayBufferToBase64(await blob.arrayBuffer());
- * ```
- */ export function arrayBufferToBase64(buffer) {
-    const bytes = new Uint8Array(buffer);
-    let binary = "";
-    for(let i = 0; i < bytes.byteLength; i++){
-        binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-}
-/**
- * Convert a base64 string to a Uint8Array.
- *
- * @param base64 - The base64 string to decode
- * @returns decoded Uint8Array
- *
- * @example
- * ```ts
- * const bytes = base64ToUint8Array(storedBase64);
- * ```
- */ export function base64ToUint8Array(base64) {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(binary.length);
-    for(let i = 0; i < binary.length; i++){
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}

package/dist/lib/feed.js

@@ -1,123 +0,0 @@
-/**
- * Default Feed Renderers
- *
- * RSS 2.0, Atom, and Sitemap XML generators.
- * Theme authors can import these to extend/wrap the defaults:
- *
- * @example
- * ```typescript
- * import { defaultRssRenderer } from "@jant/core/lib/feed";
- * ```
- */ /**
- * Escape special XML characters.
- */ function escapeXml(str) {
-    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-/**
- * Default RSS 2.0 renderer.
- *
- * @param data - Feed data with PostView[] (pre-computed URLs)
- * @returns RSS 2.0 XML string
- */ export function defaultRssRenderer(data) {
-    const { siteName, siteDescription, siteUrl, siteLanguage, posts } = data;
-    const items = posts.map((post)=>{
-        const link = `${siteUrl}${post.permalink}`;
-        const title = post.title || `Post #${post.id}`;
-        const pubDate = new Date(post.publishedAt).toUTCString();
-        // Add enclosure for first media attachment
-        const firstMedia = post.media[0];
-        const enclosure = firstMedia ? `\n      <enclosure url="${firstMedia.url}" type="${firstMedia.mimeType}"${firstMedia.size ? ` length="${firstMedia.size}"` : ""}/>` : "";
-        return `
-    <item>
-      <title><![CDATA[${escapeXml(title)}]]></title>
-      <link>${link}</link>
-      <guid isPermaLink="true">${link}</guid>
-      <pubDate>${pubDate}</pubDate>
-      <description><![CDATA[${post.bodyHtml || ""}]]></description>${enclosure}
-    </item>`;
-    }).join("");
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
-  <channel>
-    <title>${escapeXml(siteName)}</title>
-    <link>${siteUrl}</link>
-    <description>${escapeXml(siteDescription)}</description>
-    <language>${siteLanguage}</language>
-    <atom:link href="${siteUrl}/feed" rel="self" type="application/rss+xml"/>
-    ${items}
-  </channel>
-</rss>`;
-}
-/**
- * Default Atom renderer.
- *
- * @param data - Feed data with PostView[] (pre-computed URLs)
- * @returns Atom XML string
- */ export function defaultAtomRenderer(data) {
-    const { siteName, siteDescription, siteUrl, posts } = data;
-    const entries = posts.map((post)=>{
-        const link = `${siteUrl}${post.permalink}`;
-        const title = post.title || `Post #${post.id}`;
-        return `
-  <entry>
-    <title>${escapeXml(title)}</title>
-    <link href="${link}" rel="alternate"/>
-    <id>${link}</id>
-    <published>${post.publishedAt}</published>
-    <updated>${post.updatedAt}</updated>
-    <content type="html"><![CDATA[${post.bodyHtml || ""}]]></content>
-  </entry>`;
-    }).join("");
-    const now = new Date().toISOString();
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<feed xmlns="http://www.w3.org/2005/Atom">
-  <title>${escapeXml(siteName)}</title>
-  <subtitle>${escapeXml(siteDescription)}</subtitle>
-  <link href="${siteUrl}" rel="alternate"/>
-  <link href="${siteUrl}/feed/atom.xml" rel="self"/>
-  <id>${siteUrl}/</id>
-  <updated>${now}</updated>
-  ${entries}
-</feed>`;
-}
-/**
- * Default Sitemap renderer.
- *
- * @param data - Sitemap data with PostView[] and PageView[]
- * @returns Sitemap XML string
- */ export function defaultSitemapRenderer(data) {
-    const { siteUrl, posts, pages } = data;
-    const postUrls = posts.map((post)=>{
-        const loc = `${siteUrl}${post.permalink}`;
-        const lastmod = post.updatedAt.split("T")[0];
-        const priority = post.featured ? "0.8" : "0.6";
-        return `
-  <url>
-    <loc>${loc}</loc>
-    <lastmod>${lastmod}</lastmod>
-    <priority>${priority}</priority>
-  </url>`;
-    }).join("");
-    const pageUrls = pages.map((page)=>{
-        const loc = `${siteUrl}/${page.slug}`;
-        const lastmod = page.updatedAt.split("T")[0];
-        return `
-  <url>
-    <loc>${loc}</loc>
-    <lastmod>${lastmod}</lastmod>
-    <priority>0.7</priority>
-  </url>`;
-    }).join("");
-    const homepageUrl = `
-  <url>
-    <loc>${siteUrl}/</loc>
-    <priority>1.0</priority>
-    <changefreq>daily</changefreq>
-  </url>`;
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  ${homepageUrl}
-  ${postUrls}
-  ${pageUrls}
-</urlset>`;
-}

package/dist/lib/image-processor.js

@@ -1,187 +0,0 @@
-/**
- * Client-side Image Processor
- *
- * Processes images before upload:
- * - Corrects EXIF orientation
- * - Resizes to max dimensions
- * - Strips all metadata (privacy)
- * - Converts to WebP format
- */ const DEFAULT_OPTIONS = {
-    maxWidth: 1920,
-    maxHeight: 1920,
-    quality: 0.85,
-    mimeType: "image/webp"
-};
-/**
- * EXIF Orientation values and their transformations
- */ const ORIENTATIONS = {
-    1: {
-        rotate: 0,
-        flip: false
-    },
-    2: {
-        rotate: 0,
-        flip: true
-    },
-    3: {
-        rotate: 180,
-        flip: false
-    },
-    4: {
-        rotate: 180,
-        flip: true
-    },
-    5: {
-        rotate: 90,
-        flip: true
-    },
-    6: {
-        rotate: 90,
-        flip: false
-    },
-    7: {
-        rotate: 270,
-        flip: true
-    },
-    8: {
-        rotate: 270,
-        flip: false
-    }
-};
-/**
- * Read EXIF orientation from JPEG file
- */ function readExifOrientation(buffer) {
-    const view = new DataView(buffer);
-    // Check for JPEG SOI marker
-    if (view.getUint16(0) !== 0xffd8) return 1;
-    let offset = 2;
-    const length = view.byteLength;
-    while(offset < length){
-        if (view.getUint8(offset) !== 0xff) return 1;
-        const marker = view.getUint8(offset + 1);
-        // APP1 marker (EXIF)
-        if (marker === 0xe1) {
-            const exifOffset = offset + 4;
-            // Check for "Exif\0\0"
-            if (view.getUint32(exifOffset) !== 0x45786966 || view.getUint16(exifOffset + 4) !== 0x0000) {
-                return 1;
-            }
-            const tiffOffset = exifOffset + 6;
-            const littleEndian = view.getUint16(tiffOffset) === 0x4949;
-            // Validate TIFF header
-            if (view.getUint16(tiffOffset + 2, littleEndian) !== 0x002a) return 1;
-            const ifdOffset = view.getUint32(tiffOffset + 4, littleEndian);
-            const numEntries = view.getUint16(tiffOffset + ifdOffset, littleEndian);
-            // Search for orientation tag (0x0112)
-            for(let i = 0; i < numEntries; i++){
-                const entryOffset = tiffOffset + ifdOffset + 2 + i * 12;
-                const tag = view.getUint16(entryOffset, littleEndian);
-                if (tag === 0x0112) {
-                    return view.getUint16(entryOffset + 8, littleEndian);
-                }
-            }
-            return 1;
-        }
-        // Skip to next marker
-        if (marker === 0xd8 || marker === 0xd9) {
-            offset += 2;
-        } else {
-            offset += 2 + view.getUint16(offset + 2);
-        }
-    }
-    return 1;
-}
-/**
- * Load image from file
- */ function loadImage(file) {
-    return new Promise((resolve, reject)=>{
-        const img = new Image();
-        img.onload = ()=>{
-            URL.revokeObjectURL(img.src);
-            resolve(img);
-        };
-        img.onerror = ()=>reject(new Error("Failed to load image"));
-        img.src = URL.createObjectURL(file);
-    });
-}
-/**
- * Calculate output dimensions maintaining aspect ratio
- */ function calculateDimensions(width, height, maxWidth, maxHeight) {
-    if (width <= maxWidth && height <= maxHeight) {
-        return {
-            width,
-            height
-        };
-    }
-    const ratio = Math.min(maxWidth / width, maxHeight / height);
-    return {
-        width: Math.round(width * ratio),
-        height: Math.round(height * ratio)
-    };
-}
-/**
- * Process image file
- */ async function process(file, options = {}) {
-    const opts = {
-        ...DEFAULT_OPTIONS,
-        ...options
-    };
-    // Read file buffer for EXIF
-    const buffer = await file.arrayBuffer();
-    const orientation = readExifOrientation(buffer);
-    const transform = ORIENTATIONS[orientation] || ORIENTATIONS[1];
-    // Load image
-    const img = await loadImage(file);
-    // For 90° or 270° rotation, swap dimensions
-    const isRotated = transform.rotate === 90 || transform.rotate === 270;
-    const srcWidth = isRotated ? img.height : img.width;
-    const srcHeight = isRotated ? img.width : img.height;
-    // Calculate output size
-    const { width, height } = calculateDimensions(srcWidth, srcHeight, opts.maxWidth, opts.maxHeight);
-    // Create canvas
-    const canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) throw new Error("Failed to get canvas context");
-    // Apply transformations
-    ctx.save();
-    ctx.translate(width / 2, height / 2);
-    if (transform.rotate) {
-        ctx.rotate(transform.rotate * Math.PI / 180);
-    }
-    if (transform.flip) {
-        ctx.scale(-1, 1);
-    }
-    const drawWidth = isRotated ? height : width;
-    const drawHeight = isRotated ? width : height;
-    ctx.drawImage(img, -drawWidth / 2, -drawHeight / 2, drawWidth, drawHeight);
-    ctx.restore();
-    // Export as WebP
-    return new Promise((resolve, reject)=>{
-        canvas.toBlob((blob)=>{
-            if (blob) {
-                resolve(blob);
-            } else {
-                reject(new Error("Failed to create blob"));
-            }
-        }, opts.mimeType, opts.quality);
-    });
-}
-/**
- * Process file and create a new File object
- */ async function processToFile(file, options = {}) {
-    const blob = await process(file, options);
-    // Generate new filename with .webp extension
-    const originalName = file.name.replace(/\.[^.]+$/, "");
-    const newName = `${originalName}.webp`;
-    return new File([
-        blob
-    ], newName, {
-        type: "image/webp"
-    });
-}
-export const ImageProcessor = {
-    process,
-    processToFile
-};

package/dist/lib/image.js

@@ -1,97 +0,0 @@
-/**
- * Image URL utilities
- *
- * Provides helpers for generating image URLs with optional transformations.
- */ /**
- * Options for image transformations
- */ /**
- * Generates an image URL with optional transformations.
- *
- * If `transformUrl` is provided and options are specified, returns a transformed image URL.
- * Otherwise, returns the original URL unchanged.
- *
- * Compatible with:
- * - Cloudflare Image Transformations (`/cdn-cgi/image/...`)
- * - imgproxy
- * - Cloudinary
- * - Any service with similar URL-based transformation API
- *
- * @param originalUrl - The original image URL
- * @param transformUrl - The base URL for transformations (e.g., `https://example.com/cdn-cgi/image`)
- * @param options - Transformation options (width, height, quality, format, fit)
- * @returns The transformed URL or original URL if transformations are not configured
- *
- * @example
- * ```ts
- * // Without transform URL - returns original
- * getImageUrl("/media/abc123", undefined, { width: 200 });
- * // Returns: "/media/abc123"
- *
- * // With transform URL - returns transformed
- * getImageUrl("/media/abc123", "https://example.com/cdn-cgi/image", { width: 200, quality: 80 });
- * // Returns: "https://example.com/cdn-cgi/image/width=200,quality=80/https://example.com/media/abc123"
- * ```
- */ export function getImageUrl(originalUrl, transformUrl, options) {
-    if (!transformUrl || !options || Object.keys(options).length === 0) {
-        return originalUrl;
-    }
-    const params = [];
-    if (options.width) params.push(`width=${options.width}`);
-    if (options.height) params.push(`height=${options.height}`);
-    if (options.quality) params.push(`quality=${options.quality}`);
-    if (options.format) params.push(`format=${options.format}`);
-    if (options.fit) params.push(`fit=${options.fit}`);
-    if (params.length === 0) {
-        return originalUrl;
-    }
-    return `${transformUrl}/${params.join(",")}/${originalUrl}`;
-}
-/**
- * Returns the appropriate public URL base for a given storage provider.
- *
- * For `"s3"` provider, returns `s3PublicUrl`. For all other providers
- * (including `"r2"`), returns `r2PublicUrl`. Falls back to `undefined`
- * if the matching URL is not configured.
- *
- * @param provider - The storage provider identifier (e.g., `"r2"`, `"s3"`)
- * @param r2PublicUrl - Optional R2 public URL
- * @param s3PublicUrl - Optional S3 public URL
- * @returns The public URL base for the provider, or undefined
- *
- * @example
- * ```ts
- * getPublicUrlForProvider("r2", "https://r2.example.com", "https://s3.example.com");
- * // Returns: "https://r2.example.com"
- *
- * getPublicUrlForProvider("s3", "https://r2.example.com", "https://s3.example.com");
- * // Returns: "https://s3.example.com"
- * ```
- */ export function getPublicUrlForProvider(provider, r2PublicUrl, s3PublicUrl) {
-    if (provider === "s3") return s3PublicUrl;
-    return r2PublicUrl;
-}
-/**
- * Generates a media URL from a storage key.
- *
- * Both proxy and CDN paths use the same structure — only the domain differs.
- * Without a public URL, returns a root-relative path for the local proxy.
- * With a public URL, prefixes that domain.
- *
- * @param storageKey - The storage object key (e.g. `"media/2025/01/uuid.webp"`)
- * @param publicUrl - Optional public URL base for direct CDN access
- * @returns The public URL for the media file
- *
- * @example
- * ```ts
- * // Without public URL - local proxy
- * getMediaUrl("media/2025/01/01902a9f-1a2b-7c3d.webp");
- * // Returns: "/media/2025/01/01902a9f-1a2b-7c3d.webp"
- *
- * // With public URL - CDN
- * getMediaUrl("media/2025/01/01902a9f-1a2b-7c3d.webp", "https://cdn.example.com");
- * // Returns: "https://cdn.example.com/media/2025/01/01902a9f-1a2b-7c3d.webp"
- * ```
- */ export function getMediaUrl(storageKey, publicUrl) {
-    const base = publicUrl ? publicUrl.replace(/\/+$/, "") : "";
-    return `${base}/${storageKey}`;
-}

package/dist/lib/index.js

@@ -1,7 +0,0 @@
-/**
- * Utility Functions
- */ export * from "./constants.js";
-export * as sqid from "./sqid.js";
-export * as time from "./time.js";
-export * as url from "./url.js";
-export * as markdown from "./markdown.js";

package/dist/lib/markdown.js

@@ -1,83 +0,0 @@
-/**
- * Markdown Rendering
- *
- * Uses marked with minimal configuration
- */ import { marked } from "marked";
-// Configure marked for security and simplicity
-marked.setOptions({
-    gfm: true,
-    breaks: true
-});
-/**
- * Renders Markdown content to HTML using the marked library.
- *
- * Configured with GitHub Flavored Markdown (GFM) support and line breaks enabled.
- * Uses synchronous parsing for simplicity and consistency in server-side rendering.
- *
- * @param markdown - The Markdown string to convert to HTML
- * @returns The rendered HTML string
- *
- * @example
- * ```ts
- * const html = render("# Hello\n\nThis is **bold** text.");
- * // Returns: "<h1>Hello</h1>\n<p>This is <strong>bold</strong> text.</p>"
- * ```
- */ export function render(markdown) {
-    return marked.parse(markdown, {
-        async: false
-    });
-}
-/**
- * Converts Markdown to plain text by stripping all formatting syntax.
- *
- * Removes Markdown syntax including headers, bold, italic, links, images, code blocks,
- * blockquotes, lists, and converts newlines to spaces. Useful for generating text excerpts,
- * meta descriptions, or search indexes.
- *
- * @param markdown - The Markdown string to convert to plain text
- * @returns The plain text string with all Markdown syntax removed
- *
- * @example
- * ```ts
- * const plain = toPlainText("## Hello\n\nThis is **bold** and [a link](url).");
- * // Returns: "Hello This is bold and a link."
- * ```
- */ export function toPlainText(markdown) {
-    return markdown.replace(/#{1,6}\s+/g, "") // Remove headers
-    .replace(/\*\*(.+?)\*\*/g, "$1") // Bold
-    .replace(/\*(.+?)\*/g, "$1") // Italic
-    .replace(/\[(.+?)\]\(.+?\)/g, "$1") // Links
-    .replace(/!\[.*?\]\(.+?\)/g, "") // Images
-    .replace(/`{1,3}[^`]*`{1,3}/g, "") // Code
-    .replace(/>\s+/g, "") // Blockquotes
-    .replace(/[-*+]\s+/g, "") // Lists
-    .replace(/\n+/g, " ") // Newlines
-    .trim();
-}
-/**
- * Extracts a title from Markdown content by taking the first sentence or line.
- *
- * Converts Markdown to plain text first, then takes the first sentence (split by `.!?`)
- * or truncates to the specified maximum length. Useful for generating automatic titles
- * from post content when no explicit title is provided.
- *
- * @param markdown - The Markdown string to extract a title from
- * @param maxLength - Maximum length of the extracted title (default: 120)
- * @returns The extracted title string, with "..." appended if truncated
- *
- * @example
- * ```ts
- * const title = extractTitle("This is the first sentence. And another one.", 50);
- * // Returns: "This is the first sentence"
- *
- * const title = extractTitle("A very long sentence that exceeds the maximum length...", 30);
- * // Returns: "A very long sentence that ex..."
- * ```
- */ export function extractTitle(markdown, maxLength = 120) {
-    const plain = toPlainText(markdown);
-    const firstLine = plain.split(/[.!?]/)[0] ?? plain;
-    if (firstLine.length <= maxLength) {
-        return firstLine;
-    }
-    return plain.slice(0, maxLength).trim() + "...";
-}

package/dist/lib/media-helpers.js

@@ -1,49 +0,0 @@
-/**
- * Media Helper Utilities
- *
- * Shared logic for building MediaAttachment maps from raw media data.
- */ import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "./image.js";
-/**
- * Builds a map of post IDs to MediaAttachment arrays from raw media data.
- *
- * Transforms raw Media objects (with storage keys) into MediaAttachment objects
- * (with public URLs and preview URLs) suitable for rendering.
- * Automatically resolves the correct public URL based on each media item's
- * storage provider (`"r2"` or `"s3"`).
- *
- * @param rawMediaMap - Map of post IDs to raw Media arrays from the media service
- * @param r2PublicUrl - Optional R2 public URL for direct CDN access
- * @param imageTransformUrl - Optional image transformation service URL
- * @param s3PublicUrl - Optional S3 public URL for direct CDN access
- * @returns Map of post IDs to MediaAttachment arrays
- *
- * @example
- * ```ts
- * const rawMediaMap = await services.media.getByPostIds(postIds);
- * const mediaMap = buildMediaMap(rawMediaMap, c.env.R2_PUBLIC_URL, c.env.IMAGE_TRANSFORM_URL, c.env.S3_PUBLIC_URL);
- * ```
- */ export function buildMediaMap(rawMediaMap, r2PublicUrl, imageTransformUrl, s3PublicUrl) {
-    const mediaMap = new Map();
-    for (const [postId, mediaList] of rawMediaMap){
-        mediaMap.set(postId, mediaList.map((m)=>{
-            const publicUrl = getPublicUrlForProvider(m.provider, r2PublicUrl, s3PublicUrl);
-            return {
-                id: m.id,
-                url: getMediaUrl(m.storageKey, publicUrl),
-                previewUrl: getImageUrl(getMediaUrl(m.storageKey, publicUrl), imageTransformUrl, {
-                    width: 400,
-                    quality: 80,
-                    format: "auto",
-                    fit: "cover"
-                }),
-                alt: m.alt,
-                blurhash: m.blurhash,
-                width: m.width,
-                height: m.height,
-                position: m.position,
-                mimeType: m.mimeType
-            };
-        }));
-    }
-    return mediaMap;
-}