@hla4ts/spacekit 0.1.0

package/src/declarative.ts

@@ -0,0 +1,254 @@
+import type {
+  AttributeSchema,
+  InteractionClassSchema,
+  ObjectClassSchema,
+  ParameterSchema,
+  SharingType,
+  OrderType,
+  UpdateType,
+  OwnershipType,
+} from "@hla4ts/fom-codegen";
+import { FomRegistry } from "@hla4ts/fom-codegen";
+import type { RTIAmbassador } from "@hla4ts/hla-api";
+import { InteractionClassAdapter, ObjectClassAdapter } from "./object-model.ts";
+
+export type DeclarativeAttribute<T> = AttributeSchema & {
+  encode: (value: T) => Uint8Array;
+  decode?: (data: Uint8Array) => T;
+};
+
+export interface DeclarativeObjectClass<T extends object> {
+  name: string;
+  parent?: string;
+  sharing?: SharingType;
+  semantics?: string;
+  attributes: {
+    [K in keyof T]: DeclarativeAttribute<T[K]>;
+  };
+}
+
+export type DeclarativeParameter<T> = ParameterSchema & {
+  encode: (value: T) => Uint8Array;
+  decode?: (data: Uint8Array) => T;
+};
+
+export interface DeclarativeInteractionClass<T extends object> {
+  name: string;
+  parent?: string;
+  sharing?: SharingType;
+  transportation?: string;
+  order?: OrderType;
+  semantics?: string;
+  parameters: {
+    [K in keyof T]: DeclarativeParameter<T[K]>;
+  };
+}
+
+export interface DeclarativeFomOptions {
+  registry?: FomRegistry;
+}
+
+export class DeclarativeFom {
+  readonly registry: FomRegistry;
+  private readonly _objectAdapters = new Map<string, ObjectClassAdapter<Record<string, unknown>>>();
+  private readonly _interactionAdapters = new Map<
+    string,
+    InteractionClassAdapter<Record<string, unknown>>
+  >();
+  private readonly _objectSchemas = new Map<string, DeclarativeObjectClass<Record<string, unknown>>>();
+  private readonly _interactionSchemas = new Map<
+    string,
+    DeclarativeInteractionClass<Record<string, unknown>>
+  >();
+
+  constructor(options: DeclarativeFomOptions = {}) {
+    this.registry = options.registry ?? new FomRegistry();
+  }
+
+  defineObjectClass<T extends object>(
+    schema: DeclarativeObjectClass<T>,
+    options: { register?: boolean } = {}
+  ): ObjectClassAdapter<T> {
+    const resolvedName = resolveHierarchicalName(schema.name, schema.parent);
+    const adapter = new ObjectClassAdapter<T>(resolvedName, mapDeclarativeAttributes(schema));
+    if (options.register !== false) {
+      this.registry.addObjectClass(toObjectClassSchema(schema));
+    }
+    this._objectAdapters.set(
+      resolvedName,
+      adapter as ObjectClassAdapter<Record<string, unknown>>
+    );
+    this._objectSchemas.set(
+      resolvedName,
+      schema as DeclarativeObjectClass<Record<string, unknown>>
+    );
+    return adapter;
+  }
+
+  defineInteractionClass<T extends object>(
+    schema: DeclarativeInteractionClass<T>,
+    options: { register?: boolean } = {}
+  ): InteractionClassAdapter<T> {
+    const resolvedName = resolveHierarchicalName(schema.name, schema.parent);
+    const adapter = new InteractionClassAdapter<T>(
+      resolvedName,
+      mapDeclarativeParameters(schema)
+    );
+    if (options.register !== false) {
+      this.registry.addInteractionClass(toInteractionClassSchema(schema));
+    }
+    this._interactionAdapters.set(
+      resolvedName,
+      adapter as InteractionClassAdapter<Record<string, unknown>>
+    );
+    this._interactionSchemas.set(
+      resolvedName,
+      schema as DeclarativeInteractionClass<Record<string, unknown>>
+    );
+    return adapter;
+  }
+
+  get objectAdapters(): ReadonlyMap<string, ObjectClassAdapter<Record<string, unknown>>> {
+    return this._objectAdapters;
+  }
+
+  get interactionAdapters(): ReadonlyMap<string, InteractionClassAdapter<Record<string, unknown>>> {
+    return this._interactionAdapters;
+  }
+
+  get objectSchemas(): ReadonlyMap<string, DeclarativeObjectClass<Record<string, unknown>>> {
+    return this._objectSchemas;
+  }
+
+  get interactionSchemas(): ReadonlyMap<string, DeclarativeInteractionClass<Record<string, unknown>>> {
+    return this._interactionSchemas;
+  }
+
+  getObjectAdapter<T extends object>(name: string): ObjectClassAdapter<T> | undefined {
+    return this._objectAdapters.get(name) as ObjectClassAdapter<T> | undefined;
+  }
+
+  getInteractionAdapter<T extends object>(name: string): InteractionClassAdapter<T> | undefined {
+    return this._interactionAdapters.get(name) as InteractionClassAdapter<T> | undefined;
+  }
+
+  getObjectSchema<T extends object>(name: string): DeclarativeObjectClass<T> | undefined {
+    return this._objectSchemas.get(name) as DeclarativeObjectClass<T> | undefined;
+  }
+
+  getInteractionSchema<T extends object>(
+    name: string
+  ): DeclarativeInteractionClass<T> | undefined {
+    return this._interactionSchemas.get(name) as DeclarativeInteractionClass<T> | undefined;
+  }
+
+  async resolveAll(rti: RTIAmbassador): Promise<void> {
+    for (const adapter of this._objectAdapters.values()) {
+      await adapter.resolve(rti);
+    }
+    for (const adapter of this._interactionAdapters.values()) {
+      await adapter.resolve(rti);
+    }
+  }
+
+  async publishAll(rti: RTIAmbassador): Promise<void> {
+    for (const adapter of this._objectAdapters.values()) {
+      await adapter.publish(rti);
+    }
+    for (const adapter of this._interactionAdapters.values()) {
+      await adapter.publish(rti);
+    }
+  }
+
+  async subscribeAll(rti: RTIAmbassador): Promise<void> {
+    for (const adapter of this._objectAdapters.values()) {
+      await adapter.subscribe(rti);
+    }
+    for (const adapter of this._interactionAdapters.values()) {
+      await adapter.subscribe(rti);
+    }
+  }
+}
+
+function resolveHierarchicalName(name: string, parent?: string): string {
+  if (name.includes(".")) return name;
+  if (!parent) return name;
+  return `${parent}.${name}`;
+}
+
+function mapDeclarativeAttributes<T extends object>(
+  schema: DeclarativeObjectClass<T>
+): { [K in keyof T]: { name: string; encode: (value: T[K]) => Uint8Array; decode?: (data: Uint8Array) => T[K] } } {
+  const entries = Object.entries(schema.attributes) as Array<
+    [keyof T, DeclarativeAttribute<T[keyof T]>]
+  >;
+  const result: Record<string, { name: string; encode: (value: unknown) => Uint8Array; decode?: (data: Uint8Array) => unknown }> = {};
+  for (const [key, attribute] of entries) {
+    result[key as string] = {
+      name: attribute.name,
+      encode: attribute.encode as (value: unknown) => Uint8Array,
+      decode: attribute.decode as ((data: Uint8Array) => unknown) | undefined,
+    };
+  }
+  return result as { [K in keyof T]: { name: string; encode: (value: T[K]) => Uint8Array; decode?: (data: Uint8Array) => T[K] } };
+}
+
+function mapDeclarativeParameters<T extends object>(
+  schema: DeclarativeInteractionClass<T>
+): { [K in keyof T]: { name: string; encode: (value: T[K]) => Uint8Array; decode?: (data: Uint8Array) => T[K] } } {
+  const entries = Object.entries(schema.parameters) as Array<
+    [keyof T, DeclarativeParameter<T[keyof T]>]
+  >;
+  const result: Record<string, { name: string; encode: (value: unknown) => Uint8Array; decode?: (data: Uint8Array) => unknown }> = {};
+  for (const [key, parameter] of entries) {
+    result[key as string] = {
+      name: parameter.name,
+      encode: parameter.encode as (value: unknown) => Uint8Array,
+      decode: parameter.decode as ((data: Uint8Array) => unknown) | undefined,
+    };
+  }
+  return result as { [K in keyof T]: { name: string; encode: (value: T[K]) => Uint8Array; decode?: (data: Uint8Array) => T[K] } };
+}
+
+function toObjectClassSchema<T extends object>(schema: DeclarativeObjectClass<T>): ObjectClassSchema {
+  return {
+    name: schema.name,
+    parent: schema.parent,
+    sharing: schema.sharing,
+    semantics: schema.semantics,
+    attributes: (Object.values(schema.attributes) as DeclarativeAttribute<unknown>[]).map(
+      (attribute) => ({
+      name: attribute.name,
+      dataType: attribute.dataType,
+      updateType: attribute.updateType as UpdateType,
+      updateCondition: attribute.updateCondition,
+      ownership: attribute.ownership as OwnershipType,
+      sharing: attribute.sharing,
+      transportation: attribute.transportation,
+      order: attribute.order,
+      semantics: attribute.semantics,
+      valueRequired: attribute.valueRequired,
+    })
+    ),
+  };
+}
+
+function toInteractionClassSchema<T extends object>(
+  schema: DeclarativeInteractionClass<T>
+): InteractionClassSchema {
+  return {
+    name: schema.name,
+    parent: schema.parent,
+    sharing: schema.sharing,
+    transportation: schema.transportation,
+    order: schema.order,
+    semantics: schema.semantics,
+    parameters: (Object.values(schema.parameters) as DeclarativeParameter<unknown>[]).map(
+      (parameter) => ({
+      name: parameter.name,
+      dataType: parameter.dataType,
+      semantics: parameter.semantics,
+    })
+    ),
+  };
+}

package/src/declare-spacefom.ts

@@ -0,0 +1,14 @@
+import { buildDeclarativeFomFromDecorators, type FomClassConstructor } from "./decorators.ts";
+import type { DeclarativeFom } from "./declarative.ts";
+
+export interface DeclareSpaceFomOptions {
+  objectClasses?: FomClassConstructor[];
+  interactionClasses?: FomClassConstructor[];
+}
+
+export function declareSpaceFom(options: DeclareSpaceFomOptions = {}): DeclarativeFom {
+  return buildDeclarativeFomFromDecorators({
+    objectClasses: options.objectClasses ?? [],
+    interactionClasses: options.interactionClasses ?? [],
+  });
+}

package/src/decorators.test.ts

@@ -0,0 +1,133 @@
+import { expect, test } from "bun:test";
+import {
+  FomAttribute,
+  FomInteractionClass,
+  FomObjectClass,
+  FomParameter,
+  buildDeclarativeFomFromDecorators,
+  getDecoratedInteractionClassMetadata,
+  getDecoratedObjectClassMetadata,
+} from "./decorators.ts";
+
+class TestObject {
+  name = "";
+  count = 0;
+}
+
+class TestInteraction {
+  message = "";
+}
+
+test("decorator metadata produces declarative schemas", () => {
+  FomObjectClass({ name: "HLAobjectRoot.TestObject", sharing: "PublishSubscribe" })(
+    TestObject
+  );
+  FomAttribute({
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: (value: string) => new TextEncoder().encode(value),
+  })(TestObject.prototype, "name");
+  FomAttribute({
+    dataType: "HLAinteger32BE",
+    updateType: "Periodic",
+    updateCondition: "when changed",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: (value: number) => {
+      const buffer = new ArrayBuffer(4);
+      const view = new DataView(buffer);
+      view.setInt32(0, value, false);
+      return new Uint8Array(buffer);
+    },
+  })(TestObject.prototype, "count");
+
+  FomInteractionClass({
+    name: "HLAinteractionRoot.TestInteraction",
+    sharing: "PublishSubscribe",
+  })(TestInteraction);
+  FomParameter({
+    dataType: "HLAunicodeString",
+    encode: (value: string) => new TextEncoder().encode(value),
+  })(TestInteraction.prototype, "message");
+
+  const declarative = buildDeclarativeFomFromDecorators({
+    objectClasses: [TestObject],
+    interactionClasses: [TestInteraction],
+  });
+
+  const objectSchema = declarative.getObjectSchema<{ name: string; count: number }>(
+    "HLAobjectRoot.TestObject"
+  );
+  expect(objectSchema?.attributes.name?.dataType).toBe("HLAunicodeString");
+  expect(objectSchema?.attributes.count?.dataType).toBe("HLAinteger32BE");
+
+  const interactionSchema = declarative.getInteractionSchema<{ message: string }>(
+    "HLAinteractionRoot.TestInteraction"
+  );
+  expect(interactionSchema?.parameters.message?.dataType).toBe("HLAunicodeString");
+
+  const objectMeta = getDecoratedObjectClassMetadata(TestObject);
+  expect(objectMeta?.name).toBe("HLAobjectRoot.TestObject");
+  expect(objectMeta?.attributes?.[0]?.name).toBe("name");
+
+  const interactionMeta = getDecoratedInteractionClassMetadata(TestInteraction);
+  expect(interactionMeta?.name).toBe("HLAinteractionRoot.TestInteraction");
+  expect(interactionMeta?.parameters?.[0]?.name).toBe("message");
+});
+
+class BaseEntity {
+  base = "";
+}
+
+class ExtendedEntity extends BaseEntity {
+  extra = 0;
+}
+
+test("decorator metadata merges inheritance for object classes", () => {
+  FomObjectClass({ name: "HLAobjectRoot.BaseEntity", sharing: "PublishSubscribe" })(BaseEntity);
+  FomAttribute({
+    dataType: "HLAunicodeString",
+    updateType: "Static",
+    updateCondition: "during initialization",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: (value: string) => new TextEncoder().encode(value),
+  })(BaseEntity.prototype, "base");
+
+  FomObjectClass({ name: "HLAobjectRoot.BaseEntity.ExtendedEntity" })(ExtendedEntity);
+  FomAttribute({
+    dataType: "HLAinteger32BE",
+    updateType: "Periodic",
+    updateCondition: "when changed",
+    ownership: "NoTransfer",
+    sharing: "PublishSubscribe",
+    transportation: "HLAreliable",
+    order: "TimeStamp",
+    encode: (value: number) => {
+      const buffer = new ArrayBuffer(4);
+      const view = new DataView(buffer);
+      view.setInt32(0, value, false);
+      return new Uint8Array(buffer);
+    },
+  })(ExtendedEntity.prototype, "extra");
+
+  const declarative = buildDeclarativeFomFromDecorators({
+    objectClasses: [ExtendedEntity],
+  });
+
+  const schema = declarative.getObjectSchema<{ base: string; extra: number }>(
+    "HLAobjectRoot.BaseEntity.ExtendedEntity"
+  );
+  expect(schema?.parent).toBe("HLAobjectRoot.BaseEntity");
+  expect(schema?.attributes.base?.dataType).toBe("HLAunicodeString");
+  expect(schema?.attributes.extra?.dataType).toBe("HLAinteger32BE");
+});