@hla4ts/fom-codegen 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hla4ts/fom-codegen",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "FOM XML parser, registry, and TypeScript code generation tooling for hla4typescript",
   "type": "module",
   "main": "src/index.ts",

package/src/cli.ts

@@ -1,179 +1,179 @@
-#!/usr/bin/env bun
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { readFileSync, writeFileSync } from "node:fs";
-import { FomRegistry } from "./registry.ts";
-import type { FomModel, FomOutputFormat, FomOutputOptions } from "./types.ts";
-import { renderFomXml } from "./xml-writer.ts";
-import { parseFomXml } from "./xml-parser.ts";
-import { generateFomTypescript } from "./ts-codegen.ts";
-
-type CliArgs = {
-  entry: string;
-  out?: string;
-  format: FomOutputFormat;
-  schemaLocation?: string;
-  includeModelIdentification: boolean;
-  indent?: string;
-  fromXml?: string;
-  outTs?: string;
-  tsMode?: "model" | "registry";
-};
-
-function parseArgs(argv: string[]): CliArgs {
-  const args: CliArgs = {
-    entry: "",
-    format: "omt",
-    includeModelIdentification: true,
-  };
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case "--entry":
-        args.entry = argv[++i] ?? "";
-        break;
-      case "--from-xml":
-        args.fromXml = argv[++i];
-        break;
-      case "--out-ts":
-        args.outTs = argv[++i];
-        break;
-      case "--ts-mode":
-        args.tsMode = argv[++i] as "model" | "registry";
-        break;
-      case "--out":
-        args.out = argv[++i];
-        break;
-      case "--format":
-        args.format = (argv[++i] as FomOutputFormat) ?? "omt";
-        break;
-      case "--schema":
-        args.schemaLocation = argv[++i];
-        break;
-      case "--no-model-identification":
-        args.includeModelIdentification = false;
-        break;
-      case "--indent":
-        args.indent = argv[++i];
-        break;
-      case "--fdd":
-        args.format = "fdd";
-        break;
-      case "--omt":
-        args.format = "omt";
-        break;
-      case "--help":
-        printUsage();
-        process.exit(0);
-      default:
-        if (!arg.startsWith("--") && !args.entry) {
-          args.entry = arg;
-        }
-        break;
-    }
-  }
-
-  if (!args.entry && !args.fromXml) {
-    printUsage();
-    process.exit(1);
-  }
-
-  return args;
-}
-
-function printUsage(): void {
-  const text = [
-    "Usage: hla4ts-fom --entry <file> [options]",
-    "",
-    "Options:",
-    "  --entry <file>              Module that exports a registry or model",
-    "  --out <file>                Output XML file (stdout if omitted)",
-    "  --format <omt|fdd>          Output format (default: omt)",
-    "  --omt                       Shortcut for --format omt",
-    "  --fdd                       Shortcut for --format fdd",
-    "  --from-xml <file>           Parse XML and emit TypeScript",
-    "  --out-ts <file>             Output TypeScript file",
-    "  --ts-mode <model|registry>  TypeScript output mode (default: model)",
-    "  --schema <value>            Override xsi:schemaLocation",
-    "  --indent <value>            Indent string (default: two spaces)",
-    "  --no-model-identification   Skip modelIdentification block",
-  ];
-  console.log(text.join("\n"));
-}
-
-function resolveModel(mod: Record<string, unknown>): FomModel {
-  if (isRegistry(mod.registry)) {
-    return (mod.registry as FomRegistry).buildModel();
-  }
-  if (isRegistry(mod.default)) {
-    return (mod.default as FomRegistry).buildModel();
-  }
-  if (typeof mod.buildFom === "function") {
-    return mod.buildFom() as FomModel;
-  }
-  if (isFomModel(mod.default)) {
-    return mod.default as FomModel;
-  }
-  if (isFomModel(mod.fom)) {
-    return mod.fom as FomModel;
-  }
-  throw new Error("Entry module did not export a registry or FomModel.");
-}
-
-function isRegistry(value: unknown): value is FomRegistry {
-  return Boolean(
-    value &&
-      typeof value === "object" &&
-      typeof (value as FomRegistry).buildModel === "function" &&
-      typeof (value as FomRegistry).toXml === "function"
-  );
-}
-
-function isFomModel(value: unknown): value is FomModel {
-  return Boolean(
-    value &&
-      typeof value === "object" &&
-      Array.isArray((value as FomModel).objectClasses) &&
-      Array.isArray((value as FomModel).interactionClasses) &&
-      Array.isArray((value as FomModel).dataTypes)
-  );
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv.slice(2));
-  if (args.fromXml) {
-    const xml = readFileSync(args.fromXml, "utf8");
-    const model = parseFomXml(xml);
-    const ts = generateFomTypescript(model, {
-      mode: args.tsMode ?? "model",
-    });
-    if (args.outTs) {
-      writeFileSync(args.outTs, ts);
-    } else {
-      console.log(ts);
-    }
-    return;
-  }
-
-  const entryUrl = pathToFileURL(resolve(args.entry)).href;
-  const mod = (await import(entryUrl)) as Record<string, unknown>;
-  const model = resolveModel(mod);
-  const options: FomOutputOptions = {
-    format: args.format,
-    schemaLocation: args.schemaLocation,
-    includeModelIdentification: args.includeModelIdentification,
-    indent: args.indent,
-  };
-  const xml = renderFomXml(model, options);
-  if (args.out) {
-    writeFileSync(args.out, xml);
-  } else {
-    console.log(xml);
-  }
-}
-
-main().catch((error) => {
-  console.error(`[hla4ts-fom] ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(1);
-});
+#!/usr/bin/env bun
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { readFileSync, writeFileSync } from "node:fs";
+import { FomRegistry } from "./registry.ts";
+import type { FomModel, FomOutputFormat, FomOutputOptions } from "./types.ts";
+import { renderFomXml } from "./xml-writer.ts";
+import { parseFomXml } from "./xml-parser.ts";
+import { generateFomTypescript } from "./ts-codegen.ts";
+
+type CliArgs = {
+  entry: string;
+  out?: string;
+  format: FomOutputFormat;
+  schemaLocation?: string;
+  includeModelIdentification: boolean;
+  indent?: string;
+  fromXml?: string;
+  outTs?: string;
+  tsMode?: "model" | "registry";
+};
+
+function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = {
+    entry: "",
+    format: "omt",
+    includeModelIdentification: true,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--entry":
+        args.entry = argv[++i] ?? "";
+        break;
+      case "--from-xml":
+        args.fromXml = argv[++i];
+        break;
+      case "--out-ts":
+        args.outTs = argv[++i];
+        break;
+      case "--ts-mode":
+        args.tsMode = argv[++i] as "model" | "registry";
+        break;
+      case "--out":
+        args.out = argv[++i];
+        break;
+      case "--format":
+        args.format = (argv[++i] as FomOutputFormat) ?? "omt";
+        break;
+      case "--schema":
+        args.schemaLocation = argv[++i];
+        break;
+      case "--no-model-identification":
+        args.includeModelIdentification = false;
+        break;
+      case "--indent":
+        args.indent = argv[++i];
+        break;
+      case "--fdd":
+        args.format = "fdd";
+        break;
+      case "--omt":
+        args.format = "omt";
+        break;
+      case "--help":
+        printUsage();
+        process.exit(0);
+      default:
+        if (!arg.startsWith("--") && !args.entry) {
+          args.entry = arg;
+        }
+        break;
+    }
+  }
+
+  if (!args.entry && !args.fromXml) {
+    printUsage();
+    process.exit(1);
+  }
+
+  return args;
+}
+
+function printUsage(): void {
+  const text = [
+    "Usage: hla4ts-fom --entry <file> [options]",
+    "",
+    "Options:",
+    "  --entry <file>              Module that exports a registry or model",
+    "  --out <file>                Output XML file (stdout if omitted)",
+    "  --format <omt|fdd>          Output format (default: omt)",
+    "  --omt                       Shortcut for --format omt",
+    "  --fdd                       Shortcut for --format fdd",
+    "  --from-xml <file>           Parse XML and emit TypeScript",
+    "  --out-ts <file>             Output TypeScript file",
+    "  --ts-mode <model|registry>  TypeScript output mode (default: model)",
+    "  --schema <value>            Override xsi:schemaLocation",
+    "  --indent <value>            Indent string (default: two spaces)",
+    "  --no-model-identification   Skip modelIdentification block",
+  ];
+  console.log(text.join("\n"));
+}
+
+function resolveModel(mod: Record<string, unknown>): FomModel {
+  if (isRegistry(mod.registry)) {
+    return (mod.registry as FomRegistry).buildModel();
+  }
+  if (isRegistry(mod.default)) {
+    return (mod.default as FomRegistry).buildModel();
+  }
+  if (typeof mod.buildFom === "function") {
+    return mod.buildFom() as FomModel;
+  }
+  if (isFomModel(mod.default)) {
+    return mod.default as FomModel;
+  }
+  if (isFomModel(mod.fom)) {
+    return mod.fom as FomModel;
+  }
+  throw new Error("Entry module did not export a registry or FomModel.");
+}
+
+function isRegistry(value: unknown): value is FomRegistry {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      typeof (value as FomRegistry).buildModel === "function" &&
+      typeof (value as FomRegistry).toXml === "function"
+  );
+}
+
+function isFomModel(value: unknown): value is FomModel {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      Array.isArray((value as FomModel).objectClasses) &&
+      Array.isArray((value as FomModel).interactionClasses) &&
+      Array.isArray((value as FomModel).dataTypes)
+  );
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.fromXml) {
+    const xml = readFileSync(args.fromXml, "utf8");
+    const model = parseFomXml(xml);
+    const ts = generateFomTypescript(model, {
+      mode: args.tsMode ?? "model",
+    });
+    if (args.outTs) {
+      writeFileSync(args.outTs, ts);
+    } else {
+      console.log(ts);
+    }
+    return;
+  }
+
+  const entryUrl = pathToFileURL(resolve(args.entry)).href;
+  const mod = (await import(entryUrl)) as Record<string, unknown>;
+  const model = resolveModel(mod);
+  const options: FomOutputOptions = {
+    format: args.format,
+    schemaLocation: args.schemaLocation,
+    includeModelIdentification: args.includeModelIdentification,
+    indent: args.indent,
+  };
+  const xml = renderFomXml(model, options);
+  if (args.out) {
+    writeFileSync(args.out, xml);
+  } else {
+    console.log(xml);
+  }
+}
+
+main().catch((error) => {
+  console.error(`[hla4ts-fom] ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/src/generated/index.ts

@@ -1,25 +1,25 @@
-/**
- * Generated XSD Types - Re-exported for convenience
- *
- * This module re-exports the generated TypeScript types from the XSD schema.
- * These types provide autocomplete and type checking that matches XSD validation.
- */
-
-export * from "./xsd-types.ts";
-
-// Re-export commonly used types with shorter names for convenience
-export type {
-  ModelIdentification as XsdModelIdentification,
-  ObjectClass as XsdObjectClass,
-  InteractionClass as XsdInteractionClass,
-  Attribute as XsdAttribute,
-  Parameter as XsdParameter,
-} from "./xsd-types.ts";
-
-export type {
-  SharingEnumeration as XsdSharingType,
-  OrderEnumeration as XsdOrderType,
-  UpdateEnumeration as XsdUpdateType,
-  OwnershipEnumeration as XsdOwnershipType,
-  OMTypeEnumeration as XsdOMType,
-} from "./xsd-types.ts";
+/**
+ * Generated XSD Types - Re-exported for convenience
+ *
+ * This module re-exports the generated TypeScript types from the XSD schema.
+ * These types provide autocomplete and type checking that matches XSD validation.
+ */
+
+export * from "./xsd-types.ts";
+
+// Re-export commonly used types with shorter names for convenience
+export type {
+  ModelIdentification as XsdModelIdentification,
+  ObjectClass as XsdObjectClass,
+  InteractionClass as XsdInteractionClass,
+  Attribute as XsdAttribute,
+  Parameter as XsdParameter,
+} from "./xsd-types.ts";
+
+export type {
+  SharingEnumeration as XsdSharingType,
+  OrderEnumeration as XsdOrderType,
+  UpdateEnumeration as XsdUpdateType,
+  OwnershipEnumeration as XsdOwnershipType,
+  OMTypeEnumeration as XsdOMType,
+} from "./xsd-types.ts";