@jxsuite/site 2.3.1 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/site",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "What a Jx project's page at a route consists of — routing, layout, context, head and the document that boots it",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@jxsuite/runtime": "^6.1.0",
-    "@jxsuite/schema": "^5.2.0"
+    "@jxsuite/runtime": "^6.2.1",
+    "@jxsuite/schema": "^5.4.0"
   }
 }

package/src/compose.ts

@@ -30,8 +30,9 @@ import type { HeadMergeContext } from "./head-merger.ts";
 import { injectContext } from "./context.ts";
 import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 import { localeDirection, localeOfRoute, resolveI18n } from "@jxsuite/schema/locale";
-import { parseJxDocument } from "@jxsuite/schema/parse";
+import { isNativeDocumentPath, parseNativeDocument } from "@jxsuite/schema/jxn";
 import type { JxDocument, JxElement, JxHeadEntry, ProjectConfig } from "@jxsuite/schema/types";
+import { PROJECT_FILE_NAMES, parseProjectSource } from "@jxsuite/schema/project-file";
 
 /** Everything the composer settled about a page before a renderer sees it. */
 export interface ComposedPage {
@@ -88,23 +89,34 @@ async function readDocument(io: SiteIO, path: string): Promise<JxDocument | null
   if (text === null) {
     return null;
   }
-  if (path.endsWith(".json")) {
-    return parseJxDocument(text, path);
+  if (isNativeDocumentPath(path)) {
+    return parseNativeDocument(text, path);
   }
   return io.parse ? ((await io.parse(path, text)) ?? null) : null;
 }
 
-/** The project's configuration, or an empty one when it has none this host can read. */
+/**
+ * The project's configuration, or an empty one when it has none this host can read.
+ *
+ * Both names are read, because a host that can only fetch has no other way to know which one a
+ * project has. A project with both has neither, as it has everywhere else (`site-architecture.md`
+ * §2.3).
+ */
 export async function readProjectConfig(io: SiteIO): Promise<ProjectConfig> {
-  const text = await io.read("project.json");
-  if (text === null) {
+  const texts = await Promise.all(PROJECT_FILE_NAMES.map((name) => io.read(name)));
+  const found = PROJECT_FILE_NAMES.flatMap((name, index) => {
+    const text = texts[index];
+    return text === null || text === undefined ? [] : [{ name, text }];
+  });
+  const [only] = found;
+  if (!only || found.length > 1) {
     return {};
   }
   try {
-    /* SAFETY: only the syntax is checked here, deliberately: every ProjectConfig member is
-       optional, and shape checking is `validateProject`'s job against the per-project schema,
-       which `jx build` runs and a live preview of a half-edited config must not refuse over. */
-    return JSON.parse(text) as ProjectConfig;
+    /* Only the syntax is checked here, deliberately: every ProjectConfig member is optional, and
+       shape checking is `validateProject`'s job against the per-project schema, which `jx build`
+       runs and a live preview of a half-edited config must not refuse over. */
+    return parseProjectSource(only.text, only.name);
   } catch {
     /* A project whose config does not parse still has pages, and refusing to render any of them
        would hide the one error the author can act on behind a blank origin. */
@@ -137,7 +149,7 @@ export function unionElements(
 }
 
 /** A component file in the project's own library, keyed by the tag it defines. */
-const COMPONENT_FILE = /^components\/([^/]+-[^/]*)\.json$/;
+const COMPONENT_FILE = /^components\/([^/]+-[^/]*)\.(?:json|jxn)$/;
 
 /**
  * A `$ref`'s project path, so the same file written from two places is one key.
@@ -188,9 +200,10 @@ function collectTagNames(node: JxElement | string, into: Set<string>): void {
  * for free by scanning HTML it has already rendered; here the definition has to be opened. It is
  * bounded by the components a page actually reaches, and each is opened once.
  *
- * Only `.json` components are discoverable, because a `$ref` is resolved by the browser: the
- * runtime fetches the file and parses it as a document, so a component in a format needing an
- * extension's parser cannot be registered this way whoever discovers it.
+ * Only native components are discoverable, because a `$ref` is resolved by the browser: the runtime
+ * fetches the file and parses it as a document, so a component in a format needing an extension's
+ * parser cannot be registered this way whoever discovers it. A `.jxn` component qualifies because
+ * this origin answers it as JSON (`serve.ts`).
  */
 async function discoverElements(io: SiteIO, doc: JxDocument): Promise<{ $ref: string }[]> {
   const available = new Map<string, string>();
@@ -294,7 +307,7 @@ export async function composePage(
   const pageDoc = await readDocument(io, route.sourcePath);
   if (!pageDoc) {
     throw new ComposeError(
-      `${route.sourcePath} could not be read as a page. Only .json pages render here; other formats need their extension's parser, which this host does not run.`,
+      `${route.sourcePath} could not be read as a page. Only .json and .jxn pages render here; other formats need their extension's parser, which this host does not run.`,
     );
   }
 

package/src/paths.ts

@@ -1,3 +1,4 @@
+import { PROJECT_FILE_NAMES } from "@jxsuite/schema/project-file";
 /**
  * What a site origin serves, and — the part that matters — what it refuses.
  *
@@ -41,7 +42,7 @@ export const SERVABLE_ROOTS: readonly string[] = [
  * them twice is nothing.
  */
 export const NEVER_SERVABLE: ReadonlySet<string> = new Set([
-  "project.json",
+  ...PROJECT_FILE_NAMES,
   "package.json",
   "package-lock.json",
   "bun.lock",

package/src/serve.ts

@@ -13,6 +13,8 @@
  * site legitimately asks for that this package cannot produce.
  */
 
+import { isJxnPath, parseJxn } from "@jxsuite/schema/jxn";
+import { errorMessage } from "@jxsuite/schema/parse";
 import { candidatePaths, contentTypeFor, normalizeRequestPath } from "./paths.ts";
 import { ComposeError, composeRoute, readProjectConfig, routeTable } from "./compose.ts";
 import type { PageRoute, SiteIO } from "./compose.ts";
@@ -104,6 +106,9 @@ export async function serveSite(
   // A file the tree really has, at the path the published site would serve it from.
   for (const candidate of candidatePaths(requestPath)) {
     const bytes = await assets.bytes(candidate);
+    if (bytes && isJxnPath(candidate)) {
+      return jxnAsJson(bytes, candidate);
+    }
     if (bytes) {
       return new Response(bytes, {
         headers: siteHeaders(contentTypeFor(candidate)),
@@ -139,6 +144,34 @@ export async function serveSite(
  * A render that 500s tells the author nothing they can act on. A page naming the file and the
  * reason is the difference between "the preview is broken" and "this page needs a `.json` layout".
  */
+/**
+ * A `.jxn` file, as the JSON a reader expects.
+ *
+ * The runtime fetches a `$ref` and calls `res.json()`, on any origin, so answering JSON here keeps
+ * a KDL parser out of every page. A file that does not read answers 422 with the reason, because
+ * the runtime reports a failed fetch by its status and this one is the author's to fix. The dev
+ * server's canvas origin answers the same way, with its own headers.
+ *
+ * @param bytes The file.
+ * @param path Its path, which names it in an error.
+ * @param headers The headers for a response of a media type.
+ */
+export function jxnAsJson(
+  bytes: Uint8Array<ArrayBuffer>,
+  path: string,
+  headers: (type: string) => HeadersInit = siteHeaders,
+): Response {
+  try {
+    const document = parseJxn(new TextDecoder().decode(bytes), path);
+    return Response.json(document, { headers: headers("application/json;charset=utf-8") });
+  } catch (error) {
+    return new Response(errorMessage(error), {
+      headers: headers("text/plain;charset=utf-8"),
+      status: 422,
+    });
+  }
+}
+
 async function composeSafely(
   io: SiteIO,
   context: SiteContext,