dineway 0.1.3

package/dist/seed/index.d.mts

@@ -0,0 +1,3 @@
+import "../types-DkvMXalq.mjs";
+import { _ as SeedTaxonomyTerm, a as applySeed, b as ValidationResult, c as SeedCollection, d as SeedFile, f as SeedMenu, g as SeedTaxonomy, h as SeedSection, i as defaultSeed, l as SeedContentEntry, m as SeedRedirect, n as loadSeed, o as SeedApplyOptions, p as SeedMenuItem, r as loadUserSeed, s as SeedApplyResult, t as validateSeed, u as SeedField, v as SeedWidget, y as SeedWidgetArea } from "../validate-DVKJJ-M_.mjs";
+export { type SeedApplyOptions, type SeedApplyResult, type SeedCollection, type SeedContentEntry, type SeedField, type SeedFile, type SeedMenu, type SeedMenuItem, type SeedRedirect, type SeedSection, type SeedTaxonomy, type SeedTaxonomyTerm, type SeedWidget, type SeedWidgetArea, type ValidationResult, applySeed, defaultSeed, loadSeed, loadUserSeed, validateSeed };

package/dist/seed/index.mjs

@@ -0,0 +1,15 @@
+import "../dialect-helpers-B9uSp2GJ.mjs";
+import "../content-zSgdNmnt.mjs";
+import "../base64-F8-DUraK.mjs";
+import "../types-BawVha09.mjs";
+import "../media-DMTr80Gv.mjs";
+import { t as applySeed } from "../apply-CAPvMfoU.mjs";
+import "../registry-DSd1GWB8.mjs";
+import "../redirect-JPqLAbxa.mjs";
+import "../byline-DeWCMU_i.mjs";
+import "../loader-qKmo0wAY.mjs";
+import { t as validateSeed } from "../validate-CXnRKfJK.mjs";
+import { t as defaultSeed } from "../default-WYlzADZL.mjs";
+import { n as loadUserSeed, t as loadSeed } from "../load-C6FCD1FU.mjs";
+
+export { applySeed, defaultSeed, loadSeed, loadUserSeed, validateSeed };

package/dist/seo/index.d.mts

@@ -0,0 +1,69 @@
+import { i as ContentSeo } from "../types-CLLdsG3g.mjs";
+
+//#region src/seo/index.d.ts
+/**
+ * Content input for SEO functions.
+ * Accepts both ContentEntry<T> (from query functions) and ContentItem (internal).
+ */
+interface SeoContentInput<T = Record<string, unknown>> {
+  /** Content data object */
+  data: T & {
+    title?: unknown;
+    excerpt?: unknown;
+    seo?: ContentSeo;
+  };
+  /** SEO metadata (legacy location, prefer data.seo) */
+  seo?: ContentSeo;
+}
+/** Resolved SEO meta tags ready for use in templates */
+interface SeoMeta {
+  /** Full <title> tag content (e.g., "Post Title | Site Name") */
+  title: string;
+  /** Meta description */
+  description: string | null;
+  /** OG title (same as title by default) */
+  ogTitle: string;
+  /** OG description */
+  ogDescription: string | null;
+  /** OG image URL (absolute) */
+  ogImage: string | null;
+  /** Canonical URL */
+  canonical: string | null;
+  /** Robots directive (e.g., "noindex, nofollow") or null if default */
+  robots: string | null;
+}
+/** Options for generating SEO meta from a content item */
+interface SeoMetaOptions {
+  /** Site title for the suffix (e.g., "My Blog") */
+  siteTitle?: string;
+  /** Site URL origin for building absolute URLs (e.g., "https://example.com") */
+  siteUrl?: string;
+  /** Title separator between page title and site title */
+  titleSeparator?: string;
+  /** Path to this content (e.g., "/posts/my-post") for canonical fallback */
+  path?: string;
+  /** Default OG image URL if content has none */
+  defaultOgImage?: string;
+}
+/**
+ * Generate resolved SEO meta tags from a content item.
+ *
+ * Uses the content item's SEO fields, falling back to content data
+ * (title from `data.title`, description from `data.excerpt`).
+ *
+ * @param content - The content item (from getDinewayEntry, etc.)
+ * @param options - Configuration for title construction, canonical URLs, etc.
+ * @returns Resolved meta tags ready for template use
+ */
+declare function getSeoMeta<T>(content: SeoContentInput<T>, options?: SeoMetaOptions): SeoMeta;
+/**
+ * Extract SEO data from a content item.
+ *
+ * Convenience accessor for the raw SEO fields without template resolution.
+ *
+ * @param content - The content item
+ * @returns The content's SEO fields
+ */
+declare function getContentSeo<T>(content: SeoContentInput<T>): ContentSeo | undefined;
+//#endregion
+export { SeoContentInput, SeoMeta, SeoMetaOptions, getContentSeo, getSeoMeta };

package/dist/seo/index.mjs

@@ -0,0 +1,69 @@
+//#region src/seo/index.ts
+const TRAILING_SLASH_RE = /\/$/;
+const ABSOLUTE_URL_RE = /^https?:\/\//i;
+/**
+* Generate resolved SEO meta tags from a content item.
+*
+* Uses the content item's SEO fields, falling back to content data
+* (title from `data.title`, description from `data.excerpt`).
+*
+* @param content - The content item (from getDinewayEntry, etc.)
+* @param options - Configuration for title construction, canonical URLs, etc.
+* @returns Resolved meta tags ready for template use
+*/
+function getSeoMeta(content, options = {}) {
+	const { siteTitle, siteUrl, path, defaultOgImage } = options;
+	const separator = options.titleSeparator || " | ";
+	const seo = content.seo ?? content.data.seo ?? {
+		title: null,
+		description: null,
+		image: null,
+		canonical: null,
+		noIndex: false
+	};
+	const pageTitle = seo.title || (typeof content.data.title === "string" ? content.data.title : null) || "";
+	const fullTitle = siteTitle && pageTitle ? `${pageTitle}${separator}${siteTitle}` : pageTitle;
+	const description = seo.description || (typeof content.data.excerpt === "string" ? content.data.excerpt : null) || null;
+	const ogImage = seo.image ? buildMediaUrl(seo.image, siteUrl) : defaultOgImage ?? null;
+	let canonical = null;
+	if (seo.canonical) if (siteUrl && !seo.canonical.startsWith("/") && !ABSOLUTE_URL_RE.test(seo.canonical)) canonical = `${siteUrl.replace(TRAILING_SLASH_RE, "")}/${seo.canonical}`;
+	else canonical = seo.canonical;
+	else if (siteUrl && path) {
+		const safePath = path.startsWith("/") ? path : `/${path}`;
+		canonical = `${siteUrl.replace(TRAILING_SLASH_RE, "")}${safePath}`;
+	}
+	const robots = seo.noIndex ? "noindex, nofollow" : null;
+	return {
+		title: fullTitle,
+		description,
+		ogTitle: pageTitle || fullTitle,
+		ogDescription: description,
+		ogImage,
+		canonical,
+		robots
+	};
+}
+/**
+* Extract SEO data from a content item.
+*
+* Convenience accessor for the raw SEO fields without template resolution.
+*
+* @param content - The content item
+* @returns The content's SEO fields
+*/
+function getContentSeo(content) {
+	return content.seo ?? content.data.seo;
+}
+/**
+* Build a media URL from a media reference ID.
+* If it's already an absolute URL, return as-is.
+*/
+function buildMediaUrl(imageRef, siteUrl) {
+	if (ABSOLUTE_URL_RE.test(imageRef)) return imageRef;
+	const mediaPath = `/_dineway/api/media/file/${imageRef}`;
+	if (siteUrl) return `${siteUrl.replace(TRAILING_SLASH_RE, "")}${mediaPath}`;
+	return mediaPath;
+}
+
+//#endregion
+export { getContentSeo, getSeoMeta };

package/dist/storage/local.d.mts

@@ -0,0 +1,38 @@
+import { a as ListOptions, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, s as LocalStorageConfig, u as SignedUploadUrl } from "../types-ju-_ORz7.mjs";
+
+//#region src/storage/local.d.ts
+/**
+ * Local filesystem storage implementation
+ */
+declare class LocalStorage implements Storage {
+  /** Resolved absolute base directory for all stored files */
+  private directory;
+  private baseUrl;
+  constructor(config: LocalStorageConfig);
+  /**
+   * Resolve a storage key to an absolute file path, ensuring it stays
+   * within the configured storage directory. Uses path.resolve() for
+   * canonical resolution rather than regex stripping.
+   *
+   * @throws DinewayStorageError if the resolved path escapes the base directory
+   */
+  private getFilePath;
+  upload(options: {
+    key: string;
+    body: Buffer | Uint8Array | ReadableStream<Uint8Array>;
+    contentType: string;
+  }): Promise<UploadResult>;
+  download(key: string): Promise<DownloadResult>;
+  delete(key: string): Promise<void>;
+  exists(key: string): Promise<boolean>;
+  list(options?: ListOptions): Promise<ListResult>;
+  getSignedUploadUrl(_options: SignedUploadOptions): Promise<SignedUploadUrl>;
+  getPublicUrl(key: string): string;
+}
+/**
+ * Create local storage adapter
+ * This is the factory function called at runtime
+ */
+declare function createStorage(config: Record<string, unknown>): Storage;
+//#endregion
+export { LocalStorage, createStorage };

package/dist/storage/local.mjs

@@ -0,0 +1,165 @@
+import { t as DinewayStorageError } from "../types-DShnjzb6.mjs";
+import { createReadStream, existsSync } from "node:fs";
+import * as path from "node:path";
+import mime from "mime/lite";
+import * as fs from "node:fs/promises";
+import { Readable } from "node:stream";
+
+//#region src/storage/local.ts
+/**
+* Local Filesystem Storage Implementation
+*
+* For development and testing. Stores files in a local directory.
+*/
+/** Type guard for Node.js ErrnoException */
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+/** Pattern to remove leading slashes */
+const LEADING_SLASH_PATTERN = /^\//;
+/** Pattern to remove trailing slashes */
+const TRAILING_SLASH_PATTERN = /\/$/;
+/**
+* Local filesystem storage implementation
+*/
+var LocalStorage = class {
+	/** Resolved absolute base directory for all stored files */
+	directory;
+	baseUrl;
+	constructor(config) {
+		this.directory = path.resolve(config.directory);
+		this.baseUrl = config.baseUrl.replace(TRAILING_SLASH_PATTERN, "");
+	}
+	/**
+	* Resolve a storage key to an absolute file path, ensuring it stays
+	* within the configured storage directory. Uses path.resolve() for
+	* canonical resolution rather than regex stripping.
+	*
+	* @throws DinewayStorageError if the resolved path escapes the base directory
+	*/
+	getFilePath(key) {
+		const normalizedKey = key.replace(LEADING_SLASH_PATTERN, "");
+		const resolved = path.resolve(this.directory, normalizedKey);
+		if (!resolved.startsWith(this.directory + path.sep) && resolved !== this.directory) throw new DinewayStorageError("Invalid file path", "INVALID_PATH");
+		return resolved;
+	}
+	async upload(options) {
+		try {
+			const filePath = this.getFilePath(options.key);
+			const dir = path.dirname(filePath);
+			await fs.mkdir(dir, { recursive: true });
+			let buffer;
+			if (options.body instanceof ReadableStream) {
+				const chunks = [];
+				const reader = options.body.getReader();
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					chunks.push(value);
+				}
+				buffer = Buffer.concat(chunks);
+			} else if (options.body instanceof Uint8Array) buffer = Buffer.from(options.body);
+			else buffer = options.body;
+			await fs.writeFile(filePath, buffer);
+			return {
+				key: options.key,
+				url: this.getPublicUrl(options.key),
+				size: buffer.length
+			};
+		} catch (error) {
+			throw new DinewayStorageError(`Failed to upload file: ${options.key}`, "UPLOAD_FAILED", error);
+		}
+	}
+	async download(key) {
+		try {
+			const filePath = this.getFilePath(key);
+			if (!existsSync(filePath)) throw new DinewayStorageError(`File not found: ${key}`, "NOT_FOUND");
+			const stat = await fs.stat(filePath);
+			const nodeStream = createReadStream(filePath);
+			return {
+				body: Readable.toWeb(nodeStream),
+				contentType: getContentType(path.extname(key).toLowerCase()),
+				size: stat.size
+			};
+		} catch (error) {
+			if (error instanceof DinewayStorageError) throw error;
+			throw new DinewayStorageError(`Failed to download file: ${key}`, "DOWNLOAD_FAILED", error);
+		}
+	}
+	async delete(key) {
+		try {
+			const filePath = this.getFilePath(key);
+			await fs.unlink(filePath);
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "ENOENT") throw new DinewayStorageError(`Failed to delete file: ${key}`, "DELETE_FAILED", error);
+		}
+	}
+	async exists(key) {
+		try {
+			const filePath = this.getFilePath(key);
+			await fs.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async list(options = {}) {
+		try {
+			const prefix = options.prefix || "";
+			const searchDir = path.resolve(this.directory, path.dirname(prefix));
+			if (!searchDir.startsWith(this.directory + path.sep) && searchDir !== this.directory) throw new DinewayStorageError("Invalid list prefix", "INVALID_PATH");
+			const prefixBase = path.basename(prefix);
+			try {
+				await fs.access(searchDir);
+			} catch {
+				return { files: [] };
+			}
+			const entries = await fs.readdir(searchDir, { withFileTypes: true });
+			const files = [];
+			for (const entry of entries) if (entry.isFile() && entry.name.startsWith(prefixBase)) {
+				const key = path.join(path.dirname(prefix), entry.name);
+				const filePath = path.join(searchDir, entry.name);
+				const stat = await fs.stat(filePath);
+				files.push({
+					key,
+					size: stat.size,
+					lastModified: stat.mtime
+				});
+			}
+			files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+			const startIndex = options.cursor ? parseInt(options.cursor, 10) : 0;
+			const limit = options.limit || 1e3;
+			return {
+				files: files.slice(startIndex, startIndex + limit),
+				nextCursor: startIndex + limit < files.length ? String(startIndex + limit) : void 0
+			};
+		} catch (error) {
+			throw new DinewayStorageError("Failed to list files", "LIST_FAILED", error);
+		}
+	}
+	async getSignedUploadUrl(_options) {
+		throw new DinewayStorageError("Local storage does not support signed upload URLs. Upload files directly through the API.", "NOT_SUPPORTED");
+	}
+	getPublicUrl(key) {
+		return `${this.baseUrl}/${key}`;
+	}
+};
+/**
+* Get content type from file extension
+*/
+function getContentType(ext) {
+	return mime.getType(ext) ?? "application/octet-stream";
+}
+/**
+* Create local storage adapter
+* This is the factory function called at runtime
+*/
+function createStorage(config) {
+	return new LocalStorage({
+		directory: typeof config.directory === "string" ? config.directory : "",
+		baseUrl: typeof config.baseUrl === "string" ? config.baseUrl : ""
+	});
+}
+
+//#endregion
+export { LocalStorage, createStorage };

package/dist/storage/s3.d.mts

@@ -0,0 +1,31 @@
+import { a as ListOptions, c as S3StorageConfig, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, u as SignedUploadUrl } from "../types-ju-_ORz7.mjs";
+
+//#region src/storage/s3.d.ts
+/**
+ * S3-compatible storage implementation
+ */
+declare class S3Storage implements Storage {
+  private client;
+  private bucket;
+  private publicUrl?;
+  private endpoint;
+  constructor(config: S3StorageConfig);
+  upload(options: {
+    key: string;
+    body: Buffer | Uint8Array | ReadableStream<Uint8Array>;
+    contentType: string;
+  }): Promise<UploadResult>;
+  download(key: string): Promise<DownloadResult>;
+  delete(key: string): Promise<void>;
+  exists(key: string): Promise<boolean>;
+  list(options?: ListOptions): Promise<ListResult>;
+  getSignedUploadUrl(options: SignedUploadOptions): Promise<SignedUploadUrl>;
+  getPublicUrl(key: string): string;
+}
+/**
+ * Create S3 storage adapter
+ * This is the factory function called at runtime
+ */
+declare function createStorage(config: Record<string, unknown>): Storage;
+//#endregion
+export { S3Storage, createStorage };

package/dist/storage/s3.mjs

@@ -0,0 +1,174 @@
+import { t as DinewayStorageError } from "../types-DShnjzb6.mjs";
+import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+//#region src/storage/s3.ts
+/**
+* S3-Compatible Storage Implementation
+*
+* Uses the AWS SDK v3 for S3 operations.
+* Works with AWS S3, Cloudflare R2, Minio, and other S3-compatible services.
+*/
+const TRAILING_SLASH_PATTERN = /\/$/;
+/** Type guard for AWS SDK errors (have a `name` property) */
+function hasErrorName(error) {
+	return error instanceof Error && typeof error.name === "string";
+}
+/**
+* S3-compatible storage implementation
+*/
+var S3Storage = class {
+	client;
+	bucket;
+	publicUrl;
+	endpoint;
+	constructor(config) {
+		this.bucket = config.bucket;
+		this.publicUrl = config.publicUrl;
+		this.endpoint = config.endpoint;
+		this.client = new S3Client({
+			endpoint: config.endpoint,
+			region: config.region || "auto",
+			credentials: {
+				accessKeyId: config.accessKeyId,
+				secretAccessKey: config.secretAccessKey
+			},
+			forcePathStyle: true
+		});
+	}
+	async upload(options) {
+		try {
+			let body;
+			if (options.body instanceof ReadableStream) {
+				const chunks = [];
+				const reader = options.body.getReader();
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					chunks.push(value);
+				}
+				body = Buffer.concat(chunks);
+			} else body = options.body;
+			await this.client.send(new PutObjectCommand({
+				Bucket: this.bucket,
+				Key: options.key,
+				Body: body,
+				ContentType: options.contentType
+			}));
+			return {
+				key: options.key,
+				url: this.getPublicUrl(options.key),
+				size: body.length
+			};
+		} catch (error) {
+			throw new DinewayStorageError(`Failed to upload file: ${options.key}`, "UPLOAD_FAILED", error);
+		}
+	}
+	async download(key) {
+		try {
+			const response = await this.client.send(new GetObjectCommand({
+				Bucket: this.bucket,
+				Key: key
+			}));
+			if (!response.Body) throw new DinewayStorageError(`File not found: ${key}`, "NOT_FOUND");
+			return {
+				body: response.Body.transformToWebStream(),
+				contentType: response.ContentType || "application/octet-stream",
+				size: response.ContentLength || 0
+			};
+		} catch (error) {
+			if (error instanceof DinewayStorageError || hasErrorName(error) && error.name === "NoSuchKey") throw new DinewayStorageError(`File not found: ${key}`, "NOT_FOUND", error);
+			throw new DinewayStorageError(`Failed to download file: ${key}`, "DOWNLOAD_FAILED", error);
+		}
+	}
+	async delete(key) {
+		try {
+			await this.client.send(new DeleteObjectCommand({
+				Bucket: this.bucket,
+				Key: key
+			}));
+		} catch (error) {
+			if (!hasErrorName(error) || error.name !== "NoSuchKey") throw new DinewayStorageError(`Failed to delete file: ${key}`, "DELETE_FAILED", error);
+		}
+	}
+	async exists(key) {
+		try {
+			await this.client.send(new HeadObjectCommand({
+				Bucket: this.bucket,
+				Key: key
+			}));
+			return true;
+		} catch (error) {
+			if (hasErrorName(error) && error.name === "NotFound") return false;
+			throw new DinewayStorageError(`Failed to check file existence: ${key}`, "HEAD_FAILED", error);
+		}
+	}
+	async list(options = {}) {
+		try {
+			const response = await this.client.send(new ListObjectsV2Command({
+				Bucket: this.bucket,
+				Prefix: options.prefix,
+				MaxKeys: options.limit,
+				ContinuationToken: options.cursor
+			}));
+			return {
+				files: (response.Contents || []).map((item) => ({
+					key: item.Key,
+					size: item.Size || 0,
+					lastModified: item.LastModified || /* @__PURE__ */ new Date(),
+					etag: item.ETag
+				})),
+				nextCursor: response.NextContinuationToken
+			};
+		} catch (error) {
+			throw new DinewayStorageError("Failed to list files", "LIST_FAILED", error);
+		}
+	}
+	async getSignedUploadUrl(options) {
+		try {
+			const expiresIn = options.expiresIn || 3600;
+			const command = new PutObjectCommand({
+				Bucket: this.bucket,
+				Key: options.key,
+				ContentType: options.contentType,
+				ContentLength: options.size
+			});
+			const url = await getSignedUrl(this.client, command, { expiresIn });
+			const expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
+			return {
+				url,
+				method: "PUT",
+				headers: {
+					"Content-Type": options.contentType,
+					...options.size ? { "Content-Length": String(options.size) } : {}
+				},
+				expiresAt
+			};
+		} catch (error) {
+			throw new DinewayStorageError(`Failed to generate signed URL for: ${options.key}`, "SIGNED_URL_FAILED", error);
+		}
+	}
+	getPublicUrl(key) {
+		if (this.publicUrl) return `${this.publicUrl.replace(TRAILING_SLASH_PATTERN, "")}/${key}`;
+		return `${this.endpoint.replace(TRAILING_SLASH_PATTERN, "")}/${this.bucket}/${key}`;
+	}
+};
+/**
+* Create S3 storage adapter
+* This is the factory function called at runtime
+*/
+function createStorage(config) {
+	const { endpoint, bucket, accessKeyId, secretAccessKey, region, publicUrl } = config;
+	if (typeof endpoint !== "string" || typeof bucket !== "string" || typeof accessKeyId !== "string" || typeof secretAccessKey !== "string") throw new Error("S3Storage requires 'endpoint', 'bucket', 'accessKeyId', and 'secretAccessKey' string config values");
+	return new S3Storage({
+		endpoint,
+		bucket,
+		accessKeyId,
+		secretAccessKey,
+		region: typeof region === "string" ? region : void 0,
+		publicUrl: typeof publicUrl === "string" ? publicUrl : void 0
+	});
+}
+
+//#endregion
+export { S3Storage, createStorage };