@jant/core 0.3.26 → 0.3.28

package/dist/lib/sse.js

@@ -1,218 +0,0 @@
-/**
- * Datastar response utilities for v1.0.0-RC.7
- *
- * Provides both SSE (multi-event) and plain HTTP (single-event) response helpers.
- *
- * **Non-SSE helpers** (preferred for single operations):
- * - `dsRedirect(url)` — redirect via text/html
- * - `dsToast(message, type)` — toast notification via text/html
- * - `dsSignals(signals)` — signal patch via application/json
- *
- * **SSE** (for multiple operations in one response):
- * - `sse(c, handler)` — streaming SSE with full stream API
- *
- * Datastar auto-detects response type by Content-Type:
- * - `text/html` → dispatches as `datastar-patch-elements`
- * - `application/json` → dispatches as `datastar-patch-signals`
- *
- * @see https://data-star.dev/
- */ // ---------------------------------------------------------------------------
-// Shared internal helpers (used by both SSE and non-SSE response builders)
-// ---------------------------------------------------------------------------
-/** Build the redirect script tag for Datastar patch-elements */ function buildRedirectScript(url) {
-    const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-    return `<script data-effect="el.remove()">window.location.href='${escapedUrl}'</script>`;
-}
-/** Build a toast notification HTML element */ function buildToastHtml(message, type) {
-    const cls = type === "error" ? "toast-error" : "toast-success";
-    const icon = type === "error" ? '<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor"><circle cx="12" cy="12" r="10"/><path d="m15 9-6 6M9 9l6 6"/></svg>' : '<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor"><circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/></svg>';
-    const closeBtn = `<button class="toast-close" data-on:click="el.closest('.toast').classList.add('toast-out'); el.closest('.toast').addEventListener('animationend', () => el.closest('.toast').remove())"><svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor"><path d="M18 6 6 18M6 6l12 12"/></svg></button>`;
-    const escapedMessage = message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    return `<div class="toast ${cls}" data-init="setTimeout(() => { el.classList.add('toast-out'); el.addEventListener('animationend', () => el.remove()) }, 3000)">${icon}<span>${escapedMessage}</span>${closeBtn}</div>`;
-}
-// ---------------------------------------------------------------------------
-// SSE helpers
-// ---------------------------------------------------------------------------
-/**
- * Format a single SSE event string
- *
- * @param eventType - The Datastar event type (e.g. "datastar-patch-elements")
- * @param dataLines - Array of "key value" data lines
- * @returns Formatted SSE event string
- */ function formatEvent(eventType, dataLines) {
-    let event = `event: ${eventType}\n`;
-    for (const line of dataLines){
-        event += `data: ${line}\n`;
-    }
-    event += "\n";
-    return event;
-}
-/**
- * Create an SSE response for Datastar
- *
- * @param c - Hono context
- * @param handler - Async function that writes to the SSE stream
- * @param options - Optional response options (e.g. headers for cookie forwarding)
- * @returns Response with SSE content-type
- *
- * @example
- * ```ts
- * app.post("/api/upload", (c) => {
- *   return sse(c, async (stream) => {
- *     await stream.patchSignals({ uploading: false });
- *     await stream.patchElements('<div id="new-item">...</div>', {
- *       mode: 'append',
- *       selector: '#items'
- *     });
- *   });
- * });
- *
- * // With cookie forwarding (for auth)
- * app.post("/signin", (c) => {
- *   return sse(c, async (stream) => {
- *     await stream.redirect('/dash');
- *   }, { headers: { 'Set-Cookie': cookieValue } });
- * });
- * ```
- */ export function sse(c, handler, options) {
-    const encoder = new TextEncoder();
-    const body = new ReadableStream({
-        async start (controller) {
-            const stream = {
-                patchSignals (signals, opts) {
-                    const dataLines = [
-                        `signals ${JSON.stringify(signals)}`
-                    ];
-                    if (opts?.onlyIfMissing) {
-                        dataLines.push("onlyIfMissing true");
-                    }
-                    controller.enqueue(encoder.encode(formatEvent("datastar-patch-signals", dataLines)));
-                },
-                patchElements (html, opts) {
-                    const dataLines = [];
-                    // Each line of HTML gets its own "elements <line>" data line
-                    for (const line of html.split("\n")){
-                        dataLines.push(`elements ${line}`);
-                    }
-                    if (opts?.mode) {
-                        dataLines.push(`mode ${opts.mode}`);
-                    }
-                    if (opts?.selector) {
-                        dataLines.push(`selector ${opts.selector}`);
-                    }
-                    if (opts?.useViewTransition) {
-                        dataLines.push("useViewTransition true");
-                    }
-                    controller.enqueue(encoder.encode(formatEvent("datastar-patch-elements", dataLines)));
-                },
-                redirect (url) {
-                    const dataLines = [
-                        `elements ${buildRedirectScript(url)}`,
-                        "mode append",
-                        "selector body"
-                    ];
-                    controller.enqueue(encoder.encode(formatEvent("datastar-patch-elements", dataLines)));
-                },
-                remove (selector) {
-                    controller.enqueue(encoder.encode(formatEvent("datastar-patch-elements", [
-                        "elements ",
-                        `mode remove`,
-                        `selector ${selector}`
-                    ])));
-                },
-                toast (message, type = "success") {
-                    const dataLines = [
-                        `elements ${buildToastHtml(message, type)}`,
-                        "mode append",
-                        "selector #toast-container"
-                    ];
-                    controller.enqueue(encoder.encode(formatEvent("datastar-patch-elements", dataLines)));
-                }
-            };
-            await handler(stream);
-            controller.close();
-        }
-    });
-    const headers = {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        ...options?.headers
-    };
-    return new Response(body, {
-        headers
-    });
-}
-// ---------------------------------------------------------------------------
-// Non-SSE Datastar helpers (for single-operation responses)
-// ---------------------------------------------------------------------------
-/**
- * Datastar redirect via text/html
- *
- * Returns a plain HTML response that Datastar dispatches as `datastar-patch-elements`.
- * Use instead of `sse()` when the only action is a redirect.
- *
- * @param url - The URL to redirect to
- * @param options - Optional extra headers (accepts any `HeadersInit`)
- * @returns Response with text/html content-type
- *
- * @example
- * ```ts
- * return dsRedirect("/dash/posts");
- *
- * // With cookie forwarding (for auth)
- * return dsRedirect("/dash", { headers: authResponse.headers });
- * ```
- */ export function dsRedirect(url, options) {
-    const headers = options?.headers ? new Headers(options.headers) : new Headers();
-    headers.set("Content-Type", "text/html");
-    headers.set("Datastar-Mode", "append");
-    headers.set("Datastar-Selector", "body");
-    return new Response(buildRedirectScript(url), {
-        headers
-    });
-}
-/**
- * Datastar toast notification via text/html
- *
- * Returns a plain HTML response that Datastar dispatches as `datastar-patch-elements`.
- * Use instead of `sse()` when the only action is showing a toast.
- *
- * @param message - The message to display
- * @param type - Toast type: "success" (default) or "error"
- * @returns Response with text/html content-type
- *
- * @example
- * ```ts
- * return dsToast("Settings saved successfully.");
- * return dsToast("Something went wrong.", "error");
- * ```
- */ export function dsToast(message, type = "success") {
-    return new Response(buildToastHtml(message, type), {
-        headers: {
-            "Content-Type": "text/html",
-            "Datastar-Mode": "append",
-            "Datastar-Selector": "#toast-container"
-        }
-    });
-}
-/**
- * Datastar signal patch via application/json
- *
- * Returns a JSON response that Datastar dispatches as `datastar-patch-signals`.
- * Use instead of `sse()` when the only action is updating signals.
- *
- * @param signals - Object containing signal values to update
- * @returns Response with application/json content-type
- *
- * @example
- * ```ts
- * return dsSignals({ _uploadError: "File too large" });
- * ```
- */ export function dsSignals(signals) {
-    return new Response(JSON.stringify(signals), {
-        headers: {
-            "Content-Type": "application/json"
-        }
-    });
-}

package/dist/lib/storage.js

@@ -1,164 +0,0 @@
-/**
- * Storage Driver Abstraction
- *
- * Provides a common interface for file storage with R2 and S3-compatible backends.
- */ /**
- * Creates an R2 storage driver that delegates to a Cloudflare R2 bucket binding.
- *
- * @param r2 - The R2 bucket binding from the Cloudflare Workers environment
- * @returns A StorageDriver backed by R2
- */ export function createR2Driver(r2) {
-    return {
-        async put (key, body, opts) {
-            await r2.put(key, body, {
-                httpMetadata: opts?.contentType ? {
-                    contentType: opts.contentType
-                } : undefined
-            });
-        },
-        async get (key) {
-            const object = await r2.get(key);
-            if (!object) return null;
-            return {
-                body: object.body,
-                contentType: object.httpMetadata?.contentType ?? undefined
-            };
-        },
-        async delete (key) {
-            await r2.delete(key);
-        }
-    };
-}
-/**
- * Creates an S3-compatible storage driver using the AWS SDK.
- *
- * Supports any S3-compatible service: AWS S3, Backblaze B2, MinIO, etc.
- * Uses path-style addressing for non-AWS endpoints.
- *
- * @param config - S3 connection configuration
- * @returns A StorageDriver backed by S3
- */ export function createS3Driver(config) {
-    // Lazy-load the AWS SDK to avoid bundling it when using R2
-    let clientPromise = null;
-    function getClient() {
-        if (!clientPromise) {
-            clientPromise = import("@aws-sdk/client-s3").then((sdk)=>{
-                const forcePathStyle = !config.endpoint.includes("amazonaws.com");
-                const client = new sdk.S3Client({
-                    endpoint: config.endpoint,
-                    region: config.region,
-                    credentials: {
-                        accessKeyId: config.accessKeyId,
-                        secretAccessKey: config.secretAccessKey
-                    },
-                    forcePathStyle
-                });
-                return {
-                    send: (cmd)=>client.send(cmd),
-                    S3Client: sdk.S3Client,
-                    PutObjectCommand: sdk.PutObjectCommand,
-                    GetObjectCommand: sdk.GetObjectCommand,
-                    DeleteObjectCommand: sdk.DeleteObjectCommand,
-                    bucket: config.bucket
-                };
-            });
-        }
-        return clientPromise;
-    }
-    return {
-        async put (key, body, opts) {
-            const s3 = await getClient();
-            // Buffer the stream to Uint8Array for the S3 SDK
-            let bodyBytes;
-            if (body instanceof Uint8Array) {
-                bodyBytes = body;
-            } else {
-                const reader = body.getReader();
-                const chunks = [];
-                for(;;){
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    chunks.push(value);
-                }
-                let totalLength = 0;
-                for (const chunk of chunks)totalLength += chunk.length;
-                bodyBytes = new Uint8Array(totalLength);
-                let offset = 0;
-                for (const chunk of chunks){
-                    bodyBytes.set(chunk, offset);
-                    offset += chunk.length;
-                }
-            }
-            const command = new s3.PutObjectCommand({
-                Bucket: s3.bucket,
-                Key: key,
-                Body: bodyBytes,
-                ContentType: opts?.contentType
-            });
-            await s3.send(command);
-        },
-        async get (key) {
-            const s3 = await getClient();
-            try {
-                const command = new s3.GetObjectCommand({
-                    Bucket: s3.bucket,
-                    Key: key
-                });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- AWS SDK response type
-                const response = await s3.send(command);
-                if (!response.Body) return null;
-                return {
-                    body: response.Body.transformToWebStream(),
-                    contentType: response.ContentType ?? undefined
-                };
-            } catch (err) {
-                // NoSuchKey → return null instead of throwing
-                if (err instanceof Error && (err.name === "NoSuchKey" || err.name === "NotFound")) {
-                    return null;
-                }
-                throw err;
-            }
-        },
-        async delete (key) {
-            const s3 = await getClient();
-            const command = new s3.DeleteObjectCommand({
-                Bucket: s3.bucket,
-                Key: key
-            });
-            await s3.send(command);
-        }
-    };
-}
-/**
- * Creates the appropriate storage driver based on environment configuration.
- *
- * Returns `null` if no storage is configured (no R2 binding and no S3 config).
- *
- * @param env - The Cloudflare Workers environment bindings
- * @returns A StorageDriver instance or null
- *
- * @example
- * ```ts
- * const storage = createStorageDriver(c.env);
- * if (storage) {
- *   await storage.put("media/file.jpg", stream, { contentType: "image/jpeg" });
- * }
- * ```
- */ export function createStorageDriver(env) {
-    const driver = env.STORAGE_DRIVER || "r2";
-    if (driver === "s3") {
-        if (!env.S3_ENDPOINT || !env.S3_BUCKET || !env.S3_ACCESS_KEY_ID || !env.S3_SECRET_ACCESS_KEY) {
-            return null;
-        }
-        return createS3Driver({
-            endpoint: env.S3_ENDPOINT,
-            bucket: env.S3_BUCKET,
-            accessKeyId: env.S3_ACCESS_KEY_ID,
-            secretAccessKey: env.S3_SECRET_ACCESS_KEY,
-            region: env.S3_REGION || "auto"
-        });
-    }
-    // Default: R2
-    if (!env.R2) return null;
-    return createR2Driver(env.R2);
-}

package/dist/lib/theme.js

@@ -1,65 +0,0 @@
-/**
- * Theme Resolution Helpers
- *
- * Resolves the active color theme and builds CSS for injection into `<head>`.
- */ import { BUILTIN_COLOR_THEMES } from "../ui/color-themes.js";
-/**
- * Get the list of available color themes.
- *
- * Returns `config.colorThemes` if provided, otherwise the built-in list.
- *
- * @param config - The Jant configuration
- * @returns Array of available color themes
- *
- * @example
- * ```typescript
- * const themes = getAvailableThemes(c.var.config);
- * ```
- */ export function getAvailableThemes(config) {
-    return config.colorThemes ?? BUILTIN_COLOR_THEMES;
-}
-/**
- * Build a `<style>` CSS string from a color theme and optional cssVariables overlay.
- *
- * Priority (lowest → highest):
- *   BaseCoat defaults → selected theme → cssVariables
- *
- * @param theme - The active color theme (undefined = no theme overrides)
- * @param cssVariables - Extra CSS variable overrides from `createApp({ cssVariables })`
- * @returns CSS string to inject in `<head>`, or empty string if nothing to inject
- *
- * Uses `:root:root` and `:root.dark` selectors for higher specificity than
- * BaseCoat defaults (`:root` and `.dark`). This ensures theme overrides win
- * regardless of source order — important because Vite dev mode injects CSS
- * as `<style>` tags after the theme `<style>`.
- *
- * @example
- * ```typescript
- * const css = buildThemeStyle(blueTheme, { "--radius": "0.5rem" });
- * // => ":root:root { --primary: oklch(...); ... }\n:root.dark { ... }"
- * ```
- */ export function buildThemeStyle(theme, cssVariables) {
-    const lightVars = {
-        ...theme?.light ?? {},
-        ...cssVariables ?? {}
-    };
-    const darkVars = {
-        ...theme?.dark ?? {},
-        ...cssVariables ?? {}
-    };
-    const hasLight = Object.keys(lightVars).length > 0;
-    const hasDark = Object.keys(darkVars).length > 0;
-    if (!hasLight && !hasDark) return "";
-    const parts = [];
-    if (hasLight) {
-        const declarations = Object.entries(lightVars).map(([k, v])=>`  ${k}: ${v};`).join("\n");
-        // :root:root has specificity (0,0,2) > BaseCoat's :root (0,0,1)
-        parts.push(`:root:root {\n${declarations}\n}`);
-    }
-    if (hasDark) {
-        const declarations = Object.entries(darkVars).map(([k, v])=>`  ${k}: ${v};`).join("\n");
-        // :root.dark has specificity (0,1,1) > BaseCoat's .dark (0,1,0)
-        parts.push(`:root.dark {\n${declarations}\n}`);
-    }
-    return parts.join("\n");
-}

package/dist/lib/time.js

@@ -1,159 +0,0 @@
-/**
- * Time Utilities
- */ /**
- * Gets the current Unix timestamp in seconds.
- *
- * Returns the number of seconds since the Unix epoch (January 1, 1970 00:00:00 UTC).
- * This is the standard time format used throughout the application for consistency
- * and database storage.
- *
- * @returns Current Unix timestamp in seconds (not milliseconds)
- *
- * @example
- * ```ts
- * const timestamp = now();
- * // Returns: 1706745600 (example value for Feb 1, 2024)
- * ```
- */ export function now() {
-    return Math.floor(Date.now() / 1000);
-}
-/**
- * One month in seconds
- */ const ONE_MONTH = 30 * 24 * 60 * 60;
-/**
- * Checks if a Unix timestamp is within the last 30 days.
- *
- * Compares the given timestamp to the current time to determine if it falls within
- * the last month (defined as 30 days). Useful for highlighting recent posts or
- * filtering time-sensitive content.
- *
- * @param timestamp - Unix timestamp in seconds to check
- * @returns `true` if the timestamp is within the last 30 days, `false` otherwise
- *
- * @example
- * ```ts
- * const recentPost = 1706745600;  // Recent timestamp
- * if (isWithinMonth(recentPost)) {
- *   // Show "new" badge
- * }
- * ```
- */ export function isWithinMonth(timestamp) {
-    return now() - timestamp < ONE_MONTH;
-}
-/**
- * Converts a Unix timestamp to an ISO 8601 date-time string.
- *
- * Formats a Unix timestamp (in seconds) as an ISO 8601 string suitable for HTML
- * `datetime` attributes and API responses. The output includes full date, time,
- * and timezone information in UTC.
- *
- * @param timestamp - Unix timestamp in seconds to convert
- * @returns ISO 8601 formatted string (e.g., "2024-02-01T12:00:00.000Z")
- *
- * @example
- * ```ts
- * const isoDate = toISOString(1706745600);
- * // Returns: "2024-02-01T00:00:00.000Z"
- * ```
- */ export function toISOString(timestamp) {
-    return new Date(timestamp * 1000).toISOString();
-}
-/**
- * Formats a Unix timestamp as a human-readable date string.
- *
- * Converts a Unix timestamp (in seconds) to a localized date string in the format
- * "MMM DD, YYYY" (e.g., "Jan 15, 2024"). Always uses UTC timezone to ensure
- * consistent display regardless of server or client location.
- *
- * @param timestamp - Unix timestamp in seconds to format
- * @returns Formatted date string in "MMM DD, YYYY" format
- *
- * @example
- * ```ts
- * const readable = formatDate(1706745600);
- * // Returns: "Feb 1, 2024"
- * ```
- */ export function formatDate(timestamp) {
-    return new Date(timestamp * 1000).toLocaleDateString("en-US", {
-        year: "numeric",
-        month: "short",
-        day: "numeric",
-        timeZone: "UTC"
-    });
-}
-/**
- * Formats a Unix timestamp as a year-month string for grouping.
- *
- * Converts a Unix timestamp (in seconds) to a "YYYY-MM" format string, useful for
- * grouping posts by month in archives or creating month-based URLs. Always uses
- * UTC timezone for consistency.
- *
- * @param timestamp - Unix timestamp in seconds to format
- * @returns Year-month string in "YYYY-MM" format
- *
- * @example
- * ```ts
- * const yearMonth = formatYearMonth(1706745600);
- * // Returns: "2024-02"
- * ```
- */ /**
- * Formats a Unix timestamp as a 24-hour time string (HH:MM).
- *
- * Converts a Unix timestamp (in seconds) to a zero-padded time string in
- * 24-hour format. Always uses UTC timezone for consistency.
- *
- * @param timestamp - Unix timestamp in seconds to format
- * @returns Formatted time string in "HH:MM" format
- *
- * @example
- * ```ts
- * const time = formatTime(1706745600);
- * // Returns: "00:00"
- * ```
- */ export function formatTime(timestamp) {
-    const date = new Date(timestamp * 1000);
-    const hours = String(date.getUTCHours()).padStart(2, "0");
-    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
-    return `${hours}:${minutes}`;
-}
-/**
- * Formats a Unix timestamp as a short relative time string.
- *
- * Returns compact labels like "1m", "5h", "3d" for recent timestamps,
- * and falls back to "MMM D" (e.g. "Feb 1") for anything older than 7 days.
- *
- * @param timestamp - Unix timestamp in seconds
- * @returns Short relative time string
- *
- * @example
- * ```ts
- * // Assuming current time is Feb 16, 2026
- * formatRelativeTime(now() - 30);       // "1m"  (30 seconds → rounds up)
- * formatRelativeTime(now() - 3600);     // "1h"
- * formatRelativeTime(now() - 86400);    // "1d"
- * formatRelativeTime(now() - 604800);   // "7d"
- * formatRelativeTime(now() - 864000);   // "Feb 6"
- * ```
- */ export function formatRelativeTime(timestamp) {
-    const seconds = now() - timestamp;
-    if (seconds < 60) return "1m";
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60) return `${minutes}m`;
-    const hours = Math.floor(seconds / 3600);
-    if (hours < 24) return `${hours}h`;
-    const days = Math.floor(seconds / 86400);
-    if (days <= 7) return `${days}d`;
-    // Older than 7 days: show "MMM D" (e.g. "Feb 1")
-    const date = new Date(timestamp * 1000);
-    return date.toLocaleDateString("en-US", {
-        month: "short",
-        day: "numeric",
-        timeZone: "UTC"
-    });
-}
-export function formatYearMonth(timestamp) {
-    const date = new Date(timestamp * 1000);
-    const year = date.getUTCFullYear();
-    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-    return `${year}-${month}`;
-}