emdash 0.21.0 → 0.22.0

package/dist/astro/index.mjs

@@ -1,7 +1,7 @@
-import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-DKsg36ty.mjs";
-import { t as defaultSeed } from "../default-NHGuJzQ3.mjs";
-import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-BqC8cul8.mjs";
-import { n as VERSION, t as COMMIT } from "../version-BOjj_cfz.mjs";
+import { t as INTERNAL_MEDIA_PREFIX } from "../normalize-Uam4_Vkr.mjs";
+import { t as defaultSeed } from "../default-CpBEPn6a.mjs";
+import { n as validateAllowedOrigins, r as validateOriginShape } from "../allowed-origins-DjlhyfNN.mjs";
+import { n as VERSION, t as COMMIT } from "../version-RnYXYjzD.mjs";
 import { createRequire } from "node:module";
 import { fontProviders } from "astro/config";
 import { existsSync, readFileSync } from "node:fs";
@@ -66,6 +66,28 @@ function local(config) {
 	};
 }
 
+//#endregion
+//#region src/astro/object-cache/adapters.ts
+/**
+* In-isolate memory object cache.
+*
+* Caches query results across requests within a single isolate/process. On
+* Node (one long-lived process) this is a genuine cross-request cache; on
+* multi-isolate platforms (Cloudflare) prefer `kvCache()` so the cache is
+* shared. Useful for local development regardless of target.
+*
+* @example
+* ```ts
+* emdash({ objectCache: memoryCache({ defaultTtl: 600 }) })
+* ```
+*/
+function memoryCache(options = {}) {
+	return {
+		entrypoint: "emdash/object-cache/memory",
+		config: { ...options }
+	};
+}
+
 //#endregion
 //#region src/astro/integration/font-provider.ts
 /**
@@ -762,6 +784,10 @@ function injectCoreRoutes(injectRoute, options = {}) {
 		pattern: "/_emdash/api/comments/[collection]/[contentId]",
 		entrypoint: resolveRoute("api/comments/[collection]/[contentId]/index.ts")
 	});
+	injectRoute({
+		pattern: "/_emdash/api/comments/[collection]/[contentId]/reactions",
+		entrypoint: resolveRoute("api/comments/[collection]/[contentId]/reactions.ts")
+	});
 	injectRoute({
 		pattern: "/_emdash/api/admin/comments",
 		entrypoint: resolveRoute("api/admin/comments/index.ts")
@@ -960,6 +986,8 @@ const VIRTUAL_DIALECT_ID = "virtual:emdash/dialect";
 const RESOLVED_VIRTUAL_DIALECT_ID = "\0" + VIRTUAL_DIALECT_ID;
 const VIRTUAL_STORAGE_ID = "virtual:emdash/storage";
 const RESOLVED_VIRTUAL_STORAGE_ID = "\0" + VIRTUAL_STORAGE_ID;
+const VIRTUAL_OBJECT_CACHE_ID = "virtual:emdash/object-cache";
+const RESOLVED_VIRTUAL_OBJECT_CACHE_ID = "\0" + VIRTUAL_OBJECT_CACHE_ID;
 const VIRTUAL_ADMIN_REGISTRY_ID = "virtual:emdash/admin-registry";
 const RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID = "\0" + VIRTUAL_ADMIN_REGISTRY_ID;
 const VIRTUAL_PLUGINS_ID = "virtual:emdash/plugins";
@@ -1030,6 +1058,22 @@ export const createStorage = _createStorage;
 `;
 }
 /**
+* Generates the object-cache virtual module.
+*
+* Statically imports the configured object-cache backend's `createObjectCache`
+* factory and embeds its serializable config. When no object cache is
+* configured, exports `undefined` so the runtime read-through layer becomes a
+* transparent passthrough (cache off by default).
+*/
+function generateObjectCacheModule(entrypoint, config) {
+	if (!entrypoint) return [`export const createObjectCache = undefined;`, `export const objectCacheConfig = undefined;`].join("\n");
+	return `
+import { createObjectCache as _createObjectCache } from "${entrypoint}";
+export const createObjectCache = _createObjectCache;
+export const objectCacheConfig = ${JSON.stringify(config ?? {})};
+`;
+}
+/**
 * Generates the auth virtual module.
 * Statically imports the configured auth provider.
 */
@@ -1100,7 +1144,9 @@ function generatePluginsModule(descriptors) {
 				allowedHosts: descriptor.allowedHosts,
 				storage: descriptor.storage,
 				adminPages: descriptor.adminPages,
-				adminWidgets: descriptor.adminWidgets
+				adminWidgets: descriptor.adminWidgets,
+				portableTextBlocks: descriptor.portableTextBlocks,
+				fieldWidgets: descriptor.fieldWidgets
 			})})`);
 		} else {
 			const varName = `createPlugin${index}`;
@@ -1350,6 +1396,8 @@ export const sandboxedPlugins = [];
     storage: ${JSON.stringify(descriptor.storage ?? {})},
     adminPages: ${JSON.stringify(descriptor.adminPages ?? [])},
     adminWidgets: ${JSON.stringify(descriptor.adminWidgets ?? [])},
+    portableTextBlocks: ${JSON.stringify(descriptor.portableTextBlocks ?? [])},
+    fieldWidgets: ${JSON.stringify(descriptor.fieldWidgets ?? [])},
     adminEntry: ${JSON.stringify(descriptor.adminEntry)},
     // Code read from: ${filePath}
     code: ${JSON.stringify(code)},
@@ -1453,6 +1501,7 @@ function createVirtualModulesPlugin(options) {
 			if (id === VIRTUAL_CONFIG_ID) return RESOLVED_VIRTUAL_CONFIG_ID;
 			if (id === VIRTUAL_DIALECT_ID) return RESOLVED_VIRTUAL_DIALECT_ID;
 			if (id === VIRTUAL_STORAGE_ID) return RESOLVED_VIRTUAL_STORAGE_ID;
+			if (id === VIRTUAL_OBJECT_CACHE_ID) return RESOLVED_VIRTUAL_OBJECT_CACHE_ID;
 			if (id === VIRTUAL_ADMIN_REGISTRY_ID) return RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID;
 			if (id === VIRTUAL_PLUGINS_ID) return RESOLVED_VIRTUAL_PLUGINS_ID;
 			if (id === VIRTUAL_SANDBOX_RUNNER_ID) return RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID;
@@ -1473,6 +1522,7 @@ function createVirtualModulesPlugin(options) {
 				supportsRequestScope: resolvedConfig.database?.supportsRequestScope ?? false
 			});
 			if (id === RESOLVED_VIRTUAL_STORAGE_ID) return generateStorageModule(resolvedConfig.storage?.entrypoint);
+			if (id === RESOLVED_VIRTUAL_OBJECT_CACHE_ID) return generateObjectCacheModule(resolvedConfig.objectCache?.entrypoint, resolvedConfig.objectCache?.config);
 			if (id === RESOLVED_VIRTUAL_PLUGINS_ID) return generatePluginsModule(pluginDescriptors);
 			if (id === RESOLVED_VIRTUAL_ADMIN_REGISTRY_ID) return generateAdminRegistryModule([...pluginDescriptors, ...resolvedConfig.sandboxed ?? []]);
 			if (id === RESOLVED_VIRTUAL_SANDBOX_RUNNER_ID) return generateSandboxRunnerModule(resolvedConfig.sandboxRunner, resolvedConfig.sandbox);
@@ -1597,6 +1647,7 @@ function createViteConfig(options, command) {
 					"react-dom/server",
 					"astro > zod/v4",
 					"astro > zod/v4/core",
+					"emdash > zod",
 					"@emdash-cms/cloudflare > kysely-d1",
 					"astro/virtual-modules/middleware.js",
 					"astro/virtual-modules/live-config",
@@ -1666,26 +1717,21 @@ const DEFAULT_STORAGE = local({
 /**
 * Build `image.remotePatterns` entries so Astro will optimize EmDash media.
 *
-* Astro's image services only transform **absolute** URLs whose host is
-* authorized; everything else is passed through unoptimized. We authorize the
-* media sources automatically:
+* Astro's image services only build a transform URL for sources allowed via
+* `image.domains` / `image.remotePatterns` (relative URLs are never optimized —
+* see `isRemoteAllowed`). We authorize the media sources automatically:
 *
-*  1. The storage adapter's public URL host (R2 custom domain, S3/CDN), so
-*     media served directly from a public bucket is optimized.
+*  1. The storage adapter's public URL host (R2 custom domain, S3/CDN).
 *  2. The site's own origin, scoped to the media proxy route
-*     (`/_emdash/api/media/file/**`), so same-origin proxied media (local
-*     storage, or R2 without a public URL) is optimized too. The pathname
-*     scope keeps Astro's image endpoint from acting as an open proxy for the
-*     whole origin. Only registered when `siteUrl` is known at build time;
-*     `getPublicOrigin` resolves the matching origin at render time.
-*  3. In `astro dev` the dev-server origin (`localhost:<port>`) isn't known at
-*     build time, so we register a host-agnostic pattern scoped to the media
-*     route. This is dev-only — it never ships in a production build — so the
-*     missing host check can't be abused on a deployed site.
+*     (`/_emdash/api/media/file/**`), so same-origin proxied media is optimized.
+*     The components absolutize the media URL against this origin; EmDash's
+*     wrapped image endpoint then serves the bytes from storage (so the absolute
+*     URL is never fetched). Only registered when `siteUrl` is known at build.
+*  3. In `astro dev` the dev-server origin isn't known at build time, so we
+*     register a host-agnostic pattern scoped to the media route. Dev-only.
 *
-* Returns an empty array when no source is statically known (e.g. a production
-* build using local storage with no `siteUrl`), in which case media renders as
-* a plain `<img>`.
+* Returns an empty array when no source is statically known (production build,
+* local storage, no `siteUrl`), in which case media renders as a plain `<img>`.
 *
 * @internal Exported for unit testing.
 */
@@ -1714,6 +1760,41 @@ function buildImageRemotePatterns(storage, siteUrl, command) {
 	if (command === "dev") patterns.push({ pathname: `${INTERNAL_MEDIA_PREFIX}**` });
 	return patterns;
 }
+/**
+* Stock image endpoints EmDash may safely replace with its storage-backed
+* wrapper. Our wrapper delegates non-EmDash images to the platform's transform
+* endpoint, so we only override endpoints whose transform we can delegate to.
+*/
+const OVERRIDABLE_IMAGE_ENDPOINTS = new Set([
+	"astro/assets/endpoint/generic",
+	"astro/assets/endpoint/node",
+	"astro/assets/endpoint/dev",
+	"@astrojs/cloudflare/image-transform-endpoint"
+]);
+/**
+* Stock endpoints that deliberately don't transform (the user opted into
+* passthrough). We leave these untouched -- and without a warning, since it's a
+* supported choice, not a custom endpoint. Overriding would route non-EmDash
+* images through a transformer the passthrough setup doesn't provide.
+*/
+const PASSTHROUGH_IMAGE_ENDPOINTS = new Set(["@astrojs/cloudflare/image-passthrough-endpoint"]);
+/**
+* Decide which image endpoint to install (if any). EmDash wraps Astro's image
+* endpoint so EmDash media bytes load from storage; the wrapper delegates other
+* images back to the platform's stock endpoint.
+*
+* Returns `{ entrypoint }` to install, `{ warn }` to skip with a warning (a
+* custom endpoint we can't delegate to), or `{}` to skip silently (opted out).
+*
+* @internal Exported for unit testing.
+*/
+function resolveImageEndpoint(opts) {
+	if (opts.imagesDisabled) return {};
+	const current = opts.currentEntrypoint;
+	if (current === void 0 || OVERRIDABLE_IMAGE_ENDPOINTS.has(current)) return { entrypoint: opts.isCloudflare ? "@emdash-cms/cloudflare/image-endpoint" : "emdash/image-endpoint" };
+	if (PASSTHROUGH_IMAGE_ENDPOINTS.has(current)) return {};
+	return { warn: `A custom image.endpoint (${current}) is configured; EmDash will not wrap it, so storage-backed media may render unoptimized.` };
+}
 const dim = (s) => `\x1b[2m${s}\x1b[22m`;
 const bold = (s) => `\x1b[1m${s}\x1b[22m`;
 const cyan = (s) => `\x1b[36m${s}\x1b[39m`;
@@ -1842,9 +1923,18 @@ function emdash(config = {}) {
 					]
 				}];
 				const imageRemotePatterns = buildImageRemotePatterns(resolvedConfig.storage, resolvedConfig.siteUrl, command);
+				const { entrypoint: imageEndpoint, warn: imageEndpointWarning } = resolveImageEndpoint({
+					imagesDisabled: resolvedConfig.images === false,
+					currentEntrypoint: astroConfig.image?.endpoint?.entrypoint,
+					isCloudflare: astroConfig.adapter?.name === "@astrojs/cloudflare"
+				});
+				if (imageEndpointWarning) logger.warn(imageEndpointWarning);
+				const imageConfig = {};
+				if (imageRemotePatterns.length) imageConfig.remotePatterns = imageRemotePatterns;
+				if (imageEndpoint) imageConfig.endpoint = { entrypoint: imageEndpoint };
 				updateConfig({
 					security: securityConfig,
-					...imageRemotePatterns.length ? { image: { remotePatterns: imageRemotePatterns } } : {},
+					...Object.keys(imageConfig).length ? { image: imageConfig } : {},
 					fonts: emdashFonts,
 					vite: createViteConfig({
 						serializableConfig,
@@ -1933,5 +2023,5 @@ function emdash(config = {}) {
 }
 
 //#endregion
-export { emdash as default, getStoredConfig, local, s3 };
+export { emdash as default, getStoredConfig, local, memoryCache, s3 };
 //# sourceMappingURL=index.mjs.map