@seamlet/astro 0.5.1 → 0.6.0

package/README.md

@@ -125,6 +125,22 @@ A photo may carry the point that must stay in view when the site crops it, chose
 />
 ```
 
+A photo may also be one of the site's own files, named by an address of the site (`/menu/01.jpg`) that the site turns into its image when it renders. Give `defineSeamletSite` a `photos` function that finds that image, and the CMS's editor shows the photo in its field too:
+
+```ts
+const MENU_FILES = import.meta.glob<{ default: ImageMetadata }>(
+  "./assets/menu/*.jpg",
+  { eager: true },
+);
+
+export default defineSeamletSite({
+  id: "zerno",
+  schema,
+  pages: { "/": HomePage },
+  photos: (src) => MENU_FILES[src.replace("/menu/", "./assets/menu/")]?.default,
+});
+```
+
 ## Presets
 
 Sets of fields almost every site has, edited the same way everywhere; they are plain groups and collections, rendered as the site likes:
@@ -178,6 +194,7 @@ What was opened stays open while the page is rendered anew after every edit.
 
 - `/preview` and `/preview/<page>`: the preview the CMS's editor frames. `GET` shows the published content; `POST` with the content as JSON shows that content without saving it, which is how the editor shows every edit at once. Only the CMS may frame it (`Content-Security-Policy: frame-ancestors`), and it is never indexed or cached.
 - The bridge on the preview: it tells the editor where the marked elements are and what a person does on the page, and types texts in place.
+- `/seamlet-photos/<address>`: the site's own photo at an address its content gives it, found by `photos` of `defineSeamletSite`, for the CMS's editor.
 - `/media/<site>/<file>`: the photos uploaded in the CMS, taken from it on request; a static build copies every uploaded photo its built pages refer to next to them, so a static host serves them too.
 
 A site never renders content as raw HTML (`set:html`): the editor acts on what its preview says.

package/dist/chunk-3BS5CE26.js

@@ -0,0 +1,20 @@
+// src/own-photos.ts
+var OWN_PHOTOS_PATH = "/seamlet-photos";
+var UPLOADS_PATH = "/media/";
+var PARENT_SEGMENT = "..";
+function isOwnPhotoSrc(src) {
+  const isOnSite = src.startsWith("/") && !src.startsWith("//");
+  const isUpload = src.startsWith(UPLOADS_PATH);
+  const isPlainPath = !/[?#\\]/u.test(src);
+  const climbsUp = src.split("/").includes(PARENT_SEGMENT);
+  return isOnSite && !isUpload && isPlainPath && !climbsUp;
+}
+function ownPhotoPath(src) {
+  return isOwnPhotoSrc(src) ? `${OWN_PHOTOS_PATH}${src}` : void 0;
+}
+
+export {
+  OWN_PHOTOS_PATH,
+  isOwnPhotoSrc,
+  ownPhotoPath
+};

package/dist/index.js

@@ -1,3 +1,6 @@
+import {
+  OWN_PHOTOS_PATH
+} from "./chunk-3BS5CE26.js";
 import {
   isUploadedPhoto
 } from "./chunk-P2OQOZBC.js";
@@ -89,6 +92,11 @@ function seamlet(options) {
           entrypoint: "@seamlet/astro/routes/media",
           prerender: false
         });
+        injectRoute({
+          pattern: `${OWN_PHOTOS_PATH}/[...path]`,
+          entrypoint: "@seamlet/astro/routes/own-photos",
+          prerender: false
+        });
       },
       // A static host has no route to take the uploaded photos from the CMS on request: the photos
       // the built pages refer to are copied next to them. Pages rendered on request take them

package/dist/protocol.d.ts

@@ -16,4 +16,11 @@ declare function imageFieldAt(schema: Fields, path: string | undefined): {
  */
 declare function closestMarkedPath(path: FieldPath, isMarked: (path: string) => boolean): string | undefined;
 
-export { carriesFiles, closestMarkedPath, imageFieldAt };
+/** Where a site hands out its own photos: `/seamlet-photos/menu/cafe/01.jpg`. */
+declare const OWN_PHOTOS_PATH = "/seamlet-photos";
+/** An address of the site itself that is not an upload, and that cannot climb out of the site. */
+declare function isOwnPhotoSrc(src: string): boolean;
+/** Where the site hands out its own photo; undefined for an upload or another site's address. */
+declare function ownPhotoPath(src: string): string | undefined;
+
+export { OWN_PHOTOS_PATH, carriesFiles, closestMarkedPath, imageFieldAt, isOwnPhotoSrc, ownPhotoPath };

package/dist/protocol.js

@@ -1,3 +1,8 @@
+import {
+  OWN_PHOTOS_PATH,
+  isOwnPhotoSrc,
+  ownPhotoPath
+} from "./chunk-3BS5CE26.js";
 import {
   PROTOCOL_VERSION,
   carriesFiles,
@@ -9,10 +14,13 @@ import {
 } from "./chunk-XCBYYKWR.js";
 import "./chunk-GLXC5OLC.js";
 export {
+  OWN_PHOTOS_PATH,
   PROTOCOL_VERSION,
   carriesFiles,
   closestMarkedPath,
   imageFieldAt,
+  isOwnPhotoSrc,
+  ownPhotoPath,
   readEditorMessage,
   readPageMessage,
   shortcutOf

package/dist/routes/own-photos.d.ts

@@ -0,0 +1,5 @@
+import { APIRoute } from 'astro';
+
+declare const GET: APIRoute;
+
+export { GET };

package/dist/routes/own-photos.js

@@ -0,0 +1,19 @@
+import {
+  isOwnPhotoSrc
+} from "../chunk-3BS5CE26.js";
+
+// src/routes/own-photos.ts
+import site from "virtual:seamlet/site";
+var NOT_FOUND = 404;
+var FOUND = 302;
+var GET = ({ params, redirect }) => {
+  const src = `/${params["path"] ?? ""}`;
+  const photo = isOwnPhotoSrc(src) ? site.ownPhotoAt(src) : void 0;
+  if (photo === void 0) {
+    return new Response(null, { status: NOT_FOUND });
+  }
+  return redirect(photo.src, FOUND);
+};
+export {
+  GET
+};

package/dist/site.d.ts

@@ -1,3 +1,4 @@
+import { ImageMetadata } from 'astro';
 import { AstroComponentFactory } from 'astro/runtime/server/index.js';
 import { F as Fields, C as ContentOf } from './content-C_WpiWBm.js';
 
@@ -10,6 +11,11 @@ interface SeamletSiteDefinition<F extends Fields> {
      * as their `content` prop. The CMS lists the same addresses for its editor.
      */
     readonly pages: Readonly<Record<string, AstroComponentFactory>>;
+    /**
+     * The site's own photo at the address its content gives it (`/menu/cafe/01.jpg`), so the CMS's
+     * editor can show it in the photo's field. A site without own photos leaves it out.
+     */
+    readonly photos?: (src: string) => ImageMetadata | undefined;
 }
 interface SeamletSite<F extends Fields = Fields> {
     readonly id: string;
@@ -18,6 +24,8 @@ interface SeamletSite<F extends Fields = Fields> {
     readonly pageAt: (rest: string | undefined) => AstroComponentFactory | undefined;
     /** What the CMS published: the site's initial content until the first publication. */
     readonly loadPublishedContent: () => Promise<ContentOf<F>>;
+    /** The site's own photo at an address its content gives it, if it has one there. */
+    readonly ownPhotoAt: (src: string) => ImageMetadata | undefined;
 }
 /** Describes the site for the integration: `src/seamlet.ts` exports it as its default. */
 declare function defineSeamletSite<F extends Fields>(definition: SeamletSiteDefinition<F>): SeamletSite<F>;

package/dist/site.js

@@ -14,7 +14,8 @@ function defineSeamletSite(definition) {
     loadPublishedContent: async () => {
       const published = await fetchPublished(definition.id);
       return parseContent(definition.schema, published).content;
-    }
+    },
+    ownPhotoAt: (src) => definition.photos?.(src)
   };
 }
 async function fetchPublished(siteId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamlet/astro",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Connects an Astro site to the Seamlet CMS: the schema of its content, the preview the editor frames, and its published content.",
   "license": "MIT",
   "type": "module",
@@ -42,6 +42,10 @@
     "./routes/media": {
       "types": "./dist/routes/media.d.ts",
       "default": "./dist/routes/media.js"
+    },
+    "./routes/own-photos": {
+      "types": "./dist/routes/own-photos.d.ts",
+      "default": "./dist/routes/own-photos.js"
     }
   },
   "files": [