worldorbit 3.2.2 → 5.0.0

package/dist/browser/core/dist/schema.js

@@ -7,6 +7,7 @@ const ALL_OBJECTS = [
     "asteroid",
     "comet",
     "ring",
+    "craft",
     "structure",
     "phenomenon",
 ];
@@ -17,10 +18,11 @@ const IMAGE_OBJECTS = [
     "moon",
     "asteroid",
     "comet",
+    "craft",
     "structure",
     "phenomenon",
 ];
-const ANCHORED_OBJECTS = ["structure", "phenomenon"];
+const ANCHORED_OBJECTS = ["craft", "structure", "phenomenon"];
 const ORBITAL_OBJECTS = [
     "star",
     "planet",
@@ -29,6 +31,7 @@ const ORBITAL_OBJECTS = [
     "asteroid",
     "comet",
     "ring",
+    "craft",
     "structure",
     "phenomenon",
 ];
@@ -40,6 +43,7 @@ const FREE_OBJECTS = [
     "asteroid",
     "comet",
     "ring",
+    "craft",
     "structure",
     "phenomenon",
 ];
@@ -269,6 +273,12 @@ export const WORLDORBIT_FIELD_SCHEMAS = new Map([
         objectTypes: NON_SYSTEM_OBJECTS,
         unitFamily: "duration",
     }),
+    createField("trajectory", {
+        kind: "string",
+        placement: false,
+        arity: "single",
+        objectTypes: ["craft", "structure"],
+    }),
 ].map((schema) => [schema.key, schema]));
 export const WORLDORBIT_FIELD_KEYS = new Set(WORLDORBIT_FIELD_SCHEMAS.keys());
 export function getFieldSchema(key) {

package/dist/browser/core/dist/solver.d.ts

@@ -0,0 +1,33 @@
+import type { SceneRenderOptions, SpatialTrajectory, UnitValue, WorldOrbitDocument, WorldOrbitTrajectory, WorldOrbitTrajectorySegment } from "./types.js";
+export interface SolverSegmentSample {
+    segmentId: string;
+    kind: WorldOrbitTrajectorySegment["kind"];
+    fromObjectId: string | null;
+    toObjectId: string | null;
+    aroundObjectId: string | null;
+    assistObjectId: string | null;
+    duration: UnitValue | null;
+    deltaV: UnitValue | null;
+}
+export interface SolverManeuverSample {
+    segmentId: string;
+    maneuverId: string;
+    kind: string;
+    epoch: string | null;
+    deltaV: UnitValue | null;
+    duration: UnitValue | null;
+}
+export interface SolverTrajectorySnapshot {
+    trajectoryId: string;
+    craftObjectId: string | null;
+    segments: SolverSegmentSample[];
+    maneuvers: SolverManeuverSample[];
+}
+export interface TrajectorySamplingOptions extends Pick<SceneRenderOptions, "width" | "height" | "padding" | "preset" | "projection" | "camera" | "scaleModel" | "bodyScaleMode"> {
+    trajectoryMode?: "illustrative" | "solver" | "auto";
+    showTrajectoryWaypoints?: boolean;
+    showTrajectoryLabels?: boolean;
+}
+export declare function createTrajectorySolverSnapshot(trajectory: WorldOrbitTrajectory): SolverTrajectorySnapshot;
+export declare function sampleTrajectory(trajectory: WorldOrbitTrajectory, document: WorldOrbitDocument, options?: TrajectorySamplingOptions): SpatialTrajectory | null;
+export declare function sampleDocumentTrajectories(document: WorldOrbitDocument, options?: TrajectorySamplingOptions): SpatialTrajectory[];

package/dist/browser/core/dist/solver.js

@@ -0,0 +1,99 @@
+import { renderDocumentToScene } from "./scene.js";
+export function createTrajectorySolverSnapshot(trajectory) {
+    return {
+        trajectoryId: trajectory.id,
+        craftObjectId: trajectory.craftObjectId,
+        segments: trajectory.segments.map((segment) => ({
+            segmentId: segment.id,
+            kind: segment.kind,
+            fromObjectId: segment.fromObjectId,
+            toObjectId: segment.toObjectId,
+            aroundObjectId: segment.aroundObjectId,
+            assistObjectId: segment.assist?.objectId ?? null,
+            duration: segment.duration ?? null,
+            deltaV: segment.deltaV ?? null,
+        })),
+        maneuvers: trajectory.segments.flatMap((segment) => segment.maneuvers.map((maneuver) => mapManeuver(segment.id, maneuver))),
+    };
+}
+export function sampleTrajectory(trajectory, document, options = {}) {
+    const scene = renderDocumentToScene(document, {
+        ...options,
+        trajectoryMode: options.trajectoryMode ?? trajectory.renderMode ?? "auto",
+        showTrajectoryWaypoints: options.showTrajectoryWaypoints ?? true,
+        showTrajectoryLabels: options.showTrajectoryLabels ?? true,
+    });
+    const rendered = scene.trajectories.find((entry) => entry.trajectoryId === trajectory.id);
+    return rendered ? mapRenderTrajectoryToSpatial(rendered) : null;
+}
+export function sampleDocumentTrajectories(document, options = {}) {
+    const scene = renderDocumentToScene(document, {
+        ...options,
+        trajectoryMode: options.trajectoryMode ?? "auto",
+        showTrajectoryWaypoints: options.showTrajectoryWaypoints ?? true,
+        showTrajectoryLabels: options.showTrajectoryLabels ?? true,
+    });
+    return scene.trajectories.map(mapRenderTrajectoryToSpatial);
+}
+function mapRenderTrajectoryToSpatial(trajectory) {
+    return {
+        trajectoryId: trajectory.trajectoryId,
+        trajectory: trajectory.trajectory,
+        craftObjectId: trajectory.craftObjectId,
+        mode: trajectory.mode,
+        stroke: trajectory.stroke,
+        strokeWidth: trajectory.strokeWidth,
+        marker: trajectory.marker,
+        labelMode: trajectory.labelMode,
+        showWaypoints: trajectory.showWaypoints,
+        samples: samplePathPoints(trajectory.path).map((point) => ({
+            x: point.x,
+            y: 0,
+            z: point.y,
+        })),
+        waypoints: trajectory.waypoints.map((waypoint) => ({
+            trajectoryId: waypoint.trajectoryId,
+            segmentId: waypoint.segmentId,
+            maneuverId: waypoint.maneuverId,
+            objectId: waypoint.objectId,
+            position: {
+                x: waypoint.x,
+                y: 0,
+                z: waypoint.y,
+            },
+            label: waypoint.label,
+            dateLabel: waypoint.dateLabel,
+            hidden: waypoint.hidden,
+        })),
+        hidden: trajectory.hidden,
+    };
+}
+function mapManeuver(segmentId, maneuver) {
+    return {
+        segmentId,
+        maneuverId: maneuver.id,
+        kind: maneuver.kind,
+        epoch: maneuver.epoch,
+        deltaV: maneuver.deltaV ?? null,
+        duration: maneuver.duration ?? null,
+    };
+}
+function samplePathPoints(path) {
+    const matches = [...path.matchAll(/[MLQ]\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?/g)];
+    if (matches.length === 0) {
+        return [];
+    }
+    const points = [];
+    for (const match of matches) {
+        const command = match[0][0];
+        if (command === "M" || command === "L") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            continue;
+        }
+        if (command === "Q") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            points.push({ x: Number(match[5]), y: Number(match[6]) });
+        }
+    }
+    return points;
+}

package/dist/browser/core/dist/spatial-scene.js

@@ -36,6 +36,7 @@ export function renderDocumentToSpatialScene(document, options = {}) {
     const spatialObjects = scene.objects.map((entry) => createSpatialObject(entry, scene, sceneCenter, objectMap, orbitMap, scaleModel, positionCache, minimumMotionMetric));
     const spatialObjectMap = new Map(spatialObjects.map((object) => [object.objectId, object]));
     const spatialOrbits = scene.orbitVisuals.map((orbit) => createSpatialOrbit(orbit, spatialObjectMap, minimumMotionMetric, scene.activeEventId !== null));
+    const spatialTrajectories = scene.trajectories.map((trajectory) => createSpatialTrajectory(trajectory, spatialObjectMap));
     const focusTargets = spatialObjects.map((object) => ({
         objectId: object.objectId,
         center: { ...object.position },
@@ -65,6 +66,7 @@ export function renderDocumentToSpatialScene(document, options = {}) {
         timeFrozen: scene.activeEventId !== null,
         objects: spatialObjects,
         orbits: spatialOrbits,
+        trajectories: spatialTrajectories,
         focusTargets,
     };
 }
@@ -117,6 +119,41 @@ function createSpatialOrbit(orbit, objectMap, minimumMotionMetric, frozen) {
             createMotionModel(orbit.object, orbit, minimumMotionMetric, frozen),
     };
 }
+function createSpatialTrajectory(trajectory, objectMap) {
+    const samples = samplePathPoints(trajectory.path).map((point) => ({
+        x: point.x,
+        y: 0,
+        z: point.y,
+    }));
+    return {
+        trajectoryId: trajectory.trajectoryId,
+        trajectory: trajectory.trajectory,
+        craftObjectId: trajectory.craftObjectId,
+        mode: trajectory.mode,
+        stroke: trajectory.stroke,
+        strokeWidth: trajectory.strokeWidth,
+        marker: trajectory.marker,
+        labelMode: trajectory.labelMode,
+        showWaypoints: trajectory.showWaypoints,
+        samples,
+        waypoints: trajectory.waypoints.map((waypoint) => {
+            const object = waypoint.objectId ? objectMap.get(waypoint.objectId) ?? null : null;
+            return {
+                trajectoryId: waypoint.trajectoryId,
+                segmentId: waypoint.segmentId,
+                maneuverId: waypoint.maneuverId,
+                objectId: waypoint.objectId,
+                position: object
+                    ? { ...object.position }
+                    : { x: waypoint.x, y: 0, z: waypoint.y },
+                label: waypoint.label,
+                dateLabel: waypoint.dateLabel,
+                hidden: waypoint.hidden,
+            };
+        }),
+        hidden: trajectory.hidden,
+    };
+}
 function resolveSpatialObjectPosition(entry, scene, sceneCenter, objectMap, orbitMap, cache) {
     const cached = cache.get(entry.objectId);
     if (cached) {
@@ -419,3 +456,22 @@ function clampNumber(value, min, max) {
 function degreesToRadians(value) {
     return (value * Math.PI) / 180;
 }
+function samplePathPoints(path) {
+    const matches = [...path.matchAll(/[MLQ]\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?/g)];
+    if (matches.length === 0) {
+        return [];
+    }
+    const points = [];
+    for (const match of matches) {
+        const command = match[0][0];
+        if (command === "M" || command === "L") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            continue;
+        }
+        if (command === "Q") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            points.push({ x: Number(match[5]), y: Number(match[6]) });
+        }
+    }
+    return points;
+}

package/dist/browser/core/dist/types.d.ts

@@ -1,8 +1,8 @@
-export type WorldOrbitObjectType = "system" | "star" | "planet" | "moon" | "belt" | "asteroid" | "comet" | "ring" | "structure" | "phenomenon";
+export type WorldOrbitObjectType = "system" | "star" | "planet" | "moon" | "belt" | "asteroid" | "comet" | "ring" | "craft" | "structure" | "phenomenon";
 export type PlacementMode = "orbit" | "at" | "surface" | "free";
 export type Unit = "au" | "km" | "m" | "ly" | "pc" | "kpc" | "re" | "rj" | "sol" | "me" | "mj" | "s" | "min" | "h" | "d" | "y" | "ky" | "my" | "gy" | "K" | "deg";
 export type WorldOrbitDocumentVersion = "1.0";
-export type WorldOrbitAtlasDocumentVersion = "2.0" | "2.1" | "2.5" | "2.6";
+export type WorldOrbitAtlasDocumentVersion = "2.0" | "2.1" | "2.5" | "2.6" | "3.0" | "3.1";
 export type WorldOrbitDraftDocumentVersion = "2.0-draft";
 export type WorldOrbitAnyDocumentVersion = WorldOrbitDocumentVersion | WorldOrbitAtlasDocumentVersion | WorldOrbitDraftDocumentVersion;
 export type ViewProjection = "topdown" | "isometric" | "orthographic" | "perspective";
@@ -86,6 +86,7 @@ export interface WorldOrbitDocument {
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
     events: WorldOrbitEvent[];
+    trajectories: WorldOrbitTrajectory[];
     objects: WorldOrbitObject[];
 }
 export interface WorldOrbitAtlasDocument {
@@ -98,6 +99,7 @@ export interface WorldOrbitAtlasDocument {
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
     events: WorldOrbitEvent[];
+    trajectories: WorldOrbitTrajectory[];
     objects: WorldOrbitObject[];
     diagnostics: WorldOrbitDiagnostic[];
 }
@@ -111,6 +113,7 @@ export interface WorldOrbitDraftDocument {
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
     events: WorldOrbitEvent[];
+    trajectories: WorldOrbitTrajectory[];
     objects: WorldOrbitObject[];
     diagnostics: WorldOrbitDiagnostic[];
 }
@@ -127,6 +130,7 @@ export interface WorldOrbitSystem {
 export interface WorldOrbitObject {
     type: Exclude<WorldOrbitObjectType, "system">;
     id: string;
+    trajectoryId?: string | null;
     groups?: string[];
     epoch?: string | null;
     referencePlane?: string | null;
@@ -167,6 +171,7 @@ export interface WorldOrbitEvent {
     kind: string;
     label: string;
     summary: string | null;
+    trajectoryId?: string | null;
     targetObjectId: string | null;
     participantObjectIds: string[];
     timing: string | null;
@@ -181,11 +186,71 @@ export interface WorldOrbitEvent {
 export interface WorldOrbitEventPose {
     objectId: string;
     placement: Placement | null;
+    trajectorySegmentId?: string | null;
+    trajectoryManeuverId?: string | null;
     inner?: UnitValue;
     outer?: UnitValue;
     epoch?: string | null;
     referencePlane?: string | null;
 }
+export interface WorldOrbitTrajectory {
+    id: string;
+    label: string;
+    summary: string | null;
+    craftObjectId: string | null;
+    tags: string[];
+    color: string | null;
+    hidden: boolean;
+    renderMode?: TrajectoryRenderMode | null;
+    stroke?: string | null;
+    strokeWidth?: number | null;
+    marker?: string | null;
+    labelMode?: string | null;
+    showWaypoints?: boolean | null;
+    segments: WorldOrbitTrajectorySegment[];
+}
+export interface WorldOrbitTrajectorySegment {
+    id: string;
+    kind: WorldOrbitTrajectorySegmentKind;
+    label: string | null;
+    summary: string | null;
+    fromObjectId: string | null;
+    toObjectId: string | null;
+    aroundObjectId: string | null;
+    assist: WorldOrbitGravityAssist | null;
+    epoch: string | null;
+    periapsis?: UnitValue;
+    apoapsis?: UnitValue;
+    inclination?: UnitValue;
+    duration?: UnitValue;
+    deltaV?: UnitValue;
+    phaseAngle?: UnitValue;
+    turnAngle?: UnitValue;
+    energy?: UnitValue;
+    waypointLabel?: string | null;
+    waypointDate?: string | null;
+    renderHidden?: boolean | null;
+    sampleDensity?: number | null;
+    notes: string[];
+    maneuvers: WorldOrbitManeuver[];
+}
+export type TrajectoryRenderMode = "illustrative" | "solver" | "auto";
+export type WorldOrbitTrajectorySegmentKind = "departure" | "transfer" | "flyby" | "capture" | "stationkeeping" | "escape";
+export interface WorldOrbitManeuver {
+    id: string;
+    kind: string;
+    label: string | null;
+    epoch: string | null;
+    deltaV?: UnitValue;
+    duration?: UnitValue;
+    notes: string[];
+}
+export interface WorldOrbitGravityAssist {
+    objectId: string;
+    periapsis?: UnitValue;
+    turnAngle?: UnitValue;
+    notes: string[];
+}
 export interface WorldOrbitResonance {
     targetObjectId: string;
     ratio: string;
@@ -276,6 +341,9 @@ export interface SceneRenderOptions {
     scaleModel?: Partial<RenderScaleModel>;
     bodyScaleMode?: BodyScaleMode;
     activeEventId?: string | null;
+    trajectoryMode?: TrajectoryRenderMode;
+    showTrajectoryWaypoints?: boolean;
+    showTrajectoryLabels?: boolean;
 }
 export interface SpatialScaleModel {
     orbitDistanceMultiplier: number;
@@ -381,7 +449,35 @@ export interface RenderSceneEvent {
     y: number;
     hidden: boolean;
 }
-export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "relations" | "events" | "objects" | "labels" | "metadata";
+export interface RenderSceneTrajectoryWaypoint {
+    renderId: string;
+    trajectoryId: string;
+    segmentId: string | null;
+    maneuverId: string | null;
+    objectId: string | null;
+    x: number;
+    y: number;
+    label: string | null;
+    dateLabel: string | null;
+    hidden: boolean;
+}
+export interface RenderSceneTrajectory {
+    renderId: string;
+    trajectoryId: string;
+    trajectory: WorldOrbitTrajectory;
+    craftObjectId: string | null;
+    mode: TrajectoryRenderMode;
+    path: string;
+    stroke: string | null;
+    strokeWidth: number;
+    marker: string | null;
+    labelMode: string | null;
+    showWaypoints: boolean;
+    objectIds: string[];
+    waypoints: RenderSceneTrajectoryWaypoint[];
+    hidden: boolean;
+}
+export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "trajectories" | "relations" | "events" | "objects" | "labels" | "metadata";
 export interface RenderSceneViewpointFilter {
     query: string | null;
     objectTypes: Array<Exclude<WorldOrbitObjectType, "system">>;
@@ -500,6 +596,34 @@ export interface SpatialOrbit {
     hidden: boolean;
     motion: OrbitalMotionModel | null;
 }
+export interface SpatialTrajectorySample {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface SpatialTrajectory {
+    trajectoryId: string;
+    trajectory: WorldOrbitTrajectory;
+    craftObjectId: string | null;
+    mode: TrajectoryRenderMode;
+    stroke: string | null;
+    strokeWidth: number;
+    marker: string | null;
+    labelMode: string | null;
+    showWaypoints: boolean;
+    samples: SpatialTrajectorySample[];
+    waypoints: Array<{
+        trajectoryId: string;
+        segmentId: string | null;
+        maneuverId: string | null;
+        objectId: string | null;
+        position: CoordinatePoint3D;
+        label: string | null;
+        dateLabel: string | null;
+        hidden: boolean;
+    }>;
+    hidden: boolean;
+}
 export interface SpatialFocusTarget {
     objectId: string;
     center: CoordinatePoint3D;
@@ -527,6 +651,7 @@ export interface RenderScene {
     viewpoints: RenderSceneViewpoint[];
     events: RenderSceneEvent[];
     activeEventId: string | null;
+    trajectories: RenderSceneTrajectory[];
     objects: RenderSceneObject[];
     orbitVisuals: RenderOrbitVisual[];
     relations: RenderSceneRelation[];
@@ -554,6 +679,7 @@ export interface SpatialScene {
     timeFrozen: boolean;
     objects: SpatialSceneObject[];
     orbits: SpatialOrbit[];
+    trajectories: SpatialTrajectory[];
     focusTargets: SpatialFocusTarget[];
 }
 export type SceneLayoutPreset = "compact" | "balanced" | "presentation";
@@ -632,7 +758,7 @@ export interface WorldOrbitAtlasSystem {
     viewpoints: WorldOrbitAtlasViewpoint[];
     annotations: WorldOrbitAtlasAnnotation[];
 }
-export type AtlasDocumentPathKind = "system" | "defaults" | "metadata" | "group" | "event" | "event-pose" | "object" | "viewpoint" | "annotation" | "relation";
+export type AtlasDocumentPathKind = "system" | "defaults" | "metadata" | "group" | "event" | "event-pose" | "trajectory" | "trajectory-segment" | "trajectory-maneuver" | "object" | "viewpoint" | "annotation" | "relation";
 export interface AtlasDocumentPath {
     kind: AtlasDocumentPathKind;
     id?: string;