@jant/core 0.3.6 → 0.3.8

package/dist/lib/schemas.d.ts

@@ -1,113 +0,0 @@
-/**
- * Shared Zod schemas for validation
- *
- * These schemas ensure type-safe validation of user input
- * from forms, API requests, and other external sources.
- *
- * IMPORTANT: Types are defined in types.ts as the single source of truth.
- * This file only defines Zod validation schemas based on those types.
- */
-import { z } from "zod";
-/**
- * Post type enum schema
- * Based on POST_TYPES from types.ts
- */
-export declare const PostTypeSchema: z.ZodEnum<{
-    note: "note";
-    article: "article";
-    link: "link";
-    quote: "quote";
-    image: "image";
-    page: "page";
-}>;
-/**
- * Visibility enum schema
- * Based on VISIBILITY_LEVELS from types.ts
- */
-export declare const VisibilitySchema: z.ZodEnum<{
-    featured: "featured";
-    quiet: "quiet";
-    unlisted: "unlisted";
-    draft: "draft";
-}>;
-/**
- * Redirect type enum schema
- * Form input validation for redirect type (stored as number in DB)
- */
-export declare const RedirectTypeSchema: z.ZodEnum<{
-    301: "301";
-    302: "302";
-}>;
-/**
- * API request body schema for creating a post
- */
-export declare const CreatePostSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        note: "note";
-        article: "article";
-        link: "link";
-        quote: "quote";
-        image: "image";
-        page: "page";
-    }>;
-    title: z.ZodOptional<z.ZodString>;
-    content: z.ZodString;
-    visibility: z.ZodEnum<{
-        featured: "featured";
-        quiet: "quiet";
-        unlisted: "unlisted";
-        draft: "draft";
-    }>;
-    sourceUrl: z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodLiteral<"">]>;
-    sourceName: z.ZodOptional<z.ZodString>;
-    path: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
-    replyToId: z.ZodOptional<z.ZodString>;
-    publishedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * API request body schema for updating a post
- */
-export declare const UpdatePostSchema: z.ZodObject<{
-    type: z.ZodOptional<z.ZodEnum<{
-        note: "note";
-        article: "article";
-        link: "link";
-        quote: "quote";
-        image: "image";
-        page: "page";
-    }>>;
-    title: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    content: z.ZodOptional<z.ZodString>;
-    visibility: z.ZodOptional<z.ZodEnum<{
-        featured: "featured";
-        quiet: "quiet";
-        unlisted: "unlisted";
-        draft: "draft";
-    }>>;
-    sourceUrl: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodURL>, z.ZodLiteral<"">]>>;
-    sourceName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    path: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
-    replyToId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    publishedAt: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strip>;
-/**
- * Form data helper: safely parse a FormData value with a schema
- *
- * @example
- * ```ts
- * const type = parseFormData(formData, "type", PostTypeSchema);
- * // type is PostType, throws if invalid
- * ```
- */
-export declare function parseFormData<T>(formData: FormData, key: string, schema: z.ZodSchema<T>): T;
-/**
- * Form data helper: safely parse optional FormData value with a schema
- *
- * @example
- * ```ts
- * const slug = parseFormDataOptional(formData, "slug", z.string());
- * // slug is string | undefined
- * ```
- */
-export declare function parseFormDataOptional<T>(formData: FormData, key: string, schema: z.ZodSchema<T>): T | undefined;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/lib/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;EAAqB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;EAA4B,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;EAAyB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAc3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAC;AAE3D;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,CAAC,CAMH;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,CAAC,GAAG,SAAS,CAMf"}

package/dist/lib/sqid.d.ts

@@ -1,60 +0,0 @@
-/**
- * Sqids - Short unique IDs for URLs
- *
- * Encodes numeric IDs to short strings like "jR3k"
- */
-/**
- * Encodes a numeric database ID to a short, URL-friendly string.
- *
- * Uses the Sqids library to generate short unique identifiers with a minimum length of 4 characters.
- * These are used in URLs (e.g., `/p/jR3k`) to obscure sequential integer IDs while maintaining
- * uniqueness and reversibility.
- *
- * @param id - The numeric database ID to encode
- * @returns A short string representation of the ID (minimum 4 characters)
- *
- * @example
- * ```ts
- * const sqid = encode(123);
- * // Returns: "jR3k" (or similar short string)
- * ```
- */
-export declare function encode(id: number): string;
-/**
- * Decodes a sqid string back to the original numeric database ID.
- *
- * Attempts to decode a sqid string generated by the `encode()` function. Returns the original
- * numeric ID if valid, or `null` if the string is not a valid sqid. This is used to extract
- * database IDs from URL parameters.
- *
- * @param str - The sqid string to decode
- * @returns The original numeric ID if valid, or `null` if decoding fails
- *
- * @example
- * ```ts
- * const id = decode("jR3k");
- * // Returns: 123
- *
- * const invalid = decode("invalid");
- * // Returns: null
- * ```
- */
-export declare function decode(str: string): number | null;
-/**
- * Checks if a string is a valid sqid that can be decoded.
- *
- * Validates whether a string can be successfully decoded to a numeric ID.
- * Useful for route validation and input sanitization.
- *
- * @param str - The string to validate
- * @returns `true` if the string is a valid sqid, `false` otherwise
- *
- * @example
- * ```ts
- * if (isValidSqid("jR3k")) {
- *   // Process the valid sqid
- * }
- * ```
- */
-export declare function isValidSqid(str: string): boolean;
-//# sourceMappingURL=sqid.d.ts.map

package/dist/lib/sqid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sqid.d.ts","sourceRoot":"","sources":["../../src/lib/sqid.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOjD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/dist/lib/sse.d.ts

@@ -1,192 +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/
- */
-import type { Context } from "hono";
-/**
- * Patch modes for DOM element updates
- *
- * @see https://data-star.dev/reference/action_plugins/backend/sse
- */
-export type PatchMode = "outer" | "inner" | "replace" | "prepend" | "append" | "before" | "after" | "remove";
-/**
- * SSE stream writer for Datastar events
- */
-export interface SSEStream {
-    /**
-     * Update reactive signals on the client
-     *
-     * @param signals - Object containing signal values to update
-     * @param options - Optional settings (e.g. onlyIfMissing)
-     *
-     * @example
-     * ```ts
-     * await stream.patchSignals({ count: 42, loading: false });
-     * ```
-     */
-    patchSignals(signals: Record<string, unknown>, options?: {
-        onlyIfMissing?: boolean;
-    }): void;
-    /**
-     * Update DOM elements via patching
-     *
-     * @param html - HTML content (must include element with id for targeting)
-     * @param options - Optional patch mode, selector, and view transition
-     *
-     * @example
-     * ```ts
-     * // Outer patch element with matching id (default)
-     * await stream.patchElements('<div id="content">New content</div>');
-     *
-     * // Append to a container
-     * await stream.patchElements('<div>New item</div>', {
-     *   mode: 'append',
-     *   selector: '#list'
-     * });
-     * ```
-     */
-    patchElements(html: string, options?: {
-        mode?: PatchMode;
-        selector?: string;
-        useViewTransition?: boolean;
-    }): void;
-    /**
-     * Redirect the client to a new URL
-     *
-     * Uses patchElements internally to inject a script that navigates the client.
-     *
-     * @param url - The URL to redirect to
-     *
-     * @example
-     * ```ts
-     * await stream.redirect('/dash/posts');
-     * ```
-     */
-    redirect(url: string): void;
-    /**
-     * Remove elements matching a CSS selector
-     *
-     * @param selector - CSS selector for elements to remove
-     *
-     * @example
-     * ```ts
-     * await stream.remove('#placeholder');
-     * ```
-     */
-    remove(selector: string): void;
-    /**
-     * Show a toast notification
-     *
-     * Appends a toast element to `#toast-container` with auto-dismiss after 3s.
-     *
-     * @param message - The message to display
-     * @param type - Toast type: "success" (default) or "error"
-     *
-     * @example
-     * ```ts
-     * await stream.toast("Settings saved successfully.");
-     * await stream.toast("Something went wrong.", "error");
-     * ```
-     */
-    toast(message: string, type?: "success" | "error"): void;
-}
-/**
- * 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 declare function sse(c: Context, handler: (stream: SSEStream) => Promise<void>, options?: {
-    headers?: Record<string, string>;
-}): Response;
-/**
- * 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 (e.g. Set-Cookie for auth)
- * @returns Response with text/html content-type
- *
- * @example
- * ```ts
- * return dsRedirect("/dash/posts");
- *
- * // With cookie forwarding (for auth)
- * return dsRedirect("/dash", { headers: { "Set-Cookie": cookie } });
- * ```
- */
-export declare function dsRedirect(url: string, options?: {
-    headers?: Record<string, string>;
-}): Response;
-/**
- * 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 declare function dsToast(message: string, type?: "success" | "error"): Response;
-/**
- * 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 declare function dsSignals(signals: Record<string, unknown>): Response;
-//# sourceMappingURL=sse.d.ts.map

package/dist/lib/sse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/lib/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;;;GAIG;AACH,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;;OAUG;IACH,YAAY,CACV,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,GACpC,IAAI,CAAC;IAER;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B,GACA,IAAI,CAAC;IAER;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B;;;;;;;;;OASG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/B;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,IAAI,CAAC;CAC1D;AA+CD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,GAAG,CACjB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,EAC7C,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC7C,QAAQ,CAoFV;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC7C,QAAQ,CASV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,SAAS,GAAG,OAAmB,GACpC,QAAQ,CAQV;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAIpE"}

package/dist/lib/theme.d.ts

@@ -1,44 +0,0 @@
-/**
- * Theme Resolution Helpers
- *
- * Resolves the active color theme and builds CSS for injection into `<head>`.
- */
-import type { ColorTheme } from "../theme/color-themes.js";
-import type { JantConfig } from "../types.js";
-/**
- * Get the list of available color themes.
- *
- * Returns `config.theme.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 declare function getAvailableThemes(config: JantConfig): ColorTheme[];
-/**
- * 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({ theme: { 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 declare function buildThemeStyle(theme: ColorTheme | undefined, cssVariables?: Record<string, string>): string;
-//# sourceMappingURL=theme.d.ts.map

package/dist/lib/theme.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../src/lib/theme.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,EAAE,CAEnE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,MAAM,CAkCR"}

package/dist/lib/time.d.ts

@@ -1,90 +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 declare function now(): number;
-/**
- * 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 declare function isWithinMonth(timestamp: number): boolean;
-/**
- * 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 declare function toISOString(timestamp: number): string;
-/**
- * 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 declare function formatDate(timestamp: number): string;
-/**
- * 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"
- * ```
- */
-export declare function formatYearMonth(timestamp: number): string;
-//# sourceMappingURL=time.d.ts.map

package/dist/lib/time.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/lib/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,IAAI,MAAM,CAE5B;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKzD"}

package/dist/lib/url.d.ts

@@ -1,82 +0,0 @@
-/**
- * URL Utilities
- */
-/**
- * Extracts the hostname (domain) from a URL string.
- *
- * Parses a full URL and returns just the hostname portion (e.g., "example.com" from
- * "https://example.com/path"). Returns `null` if the URL is malformed or cannot be parsed.
- *
- * @param url - The full URL string to extract the domain from
- * @returns The hostname/domain if valid, or `null` if parsing fails
- *
- * @example
- * ```ts
- * const domain = extractDomain("https://www.example.com/path");
- * // Returns: "www.example.com"
- *
- * const invalid = extractDomain("not-a-url");
- * // Returns: null
- * ```
- */
-export declare function extractDomain(url: string): string | null;
-/**
- * Normalizes a path by removing slashes and converting to lowercase.
- *
- * Trims whitespace, converts to lowercase, removes leading and trailing slashes,
- * and collapses multiple consecutive slashes into single slashes. Used to create
- * consistent path representations for routing and storage.
- *
- * @param path - The path string to normalize
- * @returns The normalized path string
- *
- * @example
- * ```ts
- * const normalized = normalizePath("  /About/Contact//  ");
- * // Returns: "about/contact"
- * ```
- */
-export declare function normalizePath(path: string): string;
-/**
- * Checks if a string is a full URL with HTTP or HTTPS protocol.
- *
- * Validates whether a string starts with "http://" or "https://", indicating it's
- * a full URL rather than a relative path. Useful for distinguishing between internal
- * paths and external URLs.
- *
- * @param str - The string to check
- * @returns `true` if the string starts with http:// or https://, `false` otherwise
- *
- * @example
- * ```ts
- * isFullUrl("https://example.com");  // Returns: true
- * isFullUrl("/about");               // Returns: false
- * isFullUrl("example.com");          // Returns: false
- * ```
- */
-export declare function isFullUrl(str: string): boolean;
-/**
- * Converts text to a URL-friendly slug.
- *
- * Transforms text into a lowercase, hyphen-separated slug by:
- * - Converting to lowercase
- * - Removing special characters (keeping only word characters, spaces, and hyphens)
- * - Replacing whitespace and underscores with hyphens
- * - Removing leading and trailing hyphens
- *
- * Used for generating clean URLs from titles and names.
- *
- * @param text - The text to convert to a slug
- * @returns The slugified string
- *
- * @example
- * ```ts
- * const slug = slugify("Hello World! This is a Test.");
- * // Returns: "hello-world-this-is-a-test"
- *
- * const slug = slugify("  Multiple   Spaces  ");
- * // Returns: "multiple-spaces"
- * ```
- */
-export declare function slugify(text: string): string;
-//# sourceMappingURL=url.d.ts.map

package/dist/lib/url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/lib/url.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOxD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO5C"}

package/dist/middleware/auth.d.ts

@@ -1,24 +0,0 @@
-/**
- * Authentication Middleware
- *
- * Protects routes by requiring authentication
- */
-import type { MiddlewareHandler } from "hono";
-import type { Bindings } from "../types.js";
-import type { AppVariables } from "../app.js";
-type Env = {
-    Bindings: Bindings;
-    Variables: AppVariables;
-};
-/**
- * Middleware that requires authentication.
- * Redirects to signin page if not authenticated.
- */
-export declare function requireAuth(redirectTo?: string): MiddlewareHandler<Env>;
-/**
- * Middleware for API routes that requires authentication.
- * Returns 401 if not authenticated.
- */
-export declare function requireAuthApi(): MiddlewareHandler<Env>;
-export {};
-//# sourceMappingURL=auth.d.ts.map

package/dist/middleware/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,KAAK,GAAG,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,SAAY,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAoB1E;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAoBvD"}

package/dist/middleware/onboarding.d.ts

@@ -1,26 +0,0 @@
-/**
- * Onboarding Middleware
- *
- * Redirects all requests to /setup if onboarding hasn't been completed.
- * Caches the result in memory so the DB is only queried once per isolate lifetime.
- */
-import type { MiddlewareHandler } from "hono";
-import type { Bindings } from "../types.js";
-import type { AppVariables } from "../app.js";
-type Env = {
-    Bindings: Bindings;
-    Variables: AppVariables;
-};
-/**
- * Middleware that redirects to /setup if onboarding is not complete.
- * Uses module-level caching: once onboarding is confirmed complete,
- * no further DB queries are made for the lifetime of the Worker isolate.
- */
-export declare function requireOnboarding(): MiddlewareHandler<Env>;
-/**
- * Reset the onboarding cache. Only for testing.
- * @internal
- */
-export declare function resetOnboardingCache(): void;
-export {};
-//# sourceMappingURL=onboarding.d.ts.map

package/dist/middleware/onboarding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onboarding.d.ts","sourceRoot":"","sources":["../../src/middleware/onboarding.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,KAAK,GAAG,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC;AAK3D;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAmB1D;AAaD;;;GAGG;AACH,wBAAgB,oBAAoB,SAEnC"}

package/dist/routes/api/posts.d.ts

@@ -1,13 +0,0 @@
-/**
- * Posts API Routes
- */
-import { Hono } from "hono";
-import type { Bindings } from "../../types.js";
-import type { AppVariables } from "../../app.js";
-type Env = {
-    Bindings: Bindings;
-    Variables: AppVariables;
-};
-export declare const postsApiRoutes: Hono<Env, import("hono/types").BlankSchema, "/">;
-export {};
-//# sourceMappingURL=posts.d.ts.map