@hla4ts/fom-codegen 0.1.0

package/src/xsd-type-generator.ts

@@ -0,0 +1,452 @@
+/**
+ * XSD to TypeScript Type Generator
+ *
+ * Generates TypeScript type definitions from parsed XSD schemas.
+ */
+
+import type { XsdSchema, XsdType, XsdElement } from "./xsd-parser.ts";
+
+export interface TypeGenerationOptions {
+  outputFile?: string;
+  format?: "omt" | "fdd" | "dif";
+  includeDocumentation?: boolean;
+}
+
+/**
+ * Generate TypeScript types from an XSD schema.
+ */
+export function generateTypesFromXsd(
+  schema: XsdSchema,
+  options: TypeGenerationOptions = {}
+): string {
+  const { includeDocumentation = true } = options;
+  const lines: string[] = [];
+
+  // Header
+  lines.push("/**");
+  lines.push(" * Generated TypeScript types from IEEE 1516-2025 XSD Schema");
+  lines.push(" *");
+  lines.push(" * This file is auto-generated. Do not edit manually.");
+  lines.push(" * Regenerate with: bun run scripts/generate-types.ts");
+  lines.push(" */");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Enumerations");
+  lines.push("// ============================================================================");
+  lines.push("");
+
+  // Generate enumerations first
+  for (const [typeName, type] of schema.types.entries()) {
+    if (type.kind === "enum" && type.enumValues) {
+      generateEnum(lines, typeName, type, includeDocumentation);
+    }
+  }
+
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Complex Types");
+  lines.push("// ============================================================================");
+  lines.push("");
+
+  // Generate complex types (track generated to avoid duplicates)
+  const generatedInterfaces = new Set<string>();
+  for (const [typeName, type] of schema.types.entries()) {
+    if (type.kind === "complex") {
+      const interfaceName = sanitizeTypeName(typeName);
+      if (!generatedInterfaces.has(interfaceName)) {
+        generatedInterfaces.add(interfaceName);
+        generateInterface(lines, typeName, type, schema, includeDocumentation);
+      }
+    }
+  }
+
+  // Generate root element type if exists
+  if (schema.rootElement) {
+    const rootElement = schema.elements.get(schema.rootElement);
+    if (rootElement) {
+      const rootTypeName = resolveTypeName(rootElement.type);
+      const sanitizedRootTypeName = sanitizeTypeName(rootTypeName);
+      lines.push("");
+      lines.push("// ============================================================================");
+      lines.push("// Root Element");
+      lines.push("// ============================================================================");
+      lines.push("");
+      lines.push(`export type ${capitalize(schema.rootElement)}Type = ${sanitizedRootTypeName};`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function generateEnum(
+  lines: string[],
+  typeName: string,
+  type: XsdType,
+  includeDocumentation: boolean
+): void {
+  if (!type.enumValues || type.enumValues.length === 0) return;
+
+  if (includeDocumentation && type.documentation) {
+    lines.push("/**");
+    lines.push(` * ${type.documentation}`);
+    lines.push(" */");
+  }
+
+  const enumName = sanitizeTypeName(typeName);
+  const values = type.enumValues.map((v) => `"${v}"`).join(" | ");
+  lines.push(`export type ${enumName} = ${values};`);
+  lines.push("");
+}
+
+function generateInterface(
+  lines: string[],
+  typeName: string,
+  type: XsdType,
+  schema: XsdSchema,
+  includeDocumentation: boolean
+): void {
+  if (includeDocumentation && type.documentation) {
+    lines.push("/**");
+    lines.push(` * ${type.documentation}`);
+    lines.push(" */");
+  }
+
+  const interfaceName = sanitizeTypeName(typeName);
+  // Track property names to avoid duplicates
+  const seenProperties = new Set<string>();
+  
+  lines.push(`export interface ${interfaceName} {`);
+
+  // Handle base type (inheritance)
+  if (type.baseType) {
+    const baseTypeName = resolveTypeName(type.baseType);
+    lines.push(`  // Extends ${baseTypeName}`);
+  }
+
+  // Generate properties from elements (skip elements without names)
+  for (const element of type.elements) {
+    if (element.name && element.name.trim() !== "") {
+      // Skip if we've already seen this property name
+      if (!seenProperties.has(element.name)) {
+        seenProperties.add(element.name);
+        generateProperty(lines, element, schema, includeDocumentation);
+      }
+    }
+  }
+
+  // Generate properties from attributes (skip attributes without names)
+  for (const attr of type.attributes) {
+    if (attr.name && attr.name.trim() !== "") {
+      // Skip if we've already seen this property name
+      if (!seenProperties.has(attr.name)) {
+        seenProperties.add(attr.name);
+        generateAttributeProperty(lines, attr, schema);
+      }
+    }
+  }
+
+  lines.push("}");
+  lines.push("");
+}
+
+function generateProperty(
+  lines: string[],
+  element: XsdElement,
+  schema: XsdSchema,
+  includeDocumentation: boolean
+): void {
+  if (includeDocumentation && element.documentation) {
+    lines.push(`  /**`);
+    lines.push(`   * ${element.documentation}`);
+    lines.push(`   */`);
+  }
+
+  const propName = element.name;
+  const typeName = resolveTypeName(element.type, schema);
+  let tsType = mapXsdTypeToTs(typeName, schema, element.name);
+  
+  // Fallback for empty or unresolved types
+  if (!tsType || tsType.trim() === "") {
+    tsType = "unknown";
+  }
+
+  let propertyType = tsType;
+  if (element.array) {
+    propertyType = `${tsType}[]`;
+  }
+
+  const optional = element.optional ? "?" : "";
+  lines.push(`  ${propName}${optional}: ${propertyType};`);
+}
+
+function generateAttributeProperty(
+  lines: string[],
+  attr: { name: string; type: string; required: boolean },
+  schema: XsdSchema
+): void {
+  const propName = attr.name;
+  const typeName = resolveTypeName(attr.type, schema);
+  let tsType = mapXsdTypeToTs(typeName, schema);
+  
+  // Fallback for empty or unresolved types
+  if (!tsType || tsType.trim() === "") {
+    tsType = "unknown";
+  }
+
+  const optional = attr.required ? "" : "?";
+  lines.push(`  ${propName}${optional}: ${tsType};`);
+}
+
+function resolveTypeName(typeRef: string, schema?: XsdSchema): string {
+  // Remove namespace prefix (e.g., "xs:string" -> "string")
+  const parts = typeRef.split(":");
+  const localName = parts[parts.length - 1];
+
+  // Map XSD built-in types
+  const builtInTypes: Record<string, string> = {
+    string: "string",
+    int: "number",
+    integer: "number",
+    long: "number",
+    short: "number",
+    byte: "number",
+    decimal: "number",
+    float: "number",
+    double: "number",
+    boolean: "boolean",
+    date: "string", // ISO date string
+    dateTime: "string", // ISO datetime string
+    time: "string",
+    duration: "string",
+    anyURI: "string",
+    ID: "string",
+    IDREF: "string",
+    NCName: "string",
+    base64Binary: "string",
+    anyType: "unknown",
+    positiveInteger: "number", // XSD positiveInteger maps to number
+  };
+
+  if (builtInTypes[localName]) {
+    return builtInTypes[localName];
+  }
+
+  // Check if it's a type defined in the schema
+  if (schema && schema.types.has(localName)) {
+    const type = schema.types.get(localName)!;
+    
+    // If it's an enum, return the enum type name
+    if (type.kind === "enum") {
+      return sanitizeTypeName(localName);
+    }
+    
+    // If it's a simple type with a base type, resolve the base type
+    if (type.kind === "simple" && type.baseType) {
+      return resolveTypeName(type.baseType, schema);
+    }
+    
+    // If it's a complex type with simpleContent, resolve the base type recursively
+    if (type.kind === "complex" && type.baseType) {
+      const baseResolved = resolveTypeName(type.baseType, schema);
+      // If base resolves to a primitive, return it
+      if (builtInTypes[baseResolved] || ["string", "number", "boolean"].includes(baseResolved)) {
+        return baseResolved;
+      }
+      // If base resolves to an enum, return the enum name (not the complex type wrapper)
+      const baseType = schema.types.get(baseResolved);
+      if (baseType && baseType.kind === "enum") {
+        return sanitizeTypeName(baseResolved);
+      }
+      // Otherwise, continue resolving
+      return baseResolved;
+    }
+    
+    return sanitizeTypeName(localName);
+  }
+
+  // Default: return as-is (will be sanitized later)
+  return localName;
+}
+
+function mapXsdTypeToTs(typeName: string, schema: XsdSchema, elementName?: string): string {
+  const resolved = resolveTypeName(typeName, schema);
+
+  // If it's a primitive, return it
+  if (
+    ["string", "number", "boolean", "unknown"].includes(resolved)
+  ) {
+    return resolved;
+  }
+
+  // Get the type from schema - try both with and without "Type" suffix
+  let type = schema.types.get(resolved);
+  let typeKey = resolved;
+  
+  // If not found, try with "Type" suffix
+  if (!type && !resolved.endsWith("Type")) {
+    const withType = resolved + "Type";
+    type = schema.types.get(withType);
+    if (type) {
+      typeKey = withType;
+    }
+  }
+  
+  // Check if it's an enum type
+  if (type && type.kind === "enum") {
+    return sanitizeTypeName(typeKey);
+  }
+
+  // Check if it's a complex type with simpleContent (like String, Model, etc.)
+  // These should resolve to their base type
+  if (type && type.kind === "complex" && type.baseType) {
+    const baseResolved = resolveTypeName(type.baseType, schema);
+    // If base resolves to a primitive, use that
+    if (["string", "number", "boolean"].includes(baseResolved)) {
+      return baseResolved;
+    }
+    // Check if base type is an enum - this is the key case for Model -> OMTypeEnumeration
+    const baseType = schema.types.get(baseResolved);
+    if (baseType && baseType.kind === "enum") {
+      return sanitizeTypeName(baseResolved);
+    }
+    // Check if base type is a union - resolve to first member if it's an enum
+    if (baseType && baseType.kind === "simple" && baseType.baseType) {
+      const firstMember = resolveTypeName(baseType.baseType, schema);
+      const firstMemberType = schema.types.get(firstMember);
+      if (firstMemberType && firstMemberType.kind === "enum") {
+        return sanitizeTypeName(firstMember);
+      }
+      // If union member resolves to string, use string (union of enum + string)
+      if (firstMember === "string") {
+        return "string";
+      }
+    }
+    // Check if base type name suggests it's an enum (fallback)
+    if (baseResolved.endsWith("Enumeration")) {
+      const enumType = schema.types.get(baseResolved);
+      if (enumType && enumType.kind === "enum") {
+        return sanitizeTypeName(baseResolved);
+      }
+    }
+    // If we can't resolve further, return the complex type name
+    // (This handles cases where simpleContent extends a complex type)
+  }
+
+  // Check if it's a simple type with a base type
+  if (type && type.kind === "simple" && type.baseType) {
+    const baseResolved = resolveTypeName(type.baseType, schema);
+    if (["string", "number", "boolean"].includes(baseResolved)) {
+      return baseResolved;
+    }
+    // Check if base is an enum
+    const baseType = schema.types.get(baseResolved);
+    if (baseType && baseType.kind === "enum") {
+      return sanitizeTypeName(baseResolved);
+    }
+    // Pattern types (dimensionValuePattern, cardinalityPattern) are string-based
+    // and should resolve to string
+    if (baseResolved === "string") {
+      return "string";
+    }
+  }
+
+  // Fallback: if type name suggests a pattern type or unknown simple type, default to string
+  if (!type && (resolved.includes("Pattern") || resolved.includes("Enumeration"))) {
+    // Try to find it in schema as a simple type
+    const simpleType = schema.types.get(resolved);
+    if (simpleType && simpleType.kind === "simple" && simpleType.baseType) {
+      const baseResolved = resolveTypeName(simpleType.baseType, schema);
+      if (baseResolved === "string") {
+        return "string";
+      }
+    }
+    // If it's an enumeration that wasn't found, it might be a pattern-based enum
+    // Default to string for pattern-based types
+    if (resolved.includes("Pattern")) {
+      return "string";
+    }
+  }
+
+  // Otherwise, it's a complex type - return the interface name
+  // The generated interface name is sanitizeTypeName(typeKey)
+  // sanitizeTypeName removes "Type" suffix once
+  // So if typeKey is "ChangeDefaultAttributeTransportationTypeType", sanitize produces "ChangeDefaultAttributeTransportationType"
+  const sanitized = sanitizeTypeName(typeKey);
+  
+  // Special case: if the element name (from XSD) ends with "Type", and we created an inline type,
+  // the parser would have created a type with double "Type" (elementName + "Type"),
+  // and sanitizeTypeName removes one, leaving us with the correct name.
+  // But when we reference it, if the original typeName (from element.type) was the element name itself,
+  // we need to ensure we use the correct generated interface name.
+  
+  // If elementName is provided and ends with "Type", and typeKey also ends with "Type",
+  // then the generated interface name should keep the "Type" suffix
+  if (elementName && elementName.endsWith("Type") && typeKey.endsWith("Type") && type) {
+    // The element name ends with "Type", so the parser created a type with double "Type"
+    // sanitizeTypeName removes one, so we get the correct name with one "Type"
+    return sanitized;
+  }
+  
+  // If typeKey ends with "Type" and we found a type, the generated interface name
+  // is sanitized (which removes "Type"), but we might need to add it back if the
+  // original XSD type name had it and the parser created it with double "Type"
+  // Actually, let's check: if we found the type with "Type" suffix, and sanitize removes it,
+  // but the actual generated interface might have "Type" if the parser created it with double "Type"
+  
+  // The safest approach: check what the actual generated interface name would be
+  // by looking at what sanitizeTypeName produces for the typeKey
+  // If typeKey is "changeDefaultAttributeTransportationTypeType" (from parser),
+  // sanitizeTypeName produces "changeDefaultAttributeTransportationType" (removes one "Type")
+  // But wait, sanitizeTypeName also capitalizes, so it would be "ChangeDefaultAttributeTransportationType"
+  
+  // Actually, the issue is simpler: when an element name ends with "Type" (like "changeDefaultAttributeTransportationType"),
+  // the parser creates type name "ChangeDefaultAttributeTransportationTypeType" (capitalize + "Type"),
+  // and sanitizeTypeName("ChangeDefaultAttributeTransportationTypeType") = "ChangeDefaultAttributeTransportationType"
+  // So the generated interface IS "ChangeDefaultAttributeTransportationType"
+  
+  // But when we reference it via element.type = "changeDefaultAttributeTransportationType",
+  // resolveTypeName doesn't find it (because the type key is "ChangeDefaultAttributeTransportationTypeType"),
+  // so it returns sanitizeTypeName("changeDefaultAttributeTransportationType") = "ChangeDefaultAttributeTransportation"
+  // Then mapXsdTypeToTs gets "ChangeDefaultAttributeTransportation", doesn't find it,
+  // tries "ChangeDefaultAttributeTransportationType", finds it, and should return "ChangeDefaultAttributeTransportationType"
+  
+  // But currently it's returning sanitized = sanitizeTypeName("ChangeDefaultAttributeTransportationType")
+  // = "ChangeDefaultAttributeTransportation" (removes "Type")
+  
+  // The fix: if we found the type with "Type" suffix (typeKey ends with "Type"),
+  // and sanitizeTypeName would remove it, but the actual generated interface keeps it
+  // (because the parser created it with double "Type"), we should return sanitized + "Type"
+  if (typeKey.endsWith("Type") && type && typeKey !== sanitized + "Type") {
+    // The typeKey had "Type", sanitize removed it, but the actual interface might have "Type"
+    // Check if adding "Type" back would match a generated interface
+    // Actually, if typeKey is "ChangeDefaultAttributeTransportationType" and we found it,
+    // sanitizeTypeName("ChangeDefaultAttributeTransportationType") = "ChangeDefaultAttributeTransportation"
+    // But the actual interface is "ChangeDefaultAttributeTransportationType"
+    // So we need to add "Type" back
+    return sanitized + "Type";
+  }
+  
+  return sanitized;
+}
+
+function sanitizeTypeName(name: string): string {
+  // Remove common prefixes and capitalize
+  let sanitized = name
+    .replace(/^xs:/, "")
+    .replace(/Type$/, "")
+    .replace(/^[a-z]/, (c) => c.toUpperCase());
+
+  // Handle camelCase
+  sanitized = sanitized.replace(/([A-Z])/g, "$1");
+
+  // Ensure it starts with uppercase
+  if (sanitized[0] && sanitized[0] === sanitized[0].toLowerCase()) {
+    sanitized = sanitized[0].toUpperCase() + sanitized.slice(1);
+  }
+
+  return sanitized;
+}
+
+function capitalize(str: string): string {
+  return str[0].toUpperCase() + str.slice(1);
+}

package/src/xsd-types-adapter.ts

@@ -0,0 +1,177 @@
+/**
+ * XSD Types Adapter
+ *
+ * Provides adapters to convert between XSD-generated types and FomRegistry schema types.
+ * This allows using XSD-generated types for autocomplete while maintaining compatibility
+ * with the existing FomRegistry API.
+ */
+
+import type {
+  ModelIdentification as XsdModelIdentification,
+  ObjectClass as XsdObjectClass,
+  InteractionClass as XsdInteractionClass,
+  Attribute as XsdAttribute,
+  Parameter as XsdParameter,
+  SharingEnumeration,
+  OrderEnumeration,
+  UpdateEnumeration,
+  OwnershipEnumeration,
+} from "./generated/xsd-types.ts";
+
+import type {
+  ModelIdentification,
+  ObjectClassSchema,
+  InteractionClassSchema,
+  AttributeSchema,
+  ParameterSchema,
+} from "./types.ts";
+
+/**
+ * Convert XSD ModelIdentification to FomRegistry ModelIdentification.
+ * This provides autocomplete based on XSD schema.
+ */
+export function adaptModelIdentification(
+  xsd: XsdModelIdentification
+): ModelIdentification {
+  return {
+    name: xsd.name ?? "",
+    type: (xsd.type ?? "FOM") as "FOM" | "SOM",
+    version: xsd.version ?? "",
+    modificationDate: xsd.modificationDate ?? "",
+    securityClassification: xsd.securityClassification ?? "",
+    description: xsd.description ?? "",
+    purpose: xsd.purpose,
+    applicationDomain: xsd.applicationDomain,
+    useLimitation: xsd.useLimitation,
+    keyword: xsd.keyword?.map((kw) => ({
+      taxonomy: kw.taxonomy,
+      keywordValue: kw.keywordValue ?? "",
+    })),
+  };
+}
+
+/**
+ * Convert XSD ObjectClass to FomRegistry ObjectClassSchema.
+ * Provides autocomplete based on XSD schema.
+ */
+export function adaptObjectClass(xsd: XsdObjectClass): ObjectClassSchema {
+  // XSD uses 'attribute' (singular) for the array property
+  const attributes = (xsd as any).attribute || (xsd as any).attributes;
+  return {
+    name: xsd.name,
+    parent: (xsd as any).parent,
+    sharing: adaptSharingType(xsd.sharing),
+    semantics: (xsd as any).semantics,
+    attributes: attributes?.map(adaptAttribute),
+  };
+}
+
+/**
+ * Convert XSD InteractionClass to FomRegistry InteractionClassSchema.
+ * Provides autocomplete based on XSD schema.
+ */
+export function adaptInteractionClass(
+  xsd: XsdInteractionClass
+): InteractionClassSchema {
+  // XSD uses 'parameter' (singular) for the array property
+  const parameters = (xsd as any).parameter || (xsd as any).parameters;
+  return {
+    name: xsd.name,
+    parent: (xsd as any).parent,
+    sharing: adaptSharingType(xsd.sharing),
+    transportation: (xsd as any).transportation,
+    order: adaptOrderType(xsd.order),
+    semantics: (xsd as any).semantics,
+    parameters: parameters?.map(adaptParameter),
+  };
+}
+
+/**
+ * Convert XSD Attribute to FomRegistry AttributeSchema.
+ */
+function adaptAttribute(xsd: XsdAttribute): AttributeSchema {
+  return {
+    name: xsd.name,
+    dataType: xsd.dataType ?? "",
+    updateType: adaptUpdateType(xsd.updateType) ?? "NA",
+    updateCondition: xsd.updateCondition ?? "",
+    ownership: adaptOwnershipType(xsd.ownership) ?? "NoTransfer",
+    sharing: adaptSharingType(xsd.sharing) ?? "Neither",
+    transportation: xsd.transportation ?? "",
+    order: adaptOrderType(xsd.order) ?? "Receive",
+    semantics: xsd.semantics,
+    valueRequired: xsd.valueRequired === "true",
+  };
+}
+
+/**
+ * Convert XSD Parameter to FomRegistry ParameterSchema.
+ */
+function adaptParameter(xsd: XsdParameter): ParameterSchema {
+  return {
+    name: xsd.name,
+    dataType: xsd.dataType ?? "",
+    semantics: xsd.semantics,
+  };
+}
+
+/**
+ * Convert XSD SharingEnumeration to FomRegistry SharingType.
+ */
+function adaptSharingType(
+  sharing?: SharingEnumeration
+): "Publish" | "Subscribe" | "PublishSubscribe" | "Neither" | undefined {
+  if (!sharing) return undefined;
+  return sharing as "Publish" | "Subscribe" | "PublishSubscribe" | "Neither";
+}
+
+/**
+ * Convert XSD OrderEnumeration to FomRegistry OrderType.
+ */
+function adaptOrderType(
+  order?: OrderEnumeration
+): "Receive" | "TimeStamp" | undefined {
+  if (!order) return undefined;
+  return order as "Receive" | "TimeStamp";
+}
+
+/**
+ * Convert XSD UpdateEnumeration to FomRegistry UpdateType.
+ */
+function adaptUpdateType(
+  update?: UpdateEnumeration
+): "Static" | "Periodic" | "Conditional" | "NA" {
+  if (!update) return "NA";
+  return update as "Static" | "Periodic" | "Conditional" | "NA";
+}
+
+/**
+ * Convert XSD OwnershipEnumeration to FomRegistry OwnershipType.
+ */
+function adaptOwnershipType(
+  ownership?: OwnershipEnumeration
+): "Divest" | "Acquire" | "DivestAcquire" | "NoTransfer" {
+  if (!ownership) return "NoTransfer";
+  return ownership as "Divest" | "Acquire" | "DivestAcquire" | "NoTransfer";
+}
+
+/**
+ * Helper type that provides autocomplete for ModelIdentification using XSD types.
+ * Use this when you want XSD-based autocomplete:
+ *
+ * @example
+ * ```ts
+ * import { FomRegistry } from "@hla4ts/fom-codegen";
+ * import type { ModelIdentification } from "@hla4ts/fom-codegen/generated";
+ *
+ * const registry = new FomRegistry();
+ * const modelId: ModelIdentification = {
+ *   name: "MyFOM",
+ *   type: "FOM", // Autocomplete shows "FOM" | "SOM"
+ *   version: "1.0",
+ *   // ... other fields with autocomplete
+ * };
+ * registry.setModelIdentification(adaptModelIdentification(modelId));
+ * ```
+ */
+export type { XsdModelIdentification, XsdObjectClass, XsdInteractionClass };