@jxsuite/compiler 0.28.0 → 0.28.3

package/src/site/site-loader.ts

@@ -5,51 +5,68 @@
  * defaults for all project-level properties.
  */
 
-import { readFileSync, existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import type { ImageConfig, ProjectConfig } from "@jxsuite/schema/types";
+import { errorMessage, parseProjectConfig } from "@jxsuite/schema/parse";
 import { resolve } from "node:path";
 
 /**
  * Default project configuration. All properties are optional in project.json; these defaults fill
  * in anything the author omits.
  */
+/** A project config after merging with DEFAULTS — the option groups are always present. */
+export interface ResolvedProjectConfig extends ProjectConfig {
+  name: string;
+  url: string;
+  defaults: NonNullable<ProjectConfig["defaults"]>;
+  images: ImageConfig & { service: "build" | "cloudflare" };
+  build: {
+    adapter?: string;
+    outDir: string;
+    format: string;
+    trailingSlash: string;
+    provider?: string | null;
+    [key: string]: unknown;
+  };
+}
+
 const DEFAULTS = {
-  name: "Jx Site",
-  url: "",
-  defaults: {
-    layout: null,
-    lang: "en",
-    charset: "utf-8",
-  },
   $head: [],
-  imports: {},
   $media: {},
-  style: {},
-  state: {},
+  build: {
+    format: "directory",
+    outDir: "./dist",
+    provider: null,
+    trailingSlash: "always",
+  },
   contentTypes: {},
-  redirects: {},
+  defaults: {
+    charset: "utf8",
+    lang: "en",
+    layout: null,
+  },
   images: {
-    optimize: true,
-    widths: [320, 640, 960, 1280, 1920],
     formats: ["webp", "avif"],
-    quality: { webp: 80, avif: 65, jpeg: 80, png: 80 },
-    sizes: "(max-width: 768px) 100vw, 50vw",
     lazyLoad: true,
+    optimize: true,
+    quality: { avif: 65, jpeg: 80, png: 80, webp: 80 },
     service: "build",
-    binding: "IMAGES",
-  },
-  build: {
-    outDir: "./dist",
-    format: "directory",
-    trailingSlash: "always",
-    provider: null,
+    sizes: "(max-width: 768px) 100vw, 50vw",
+    widths: [320, 640, 960, 1280, 1920],
   },
-};
+  imports: {},
+  name: "Jx Site",
+  redirects: {},
+  state: {},
+  style: {},
+  url: "",
+} satisfies Partial<ResolvedProjectConfig>;
 
 /**
  * Load and validate project.json from a project root.
  *
  * @param {string} projectRoot - Absolute path to the project directory
- * @returns {{ config: Record<string, any>; configPath: string; projectRoot: string }}
+ * @returns {{ config: ProjectConfig; configPath: string; projectRoot: string }}
  * @throws {Error} If project.json is missing or invalid JSON
  */
 export function loadProjectConfig(projectRoot: string) {
@@ -59,35 +76,44 @@ export function loadProjectConfig(projectRoot: string) {
     throw new Error(`project.json not found in ${projectRoot}`);
   }
 
-  let raw;
+  let raw: ProjectConfig;
   try {
-    raw = JSON.parse(readFileSync(configPath, "utf8"));
-  } catch (e) {
-    const err = e as Error;
-    throw new Error(`Invalid JSON in ${configPath}: ${err.message}`);
-  }
-
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new Error(`project.json must be a JSON object, got ${typeof raw}`);
+    raw = parseProjectConfig(readFileSync(configPath, "utf8"), configPath);
+  } catch (error) {
+    throw new Error(`Invalid project.json: ${errorMessage(error)}`, { cause: error });
   }
 
   // Deep merge with defaults
-  const config = {
+  const config: ResolvedProjectConfig = {
     ...DEFAULTS,
     ...raw,
+    build: { ...DEFAULTS.build, ...raw.build },
     defaults: { ...DEFAULTS.defaults, ...raw.defaults },
     images: { ...DEFAULTS.images, ...raw.images },
-    build: { ...DEFAULTS.build, ...raw.build },
   };
 
   // Preserve arrays and objects that shouldn't be shallow-merged
-  if (raw.$head) config.$head = raw.$head;
-  if (raw.$media) config.$media = raw.$media;
-  if (raw.style) config.style = raw.style;
-  if (raw.state) config.state = raw.state;
-  if (raw.redirects) config.redirects = raw.redirects;
-  if (raw.imports) config.imports = raw.imports;
-  if (raw.contentTypes) config.contentTypes = raw.contentTypes;
+  if (raw.$head) {
+    config.$head = raw.$head;
+  }
+  if (raw.$media) {
+    config.$media = raw.$media;
+  }
+  if (raw.style) {
+    config.style = raw.style;
+  }
+  if (raw.state) {
+    config.state = raw.state;
+  }
+  if (raw.redirects) {
+    config.redirects = raw.redirects;
+  }
+  if (raw.imports) {
+    config.imports = raw.imports;
+  }
+  if (raw.contentTypes) {
+    config.contentTypes = raw.contentTypes;
+  }
 
   // Validate adapter
   const VALID_ADAPTERS = ["cloudflare-workers", "cloudflare-pages", "node", "bun"];
@@ -98,7 +124,8 @@ export function loadProjectConfig(projectRoot: string) {
     );
   }
 
-  // Validate image service
+  // Validate image service. The "cloudflare" service emits /cdn-cgi/image transform URLs,
+  // Which work on any zone served through Cloudflare regardless of the build adapter.
   const VALID_IMAGE_SERVICES = ["build", "cloudflare"];
   if (!VALID_IMAGE_SERVICES.includes(config.images.service)) {
     throw new Error(
@@ -106,14 +133,6 @@ export function loadProjectConfig(projectRoot: string) {
         `Valid services: ${VALID_IMAGE_SERVICES.join(", ")}`,
     );
   }
-  const CF_ADAPTERS = ["cloudflare-workers", "cloudflare-pages"];
-  if (config.images.service === "cloudflare" && !CF_ADAPTERS.includes(config.build.adapter)) {
-    console.warn(
-      `images.service "cloudflare" requires a Cloudflare adapter ` +
-        `(${CF_ADAPTERS.join(", ")}) — falling back to "build"`,
-    );
-    config.images.service = "build";
-  }
 
   return {
     config,

package/src/targets/compile-class.ts

@@ -5,28 +5,40 @@
  * Schema 2020-12 class definition.
  */
 
-import type { JxMutableNode } from "@jxsuite/schema/types";
+import type {
+  JxClassCtorDef,
+  JxClassDef,
+  JxClassMethodDef,
+  JxClassParamDef,
+} from "@jxsuite/schema/types";
 
 /**
  * Compile a .class.json schema to a JavaScript ES module string.
  *
- * @param {JxMutableNode} classDef - Parsed .class.json content (must have $prototype: "Class")
+ * @param {JxClassDef} classDef - Parsed .class.json content (must have $prototype: "Class")
  * @param {Record<string, unknown>} [_opts]
  * @returns {string} JavaScript module source code
  */
-export function compileClassJson(classDef: JxMutableNode, _opts: Record<string, unknown> = {}) {
+export function compileClassJson(classDef: JxClassDef, _opts: Record<string, unknown> = {}) {
   const className = classDef.title;
-  if (!className) throw new Error("compileClassJson: missing title (class name)");
+  if (!className) {
+    throw new Error("compileClassJson: missing title (class name)");
+  }
 
   const baseClass = resolveBaseClass(classDef.extends);
-  const defs = classDef.$defs as Record<string, unknown> | undefined;
-  const fields = (defs?.fields ?? {}) as Record<string, JxMutableNode>;
-  const ctor = defs?.constructor as JxMutableNode | undefined;
-  const methods = (defs?.methods ?? {}) as Record<string, JxMutableNode>;
-
-  const lines: string[] = [];
-  lines.push("// Generated by @jxsuite/compiler from .class.json — do not edit manually");
-  if (classDef.$id) lines.push(`// Source: ${classDef.$id}`);
+  const defs = classDef.$defs;
+  const fields = defs?.fields ?? {};
+  // JSON objects inherit Object.prototype.constructor — only an own object value counts.
+  const rawCtor = defs?.constructor;
+  const ctor = typeof rawCtor === "object" ? rawCtor : undefined;
+  const methods = defs?.methods ?? {};
+
+  const lines: string[] = [
+    "// Generated by @jxsuite/compiler from .class.json — do not edit manually",
+  ];
+  if (classDef.$id) {
+    lines.push(`// Source: ${classDef.$id}`);
+  }
   lines.push("");
 
   // Class declaration
@@ -34,9 +46,10 @@ export function compileClassJson(classDef: JxMutableNode, _opts: Record<string,
   lines.push(`class ${className}${extendsClause} {`);
 
   // Static fields
-  for (const [key, field] of Object.entries(fields)) {
-    const f = field as JxMutableNode;
-    if (f.scope !== "static") continue;
+  for (const [key, f] of Object.entries(fields)) {
+    if (f.scope !== "static") {
+      continue;
+    }
     const name = f.identifier ?? key;
     const prefix = f.access === "private" ? "#" : "";
     const initVal =
@@ -49,15 +62,20 @@ export function compileClassJson(classDef: JxMutableNode, _opts: Record<string,
   }
 
   // Instance field declarations (private)
-  for (const [key, field] of Object.entries(fields)) {
-    const f = field as JxMutableNode;
-    if (f.scope === "static") continue;
-    if (f.access !== "private") continue;
+  for (const [key, f] of Object.entries(fields)) {
+    if (f.scope === "static") {
+      continue;
+    }
+    if (f.access !== "private") {
+      continue;
+    }
     const name = f.identifier ?? key;
     lines.push(`  #${name};`);
   }
 
-  if (Object.keys(fields).length > 0) lines.push("");
+  if (Object.keys(fields).length > 0) {
+    lines.push("");
+  }
 
   // Constructor
   lines.push("  constructor(config = {}) {");
@@ -67,9 +85,10 @@ export function compileClassJson(classDef: JxMutableNode, _opts: Record<string,
   }
 
   // Initialize instance fields from config or defaults
-  for (const [key, field] of Object.entries(fields)) {
-    const f = field as JxMutableNode;
-    if (f.scope === "static") continue;
+  for (const [key, f] of Object.entries(fields)) {
+    if (f.scope === "static") {
+      continue;
+    }
     const name = f.identifier ?? key;
     const prefix = f.access === "private" ? "#" : "";
     const initVal =
@@ -93,18 +112,13 @@ export function compileClassJson(classDef: JxMutableNode, _opts: Record<string,
   lines.push("  }");
 
   // Methods
-  for (const [key, method] of Object.entries(methods)) {
-    const m = method as JxMutableNode;
+  for (const [key, m] of Object.entries(methods)) {
     const name = m.identifier ?? key;
     const isStatic = m.scope === "static";
     const isPrivate = m.access === "private";
     const prefix = isPrivate ? "#" : "";
     const staticPrefix = isStatic ? "static " : "";
-    const asyncPrefix =
-      m.returnType?.$ref?.includes("Promise") ||
-      isMethodAsync(m as unknown as { body?: string | string[] })
-        ? "async "
-        : "";
+    const asyncPrefix = m.returnType?.$ref?.includes("Promise") || isMethodAsync(m) ? "async " : "";
 
     const params = resolveParams(m.parameters ?? []);
     const bodyStr = resolveBody(m.body);
@@ -146,16 +160,18 @@ export function compileClassJson(classDef: JxMutableNode, _opts: Record<string,
 /**
  * Resolve the base class name from an extends value.
  *
- * @param {unknown} ext
+ * @param {JxClassDef["extends"]} ext
  * @returns {string}
  */
-function resolveBaseClass(ext: unknown) {
-  if (!ext) return "Object";
-  if (typeof ext === "string") return ext;
-  const e = ext as JxMutableNode;
-  if (e.$ref) {
-    const ref = e.$ref;
-    const match = ref.match(/([A-Za-z0-9_]+)\.class\.json/);
+function resolveBaseClass(ext: JxClassDef["extends"]) {
+  if (!ext) {
+    return "Object";
+  }
+  if (typeof ext === "string") {
+    return ext;
+  }
+  if (ext.$ref) {
+    const match = ext.$ref.match(/([A-Za-z0-9_]+)\.class\.json/);
     return match ? match[1] : "Object";
   }
   return "Object";
@@ -164,15 +180,17 @@ function resolveBaseClass(ext: unknown) {
 /**
  * Resolve parameter names from $ref or inline definitions.
  *
- * @param {unknown[]} params
+ * @param {JxClassParamDef[]} params
  * @returns {string}
  */
-function resolveParams(params: unknown[]) {
+function resolveParams(params: JxClassParamDef[]) {
   return params
-    .map((p) => {
-      const param = p as JxMutableNode;
-      if (param.$ref) return param.$ref.split("/").pop();
-      return param.identifier ?? param.name ?? "arg";
+    .map((param) => {
+      if (param.$ref) {
+        return param.$ref.split("/").pop();
+      }
+      const name = param.identifier ?? param.name;
+      return typeof name === "string" ? name : "arg";
     })
     .join(", ");
 }
@@ -180,22 +198,23 @@ function resolveParams(params: unknown[]) {
 /**
  * Resolve body from string or array of strings.
  *
- * @param {unknown} body
+ * @param {string | string[] | undefined} body
  * @returns {string[]}
  */
-function resolveBody(body: unknown) {
-  if (!body) return [""];
-  if (Array.isArray(body)) return body;
-  return [body as string];
+function resolveBody(body: string | string[] | undefined) {
+  if (!body) {
+    return [""];
+  }
+  return Array.isArray(body) ? body : [body];
 }
 
 /**
  * Simple heuristic: does the method body contain await?
  *
- * @param {{ body?: string | string[] }} method
+ * @param {JxClassMethodDef | JxClassCtorDef} method
  * @returns {boolean}
  */
-function isMethodAsync(method: { body?: string | string[] }) {
+function isMethodAsync(method: JxClassMethodDef | JxClassCtorDef) {
   const body = Array.isArray(method.body) ? method.body.join("\n") : (method.body ?? "");
   return body.includes("await ");
 }