@jxsuite/compiler 0.28.2 → 0.28.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/compiler",
-  "version": "0.28.2",
+  "version": "0.28.4",
   "description": "Jx static HTML compiler, island detector, and site builder",
   "license": "MIT",
   "repository": {
@@ -42,10 +42,10 @@
   },
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^15.3.5",
-    "@jxsuite/parser": "^0.28.2",
-    "@jxsuite/runtime": "^0.28.2",
-    "@jxsuite/schema": "^0.28.2",
-    "sharp": "^0.34.5"
+    "@jxsuite/parser": "^0.28.4",
+    "@jxsuite/runtime": "^0.28.4",
+    "@jxsuite/schema": "^0.28.4",
+    "sharp": "^0.35.0"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.10.2",

package/src/cli.ts

@@ -10,7 +10,7 @@
 import { resolve } from "node:path";
 
 const args = process.argv.slice(2);
-const command = args[0];
+const [command] = args;
 
 if (!command || command === "--help" || command === "-h") {
   console.log(`Usage: jx <command> [options]
@@ -27,9 +27,9 @@ Options:
 if (command === "build") {
   const rest = args.slice(1);
   const flags = new Set(rest.filter((a) => a.startsWith("--")));
-  const positional = rest.filter((a) => !a.startsWith("--"));
+  const positional = rest.find((a) => !a.startsWith("--"));
 
-  const projectRoot = resolve(positional[0] ?? ".");
+  const projectRoot = resolve(positional ?? ".");
   const verbose = flags.has("--verbose");
   const clean = !flags.has("--no-clean");
 
@@ -37,7 +37,7 @@ if (command === "build") {
 
   try {
     const { buildSite } = await import("./site/site-build.ts");
-    const result = await buildSite(projectRoot, { verbose, clean });
+    const result = await buildSite(projectRoot, { clean, verbose });
 
     if (result.errors.length > 0) {
       console.error(`\nBuild completed with ${result.errors.length} error(s):`);
@@ -48,8 +48,8 @@ if (command === "build") {
     }
 
     console.log(`\nDone: ${result.routes} routes → ${result.files} files`);
-  } catch (e) {
-    const err = e as Error;
+  } catch (error) {
+    const err = error as Error;
     console.error(`Build failed: ${err.message}`);
     process.exit(1);
   }

package/src/compile-cli.ts

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import { runCli } from "./compiler.ts";
 
-const [, , src, out] = process.argv;
+const [src, out] = process.argv.slice(2);
 if (src) {
-  runCli(src, out).catch((err) => {
-    console.error(err);
+  try {
+    await runCli(src, out);
+  } catch (error) {
+    console.error(error);
     process.exit(1);
-  });
+  }
 }

package/src/compiler.ts

@@ -1,5 +1,5 @@
 /**
- * jx-compiler.js — Compiler orchestrator
+ * Jx-compiler.js — Compiler orchestrator
  * @version 3.0.0
  * @license MIT
  *
@@ -15,12 +15,12 @@
 
 import { readFileSync } from "node:fs";
 import {
-  isDynamic,
+  DEFAULT_LIT_HTML_SRC,
+  DEFAULT_REACTIVITY_SRC,
   compileStyles,
   escapeHtml,
+  isDynamic,
   tagNameToClassName,
-  DEFAULT_REACTIVITY_SRC,
-  DEFAULT_LIT_HTML_SRC,
 } from "./shared.ts";
 import { compileServer, compileSiteServer } from "./targets/compile-server.ts";
 
@@ -31,7 +31,10 @@ import {
 } from "./targets/compile-element.ts";
 import { compileStaticPage } from "./targets/compile-static.ts";
 import { compileClient } from "./targets/compile-client.ts";
-import type { JxMutableNode } from "@jxsuite/schema/types";
+import { isClassDef } from "@jxsuite/schema/guards";
+import { parseJxDocument } from "@jxsuite/schema/parse";
+import type { JxDocument, JxStyle } from "@jxsuite/schema/types";
+import type { FormatRegistry } from "@jxsuite/schema/format-registry";
 
 // Re-exports for consumers
 export {
@@ -45,77 +48,85 @@ export {
 
 // ─── Entry ────────────────────────────────────────────────────────────────────
 
+export interface CompileOptions {
+  title?: string;
+  reactivitySrc?: string;
+  litHtmlSrc?: string;
+  projectStyle?: JxStyle | null;
+  formats?: FormatRegistry;
+  [key: string]: unknown;
+}
+
 /**
  * Compile a Jx document to HTML (+ optional JS module files).
  *
  * Routing: 1. Not dynamic → static HTML/CSS, zero JS 2. tagName contains hyphen → custom element
  * (lit-html) 3. Otherwise → pre-rendered HTML with reactive bindings
  *
- * @param {string | any} sourcePath - Path to .json file, URL, or raw object
- * @param {Record<string, unknown>} [opts]
+ * @param {string | JxDocument} sourcePath - Path to .json file, URL, or raw document object
+ * @param {CompileOptions} [opts]
  * @returns {Promise<{
  *   html: string;
  *   files: { path: string; content: string; tagName?: string }[];
  * }>}
  */
-export async function compile(sourcePath: string | any, opts: Record<string, unknown> = {}) {
+export async function compile(sourcePath: string | JxDocument, opts: CompileOptions = {}) {
   const {
     title = "Jx App",
     reactivitySrc = DEFAULT_REACTIVITY_SRC,
     litHtmlSrc = DEFAULT_LIT_HTML_SRC,
     projectStyle = null,
-  } = opts as JxMutableNode;
+  } = opts;
 
-  let raw;
+  let raw: JxDocument;
   if (typeof sourcePath === "string") {
     const source = readFileSync(sourcePath, "utf8");
     if (sourcePath.endsWith(".json")) {
-      raw = JSON.parse(source);
+      raw = parseJxDocument(source, sourcePath);
     } else {
       const { extname } = await import("node:path");
       const ext = extname(sourcePath).toLowerCase();
-      const registry = (opts as JxMutableNode)
-        .formats as import("@jxsuite/schema/format-registry").FormatRegistry;
-      const entry = registry?.byExtension?.(ext, "parse");
+      const entry = opts.formats?.byExtension?.(ext, "parse");
       if (!entry) {
         const { unknownFormatError } = await import("./site/format-host.ts");
         throw unknownFormatError(sourcePath, ext);
       }
-      raw = await entry.call("parse", source);
+      // Format plugins contractually parse source text into a Jx document.
+      raw = (await entry.call("parse", source)) as JxDocument;
     }
   } else {
     raw = sourcePath;
   }
 
   // Route 0: .class.json schema-defined class → JS class module
-  if (raw.$prototype === "Class") {
+  if (isClassDef(raw)) {
     const { compileClassJson } = await import("./targets/compile-class.js");
     const jsContent = compileClassJson(raw, opts);
     const outputPath =
       typeof sourcePath === "string"
         ? sourcePath.replace(/\.class\.json$/, ".js")
         : `${raw.title}.js`;
-    return { html: "", files: [{ path: outputPath, content: jsContent }] };
+    return { files: [{ content: jsContent, path: outputPath }], html: "" };
   }
 
   // Route 1: Fully static → plain HTML/CSS
   if (!isDynamic(raw)) {
     return compileStaticPage(raw, {
-      title,
-      reactivitySrc,
       litHtmlSrc,
       projectStyle,
+      reactivitySrc,
+      title,
     });
   }
 
   // Route 2: Custom element tagName (contains hyphen) → lit-html web component
   if (raw.tagName && raw.tagName.includes("-")) {
-    const tagName = raw.tagName;
+    const { tagName } = raw;
     const className = tagNameToClassName(tagName);
     const moduleContent = emitElementModule(raw, className, []);
     const moduleFile = {
-      path: `${tagName}.js`,
       content: moduleContent,
+      path: `${tagName}.js`,
       tagName,
     };
     const styleBlock = compileStyles(raw, raw.$media ?? {});
@@ -142,11 +153,11 @@ export async function compile(sourcePath: string | any, opts: Record<string, unk
 </body>
 </html>`;
 
-    return { html, files: [moduleFile] };
+    return { files: [moduleFile], html };
   }
 
   // Route 3: Dynamic with standard tagName → pre-rendered HTML + reactive bindings
-  return compileClient(raw, { title, reactivitySrc, litHtmlSrc, projectStyle });
+  return compileClient(raw, { litHtmlSrc, projectStyle, reactivitySrc, title });
 }
 
 // ─── CLI ──────────────────────────────────────────────────────────────────────