@rise-maritime/keelson-js 0.5.1 → 0.5.3

package/dist/interfaces/VehicleParam.js

@@ -5,10 +5,12 @@
 //   protoc               v6.30.2
 // source: VehicleParam.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehicleParamClientImpl = exports.VehicleParamServiceName = exports.ParamSetBulkResponse = exports.ParamSetBulkResult = exports.ParamSetBulkRequest = exports.ParamListResponse = exports.ParamValueResponse = exports.ParamSetRequest = exports.ParamGetRequest = exports.protobufPackage = void 0;
+exports.VehicleParamClientImpl = exports.VehicleParamServiceName = exports.SaveParamsResponse = exports.SaveParamsRequest = exports.ParamSetBulkResponse = exports.ParamSetBulkResult = exports.ParamSetBulkRequest = exports.ParamListResponse = exports.ParamValueResponse = exports.ParamSetRequest = exports.ParamGetRequest = exports.protobufPackage = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
+const VehicleCommon_1 = require("./VehicleCommon");
 const empty_1 = require("./google/protobuf/empty");
+const timestamp_1 = require("./google/protobuf/timestamp");
 exports.protobufPackage = "";
 function createBaseParamGetRequest() {
     return { name: "" };
@@ -490,6 +492,140 @@ exports.ParamSetBulkResponse = {
         return message;
     },
 };
+function createBaseSaveParamsRequest() {
+    return { timestamp: undefined };
+}
+exports.SaveParamsRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.timestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSaveParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SaveParamsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSaveParamsRequest();
+        message.timestamp = object.timestamp ?? undefined;
+        return message;
+    },
+};
+function createBaseSaveParamsResponse() {
+    return { result: 0, rawAutopilotResult: 0, detail: "" };
+}
+exports.SaveParamsResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.result !== 0) {
+            writer.uint32(8).int32(message.result);
+        }
+        if (message.rawAutopilotResult !== 0) {
+            writer.uint32(16).int32(message.rawAutopilotResult);
+        }
+        if (message.detail !== "") {
+            writer.uint32(26).string(message.detail);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSaveParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.result = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.rawAutopilotResult = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.detail = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            result: isSet(object.result) ? (0, VehicleCommon_1.commandResultFromJSON)(object.result) : 0,
+            rawAutopilotResult: isSet(object.rawAutopilotResult) ? globalThis.Number(object.rawAutopilotResult) : 0,
+            detail: isSet(object.detail) ? globalThis.String(object.detail) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.result !== 0) {
+            obj.result = (0, VehicleCommon_1.commandResultToJSON)(message.result);
+        }
+        if (message.rawAutopilotResult !== 0) {
+            obj.rawAutopilotResult = Math.round(message.rawAutopilotResult);
+        }
+        if (message.detail !== "") {
+            obj.detail = message.detail;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SaveParamsResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSaveParamsResponse();
+        message.result = object.result ?? 0;
+        message.rawAutopilotResult = object.rawAutopilotResult ?? 0;
+        message.detail = object.detail ?? "";
+        return message;
+    },
+};
 exports.VehicleParamServiceName = "VehicleParam";
 class VehicleParamClientImpl {
     constructor(rpc, opts) {
@@ -499,6 +635,7 @@ class VehicleParamClientImpl {
         this.set_param = this.set_param.bind(this);
         this.list_params = this.list_params.bind(this);
         this.set_params = this.set_params.bind(this);
+        this.save_params = this.save_params.bind(this);
     }
     get_param(request) {
         const data = exports.ParamGetRequest.encode(request).finish();
@@ -520,8 +657,34 @@ class VehicleParamClientImpl {
         const promise = this.rpc.request(this.service, "set_params", data);
         return promise.then((data) => exports.ParamSetBulkResponse.decode(new wire_1.BinaryReader(data)));
     }
+    save_params(request) {
+        const data = exports.SaveParamsRequest.encode(request).finish();
+        const promise = this.rpc.request(this.service, "save_params", data);
+        return promise.then((data) => exports.SaveParamsResponse.decode(new wire_1.BinaryReader(data)));
+    }
 }
 exports.VehicleParamClientImpl = VehicleParamClientImpl;
+function toTimestamp(date) {
+    const seconds = Math.trunc(date.getTime() / 1000);
+    const nanos = (date.getTime() % 1000) * 1000000;
+    return { seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds || 0) * 1000;
+    millis += (t.nanos || 0) / 1000000;
+    return new globalThis.Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof globalThis.Date) {
+        return o;
+    }
+    else if (typeof o === "string") {
+        return new globalThis.Date(o);
+    }
+    else {
+        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
+    }
+}
 function isSet(value) {
     return value !== null && value !== undefined;
 }

package/dist/payloads/Primitives.d.ts

@@ -52,6 +52,16 @@ export interface TimestampedQuaternion {
     /** Quaternion is defined in foxglove/Quaternion.proto */
     value: Quaternion | undefined;
 }
+/**
+ * Anchors a scalar value to an end-of-interval timestamp plus the interval duration.
+ * Use for windowed aggregates such as max wind speed over a 10-minute window.
+ */
+export interface TimestampedFloatPeriod {
+    $type: "keelson.TimestampedFloatPeriod";
+    timestamp: Date | undefined;
+    value: number;
+    period: Duration | undefined;
+}
 export declare const TimestampedBytes: MessageFns<TimestampedBytes, "keelson.TimestampedBytes">;
 export declare const TimestampedDouble: MessageFns<TimestampedDouble, "keelson.TimestampedDouble">;
 export declare const TimestampedFloat: MessageFns<TimestampedFloat, "keelson.TimestampedFloat">;
@@ -62,6 +72,7 @@ export declare const TimestampedBool: MessageFns<TimestampedBool, "keelson.Times
 export declare const TimestampedDuration: MessageFns<TimestampedDuration, "keelson.TimestampedDuration">;
 export declare const TimestampedTimestamp: MessageFns<TimestampedTimestamp, "keelson.TimestampedTimestamp">;
 export declare const TimestampedQuaternion: MessageFns<TimestampedQuaternion, "keelson.TimestampedQuaternion">;
+export declare const TimestampedFloatPeriod: MessageFns<TimestampedFloatPeriod, "keelson.TimestampedFloatPeriod">;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;

package/dist/payloads/Primitives.js

@@ -5,7 +5,7 @@
 //   protoc               v6.30.2
 // source: Primitives.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimestampedQuaternion = exports.TimestampedTimestamp = exports.TimestampedDuration = exports.TimestampedBool = exports.TimestampedString = exports.TimestampedInt64 = exports.TimestampedInt = exports.TimestampedFloat = exports.TimestampedDouble = exports.TimestampedBytes = void 0;
+exports.TimestampedFloatPeriod = exports.TimestampedQuaternion = exports.TimestampedTimestamp = exports.TimestampedDuration = exports.TimestampedBool = exports.TimestampedString = exports.TimestampedInt64 = exports.TimestampedInt = exports.TimestampedFloat = exports.TimestampedDouble = exports.TimestampedBytes = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const Quaternion_1 = require("./foxglove/Quaternion");
@@ -726,6 +726,94 @@ exports.TimestampedQuaternion = {
     },
 };
 typeRegistry_1.messageTypeRegistry.set(exports.TimestampedQuaternion.$type, exports.TimestampedQuaternion);
+function createBaseTimestampedFloatPeriod() {
+    return { $type: "keelson.TimestampedFloatPeriod", timestamp: undefined, value: 0, period: undefined };
+}
+exports.TimestampedFloatPeriod = {
+    $type: "keelson.TimestampedFloatPeriod",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.timestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).join();
+        }
+        if (message.value !== 0) {
+            writer.uint32(21).float(message.value);
+        }
+        if (message.period !== undefined) {
+            duration_1.Duration.encode(message.period, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTimestampedFloatPeriod();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.value = reader.float();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.period = duration_1.Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.TimestampedFloatPeriod.$type,
+            timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+            value: isSet(object.value) ? globalThis.Number(object.value) : 0,
+            period: isSet(object.period) ? duration_1.Duration.fromJSON(object.period) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.timestamp !== undefined) {
+            obj.timestamp = message.timestamp.toISOString();
+        }
+        if (message.value !== 0) {
+            obj.value = message.value;
+        }
+        if (message.period !== undefined) {
+            obj.period = duration_1.Duration.toJSON(message.period);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TimestampedFloatPeriod.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimestampedFloatPeriod();
+        message.timestamp = object.timestamp ?? undefined;
+        message.value = object.value ?? 0;
+        message.period = (object.period !== undefined && object.period !== null)
+            ? duration_1.Duration.fromPartial(object.period)
+            : undefined;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.TimestampedFloatPeriod.$type, exports.TimestampedFloatPeriod);
 function bytesFromBase64(b64) {
     if (globalThis.Buffer) {
         return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));

package/dist/payloads/ReplayStatus.d.ts

@@ -0,0 +1,76 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+/**
+ * Identifies the replay daemon producing this status. Static across the
+ * daemon's lifetime; populated on every sample so clients can discover and
+ * label replayers via the broadcast alone (no separate RPC needed).
+ */
+export interface DaemonInfo {
+    $type: "keelson.DaemonInfo";
+    /** keelson SDK version, e.g. "0.5.1" */
+    version: string;
+    hostname: string;
+    startedAt: Date | undefined;
+    baseDirectory: string;
+}
+export interface ReplayStatus {
+    $type: "keelson.ReplayStatus";
+    state: ReplayStatus_State;
+    /** Current playhead position in the loaded file. */
+    currentTime: Date | undefined;
+    /** Start and end timestamps of the loaded file. */
+    startTime: Date | undefined;
+    endTime: Date | undefined;
+    /** Playback speed multiplier (1.0 = real time). */
+    playbackSpeed: number;
+    /** Path of the currently loaded MCAP file, or empty if none loaded. */
+    loadedFile: string;
+    /** Number of messages already emitted since the file was loaded. */
+    playedMessageCount: number;
+    /** Total number of messages in the loaded file. */
+    totalMessageCount: number;
+    /** Progress through the file as a percentage in [0.0, 100.0]. */
+    progressPct: number;
+    /** Whether the replayer is configured to loop on end-of-file. */
+    loop: boolean;
+    /** Identification of the daemon producing this sample. See DaemonInfo above. */
+    daemon: DaemonInfo | undefined;
+    /** Progress of an in-flight load_file, 0..100. Zero outside of LOADING. */
+    loadProgressPct: number;
+    /**
+     * Most-recent load_file failure, surfaced through the broadcast because
+     * the RPC reply has already returned OK by the time the worker fails.
+     * Cleared on a successful load. Empty if the most recent load succeeded.
+     */
+    lastLoadError: string;
+}
+export declare enum ReplayStatus_State {
+    STOPPED = 0,
+    PLAYING = 1,
+    PAUSED = 2,
+    LOADING = 3,
+    UNRECOGNIZED = -1
+}
+export declare function replayStatus_StateFromJSON(object: any): ReplayStatus_State;
+export declare function replayStatus_StateToJSON(object: ReplayStatus_State): string;
+export declare const DaemonInfo: MessageFns<DaemonInfo, "keelson.DaemonInfo">;
+export declare const ReplayStatus: MessageFns<ReplayStatus, "keelson.ReplayStatus">;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never;
+};
+interface MessageFns<T, V extends string> {
+    readonly $type: V;
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};