@hla4ts/fom-codegen 0.1.0

package/src/index.ts

@@ -0,0 +1,62 @@
+/**
+ * @hla4ts/fom-codegen
+ *
+ * TypeScript-first registry and XML generator for IEEE 1516-2025 FOM/SOM.
+ */
+
+export {
+  type SharingType,
+  type OrderType,
+  type UpdateType,
+  type OwnershipType,
+  type ModelIdentification,
+  type TimeDefinition,
+  type AttributeSchema,
+  type ObjectClassSchema,
+  type ParameterSchema,
+  type InteractionClassSchema,
+  type DimensionSchema,
+  type TransportationSchema,
+  type SwitchesSchema,
+  type SimpleDataTypeSchema,
+  type EnumeratedDataTypeSchema,
+  type ArrayDataTypeSchema,
+  type FixedRecordDataTypeSchema,
+  type VariantRecordDataTypeSchema,
+  type DataTypeSchema,
+  type FomModel,
+  type FomOutputFormat,
+  type FomOutputOptions,
+} from "./types.ts";
+
+export {
+  FomRegistry,
+  defaultRegistry,
+  defineObjectClass,
+  defineInteractionClass,
+} from "./registry.ts";
+
+export { renderFomXml } from "./xml-writer.ts";
+export { parseFomXml } from "./xml-parser.ts";
+export {
+  generateFomTypescript,
+  type TsCodegenMode,
+  type TsCodegenOptions,
+} from "./ts-codegen.ts";
+
+// =============================================================================
+// Generated XSD Types (for autocomplete and type checking)
+// =============================================================================
+export * from "./generated/index.ts";
+
+// =============================================================================
+// XSD Type Adapters (convert XSD types to FomRegistry types)
+// =============================================================================
+export {
+  adaptModelIdentification,
+  adaptObjectClass,
+  adaptInteractionClass,
+  type XsdModelIdentification,
+  type XsdObjectClass,
+  type XsdInteractionClass,
+} from "./xsd-types-adapter.ts";

package/src/registry.ts

@@ -0,0 +1,127 @@
+import type {
+  DataTypeSchema,
+  DimensionSchema,
+  FomModel,
+  FomOutputOptions,
+  InteractionClassSchema,
+  ModelIdentification,
+  ObjectClassSchema,
+  TransportationSchema,
+  TimeDefinition,
+} from "./types.ts";
+import { renderFomXml } from "./xml-writer.ts";
+
+const NCNAME_PATTERN = /^[A-Za-z_][A-Za-z0-9._-]*$/;
+
+export class FomRegistry {
+  private _modelIdentification?: ModelIdentification;
+  private _time?: TimeDefinition;
+  private readonly _objectClasses: ObjectClassSchema[] = [];
+  private readonly _interactionClasses: InteractionClassSchema[] = [];
+  private readonly _dataTypes: DataTypeSchema[] = [];
+  private readonly _dimensions: DimensionSchema[] = [];
+  private readonly _transportations: TransportationSchema[] = [];
+  private _switches?: FomModel["switches"];
+
+  setModelIdentification(model: ModelIdentification): void {
+    this._modelIdentification = model;
+  }
+
+  setTime(time: TimeDefinition): void {
+    this._time = time;
+  }
+
+  addObjectClass(schema: ObjectClassSchema): void {
+    validateName(schema.name, "object class");
+    this._objectClasses.push(schema);
+  }
+
+  addInteractionClass(schema: InteractionClassSchema): void {
+    validateName(schema.name, "interaction class");
+    this._interactionClasses.push(schema);
+  }
+
+  addDataType(schema: DataTypeSchema): void {
+    validateName(schema.name, "data type");
+    this._dataTypes.push(schema);
+  }
+
+  addDimension(schema: DimensionSchema): void {
+    validateName(schema.name, "dimension");
+    this._dimensions.push(schema);
+  }
+
+  addTransportation(schema: TransportationSchema): void {
+    validateName(schema.name, "transportation");
+    this._transportations.push(schema);
+  }
+
+  setSwitches(switches: FomModel["switches"]): void {
+    this._switches = switches ?? undefined;
+  }
+
+  buildModel(): FomModel {
+    return {
+      modelIdentification: this._modelIdentification,
+      time: this._time,
+      objectClasses: [...this._objectClasses],
+      interactionClasses: [...this._interactionClasses],
+      dataTypes: [...this._dataTypes],
+      dimensions: [...this._dimensions],
+      transportations: [...this._transportations],
+      switches: this._switches,
+    };
+  }
+
+  toXml(options: FomOutputOptions): string {
+    if (options.format === "omt") {
+      assertModelIdentification(this._modelIdentification);
+    }
+    return renderFomXml(this.buildModel(), options);
+  }
+}
+
+export const defaultRegistry = new FomRegistry();
+
+export function defineObjectClass<T extends new (...args: never[]) => unknown>(
+  ctor: T,
+  schema: ObjectClassSchema,
+  registry: FomRegistry = defaultRegistry
+): T {
+  registry.addObjectClass(schema);
+  return ctor;
+}
+
+export function defineInteractionClass<T extends new (...args: never[]) => unknown>(
+  ctor: T,
+  schema: InteractionClassSchema,
+  registry: FomRegistry = defaultRegistry
+): T {
+  registry.addInteractionClass(schema);
+  return ctor;
+}
+
+function validateName(name: string, label: string): void {
+  if (!NCNAME_PATTERN.test(name)) {
+    throw new Error(`Invalid ${label} name "${name}". Expected XML NCName.`);
+  }
+}
+
+function assertModelIdentification(model?: ModelIdentification): void {
+  if (!model) {
+    throw new Error("Model identification is required for OMT output.");
+  }
+  const required: Array<keyof ModelIdentification> = [
+    "name",
+    "type",
+    "version",
+    "modificationDate",
+    "securityClassification",
+    "description",
+  ];
+  for (const key of required) {
+    if (!model[key]) {
+      throw new Error(`Model identification is missing required field: ${String(key)}`);
+    }
+  }
+}

package/src/ts-codegen.ts

@@ -0,0 +1,59 @@
+import type { FomModel } from "./types.ts";
+
+export type TsCodegenMode = "model" | "registry";
+
+export interface TsCodegenOptions {
+  mode?: TsCodegenMode;
+  exportName?: string;
+  indent?: number;
+}
+
+export function generateFomTypescript(model: FomModel, options?: TsCodegenOptions): string {
+  const mode = options?.mode ?? "model";
+  const exportName = options?.exportName ?? (mode === "registry" ? "registry" : "fom");
+  const indent = options?.indent ?? 2;
+  const json = JSON.stringify(model, null, indent);
+
+  if (mode === "model") {
+    return [
+      'import type { FomModel } from "@hla4ts/fom-codegen";',
+      "",
+      `export const ${exportName}: FomModel = ${json};`,
+      "",
+      `export function buildFom(): FomModel {`,
+      `  return ${exportName};`,
+      `}`,
+      "",
+    ].join("\n");
+  }
+
+  return [
+    'import { FomRegistry } from "@hla4ts/fom-codegen";',
+    'import type { FomModel } from "@hla4ts/fom-codegen";',
+    "",
+    `const model: FomModel = ${json};`,
+    "",
+    `export const ${exportName} = new FomRegistry();`,
+    `if (model.modelIdentification) ${exportName}.setModelIdentification(model.modelIdentification);`,
+    `if (model.time) ${exportName}.setTime(model.time);`,
+    "for (const obj of model.objectClasses) {",
+    `  ${exportName}.addObjectClass(obj);`,
+    "}",
+    "for (const interaction of model.interactionClasses) {",
+    `  ${exportName}.addInteractionClass(interaction);`,
+    "}",
+    "for (const dataType of model.dataTypes) {",
+    `  ${exportName}.addDataType(dataType);`,
+    "}",
+    "for (const dim of model.dimensions ?? []) {",
+    `  ${exportName}.addDimension(dim);`,
+    "}",
+    "for (const transport of model.transportations ?? []) {",
+    `  ${exportName}.addTransportation(transport);`,
+    "}",
+    "if (model.switches) {",
+    `  ${exportName}.setSwitches(model.switches);`,
+    "}",
+    "",
+  ].join("\n");
+}

package/src/types.ts

@@ -0,0 +1,172 @@
+/**
+ * FOM Codegen Types
+ *
+ * These types define a minimal, explicit schema for generating IEEE 1516-2025
+ * OMT/FDD XML from TypeScript registrations.
+ */
+
+export type SharingType = "Publish" | "Subscribe" | "PublishSubscribe" | "Neither";
+export type OrderType = "Receive" | "TimeStamp";
+export type UpdateType = "Static" | "Periodic" | "Conditional" | "NA";
+export type OwnershipType = "Divest" | "Acquire" | "DivestAcquire" | "NoTransfer";
+
+export interface ModelIdentification {
+  name: string;
+  type: "FOM" | "SOM";
+  version: string;
+  modificationDate: string; // YYYY-MM-DD
+  securityClassification: string;
+  description: string;
+  purpose?: string;
+  applicationDomain?: string;
+  useLimitation?: string;
+  keyword?: Array<{ taxonomy?: string; keywordValue: string }>;
+}
+
+export interface TimeDefinition {
+  timeStampType: string;
+  lookaheadType: string;
+  semantics?: {
+    timeStamp?: string;
+    lookahead?: string;
+  };
+}
+
+export interface AttributeSchema {
+  name: string;
+  dataType: string;
+  updateType: UpdateType;
+  updateCondition: string;
+  ownership: OwnershipType;
+  sharing: SharingType;
+  transportation: string;
+  order: OrderType;
+  semantics?: string;
+  valueRequired?: boolean;
+}
+
+export interface ObjectClassSchema {
+  name: string;
+  parent?: string;
+  sharing?: SharingType;
+  semantics?: string;
+  attributes?: AttributeSchema[];
+}
+
+export interface ParameterSchema {
+  name: string;
+  dataType: string;
+  semantics?: string;
+}
+
+export interface InteractionClassSchema {
+  name: string;
+  parent?: string;
+  sharing?: SharingType;
+  transportation?: string;
+  order?: OrderType;
+  semantics?: string;
+  parameters?: ParameterSchema[];
+}
+
+export interface DimensionSchema {
+  name: string;
+  dataType?: string;
+}
+
+export interface TransportationSchema {
+  name: string;
+  reliable?: "Yes" | "No";
+}
+
+export interface SwitchesSchema {
+  autoProvide?: boolean;
+  conveyRegionDesignatorSets?: boolean;
+  conveyProducingFederate?: boolean;
+  attributeScopeAdvisory?: boolean;
+  attributeRelevanceAdvisory?: boolean;
+  objectClassRelevanceAdvisory?: boolean;
+  interactionRelevanceAdvisory?: boolean;
+  serviceReporting?: boolean;
+  exceptionReporting?: boolean;
+  delaySubscriptionEvaluation?: boolean;
+  automaticResignAction?: string;
+}
+
+export interface SimpleDataTypeSchema {
+  kind: "simple";
+  name: string;
+  representation: string;
+  units?: string;
+  resolution?: string;
+  accuracy?: string;
+  semantics?: string;
+}
+
+export interface EnumeratedDataTypeSchema {
+  kind: "enumerated";
+  name: string;
+  representation: string;
+  semantics?: string;
+  enumerators: Array<{ name: string; value: string | string[] }>;
+}
+
+export interface ArrayDataTypeSchema {
+  kind: "array";
+  name: string;
+  dataType: string;
+  cardinality: string;
+  encoding: string;
+  semantics?: string;
+}
+
+export interface FixedRecordDataTypeSchema {
+  kind: "fixedRecord";
+  name: string;
+  encoding: string;
+  semantics?: string;
+  fields: Array<{ name: string; dataType: string; semantics?: string }>;
+}
+
+export interface VariantRecordDataTypeSchema {
+  kind: "variantRecord";
+  name: string;
+  discriminant: string;
+  dataType: string;
+  encoding: string;
+  semantics?: string;
+  alternatives: Array<{
+    enumerator: string;
+    name?: string;
+    dataType?: string;
+    semantics?: string;
+  }>;
+}
+
+export type DataTypeSchema =
+  | SimpleDataTypeSchema
+  | EnumeratedDataTypeSchema
+  | ArrayDataTypeSchema
+  | FixedRecordDataTypeSchema
+  | VariantRecordDataTypeSchema;
+
+export interface FomModel {
+  modelIdentification?: ModelIdentification;
+  time?: TimeDefinition;
+  objectClasses: ObjectClassSchema[];
+  interactionClasses: InteractionClassSchema[];
+  dataTypes: DataTypeSchema[];
+  dimensions?: DimensionSchema[];
+  transportations?: TransportationSchema[];
+  switches?: SwitchesSchema;
+}
+
+export type FomOutputFormat = "omt" | "fdd";
+
+export interface FomOutputOptions {
+  format: FomOutputFormat;
+  schemaLocation?: string;
+  includeModelIdentification?: boolean;
+  indent?: string;
+  inferParentStubs?: boolean;
+}