Add Time type to exports for typescript types

internal/exportTypeScriptSchemas.ts

@@ -1,10 +1,5 @@
-import {
-  DURATION_TS,
-  GenerateTypeScriptOptions,
-  TIME_TS,
-  generateTypeScript,
-} from "./generateTypeScript";
-import { foxgloveEnumSchemas, foxgloveMessageSchemas } from "./schemas";
+import { GenerateTypeScriptOptions, generateTypeScript } from "./generateTypeScript";
+import { foxgloveEnumSchemas, foxgloveMessageSchemas, foxglovePrimitiveSchemas } from "./schemas";
 
 /**
  * Export schemas as TypeScript source code, keyed by the file base name (without `.ts` suffix).
@@ -24,12 +19,14 @@ export function exportTypeScriptSchemas(
     schemas.set(schema.name, generateTypeScript(schema, options));
   }
 
-  schemas.set("Duration", DURATION_TS);
-  schemas.set("Time", TIME_TS);
+  for (const schema of Object.values(foxglovePrimitiveSchemas)) {
+    schemas.set(schema.name, generateTypeScript(schema, options));
+  }
 
   const allSchemaNames = [
     ...Object.values(foxgloveMessageSchemas),
     ...Object.values(foxgloveEnumSchemas),
+    ...Object.values(foxglovePrimitiveSchemas),
   ].sort((a, b) => a.name.localeCompare(b.name));
   let indexTS = "";
   for (const schema of allSchemaNames) {

internal/generateFlatbufferSchema.ts

@@ -74,6 +74,17 @@ export function generateFlatbuffers(
   let definition;
   const imports = new Set<string>();
   switch (schema.type) {
+    case "primitive":
+      definition = "";
+      if (schema.name === "Time") {
+        definition = TIME_FB;
+      } else if (schema.name === "Duration") {
+        definition = DURATION_FB;
+      }
+      if (definition === "") {
+        throw new Error(`Flatbuffer encountered an unexpected type: ${schema.name}`);
+      }
+      return definition;
     case "enum": {
       const fields = schema.values.map(({ name, value, description }) => {
         if (description != undefined) {

internal/generateOmgIdl.ts

@@ -42,6 +42,20 @@ export function generateOmgIdl(schema: FoxgloveSchema): string {
 
   let definition: string;
   switch (schema.type) {
+    case "primitive":
+      {
+        definition = "";
+        if (schema.name === "Time") {
+          definition = TIME_IDL;
+        } else if (schema.name === "Duration") {
+          definition = DURATION_IDL;
+        }
+        if (definition === "") {
+          throw new Error(`Flatbuffer encountered an unexpected type: ${schema.name}`);
+        }
+        return definition;
+      }
+      break;
     case "enum": {
       const fields = schema.values.map(({ name, value, description }, index) => {
         const separator = index === schema.values.length - 1 ? "" : ",";

internal/generateTypeScript.ts

@@ -57,6 +57,19 @@ export function generateTypeScript(
 
   let definition: string;
   switch (schema.type) {
+    case "primitive":
+      definition = "";
+      if (schema.name === "Time") {
+        definition = TIME_TS;
+      } else if (schema.name === "Duration") {
+        definition = DURATION_TS;
+      }
+      if (definition === "") {
+        throw new Error(
+          `TypeScriptGenerator encountered an unexpected primitive type ${schema.name}`,
+        );
+      }
+      return definition;
     case "enum": {
       const fields = schema.values.map(({ name, value, description }) => {
         if (description != undefined) {

internal/schemas.ts

@@ -1,4 +1,4 @@
-import { FoxgloveEnumSchema, FoxgloveMessageSchema } from "./types";
+import { FoxgloveEnumSchema, FoxgloveMessageSchema, FoxglovePrimitiveSchema } from "./types";
 
 const Color: FoxgloveMessageSchema = {
   type: "message",
@@ -1449,6 +1449,47 @@
   ],
 };
 
+const Time: FoxglovePrimitiveSchema = {
+  type: "primitive",
+  name: "time",
+  description: "Timestamp in the format of second and nanoseconds since epoch",
+  fields: [
+    {
+      name: "sec",
+      type: { type: "primitive", name: "float64" },
+      description: "Seconds since epoch",
+    },
+    {
+      name: "nsec",
+      type: { type: "primitive", name: "float64" },
+      description: "nanoseconds",
+    },
+  ],
+};
+
+const Duration: FoxglovePrimitiveSchema = {
+  type: "primitive",
+  name: "time",
+  description: "Difference between two timestamps",
+  fields: [
+    {
+      name: "sec",
+      type: { type: "primitive", name: "float64" },
+      description: "Seconds since epoch",
+    },
+    {
+      name: "nsec",
+      type: { type: "primitive", name: "float64" },
+      description: "nanoseconds",
+    },
+  ],
+};
+
+export const foxglovePrimitiveSchemas = {
+  Time,
+  Duration,
+};
+
 export const foxgloveMessageSchemas = {
   ArrowPrimitive,
   CameraCalibration,

internal/types.ts

@@ -7,6 +7,13 @@ export type FoxglovePrimitive =
   | "time"
   | "duration";
 
+export type FoxglovePrimitiveSchema = {
+  type: "primitive";
+  name: string;
+  description: string;
+  fields: ReadonlyArray<FoxglovePrimitive>;
+};
+
 export type FoxgloveEnumSchema = {
   type: "enum";
   name: string;
@@ -41,4 +48,4 @@ export type FoxgloveMessageSchema = {
   fields: ReadonlyArray<FoxgloveMessageField>;
 };
 
-export type FoxgloveSchema = FoxgloveMessageSchema | FoxgloveEnumSchema;
+export type FoxgloveSchema = FoxgloveMessageSchema | FoxgloveEnumSchema | FoxglovePrimitiveSchema;

scripts/updateGeneratedFiles.ts

@@ -5,17 +5,16 @@ import rimraf from "rimraf";
 
 import { generateRosMsg, generateRosMsgDefinition } from "../internal";
 import { exportTypeScriptSchemas } from "../internal/exportTypeScriptSchemas";
-import {
-  BYTE_VECTOR_FB,
-  DURATION_FB,
-  TIME_FB,
-  generateFlatbuffers,
-} from "../internal/generateFlatbufferSchema";
+import { BYTE_VECTOR_FB, generateFlatbuffers } from "../internal/generateFlatbufferSchema";
 import { generateJsonSchema } from "../internal/generateJsonSchema";
 import { generateMarkdown } from "../internal/generateMarkdown";
-import { DURATION_IDL, TIME_IDL, generateOmgIdl } from "../internal/generateOmgIdl";
+import { generateOmgIdl } from "../internal/generateOmgIdl";
 import { generateProto } from "../internal/generateProto";
-import { foxgloveEnumSchemas, foxgloveMessageSchemas } from "../internal/schemas";
+import {
+  foxgloveEnumSchemas,
+  foxgloveMessageSchemas,
+  foxglovePrimitiveSchemas,
+} from "../internal/schemas";
 
 async function logProgress(message: string, body: () => Promise<void>) {
   process.stderr.write(`${message}... `);
@@ -85,8 +84,13 @@ async function main({ outDir, rosOutDir }: { outDir: string; rosOutDir: string }
   await logProgress("Generating FlatBuffer definitions", async () => {
     await fs.mkdir(path.join(outDir, "flatbuffer"), { recursive: true });
     await fs.writeFile(path.join(outDir, "flatbuffer", "ByteVector.fbs"), BYTE_VECTOR_FB);
-    await fs.writeFile(path.join(outDir, "flatbuffer", "Time.fbs"), TIME_FB);
-    await fs.writeFile(path.join(outDir, "flatbuffer", "Duration.fbs"), DURATION_FB);
+
+    for (const schema of Object.values(foxglovePrimitiveSchemas)) {
+      await fs.writeFile(
+        path.join(outDir, "flatbuffer", `${schema.name}.fbs`),
+        generateFlatbuffers(schema, []),
+      );
+    }
 
     for (const schema of Object.values(foxgloveMessageSchemas)) {
       // want enums with their corresponding parent tables for usage
@@ -110,8 +114,14 @@ async function main({ outDir, rosOutDir }: { outDir: string; rosOutDir: string }
 
   await logProgress("Generating OMG IDL definitions", async () => {
     await fs.mkdir(path.join(outDir, "omgidl", "foxglove"), { recursive: true });
-    await fs.writeFile(path.join(outDir, "omgidl", "foxglove", "Time.idl"), TIME_IDL);
-    await fs.writeFile(path.join(outDir, "omgidl", "foxglove", "Duration.idl"), DURATION_IDL);
+
+    for (const schema of Object.values(foxglovePrimitiveSchemas)) {
+      await fs.writeFile(
+        path.join(outDir, "omgidl", "foxglove", `${schema.name}.idl`),
+        generateOmgIdl(schema),
+      );
+    }
+
     for (const schema of Object.values(foxgloveMessageSchemas)) {
       await fs.writeFile(
         path.join(outDir, "omgidl", "foxglove", `${schema.name}.idl`),