worldorbit 2.6.0 → 3.0.0

package/dist/browser/viewer/dist/tooltip.js

@@ -0,0 +1,198 @@
+const FIELD_ORDER = [
+    "radius",
+    "temperature",
+    "atmosphere",
+    "period",
+    "semiMajor",
+    "distance",
+    "eccentricity",
+    "angle",
+    "inclination",
+    "phase",
+    "albedo",
+    "mass",
+    "density",
+    "gravity",
+];
+export function buildViewerTooltipDetails(details) {
+    return {
+        objectId: details.objectId,
+        title: details.objectId,
+        typeLabel: humanizeType(details.object.type),
+        imageHref: details.renderObject.imageHref ?? null,
+        description: readTooltipDescription(details),
+        tags: normalizeTags(details.object.properties.tags),
+        fields: buildTooltipFields(details),
+        parentLabel: details.parent?.objectId ?? null,
+        orbitLabel: details.orbit?.parentId ?? null,
+        details,
+    };
+}
+export function renderDefaultTooltipContent(details, mode) {
+    const tagMarkup = details.tags.length
+        ? `<div class="wo-tooltip-tags">${details.tags
+            .map((tag) => `<span class="wo-tooltip-tag">${escapeHtml(tag)}</span>`)
+            .join("")}</div>`
+        : "";
+    const fieldMarkup = details.fields.length
+        ? `<dl class="wo-tooltip-fields">${details.fields
+            .map((field) => `<div class="wo-tooltip-field"><dt>${escapeHtml(field.label)}</dt><dd>${escapeHtml(field.value)}</dd></div>`)
+            .join("")}</dl>`
+        : "";
+    const relationBits = [
+        details.parentLabel ? `Parent: ${details.parentLabel}` : null,
+        details.orbitLabel ? `Orbit: ${details.orbitLabel}` : null,
+        mode === "pinned" ? "Pinned tooltip" : "Hover tooltip",
+    ].filter(Boolean);
+    return `<article class="wo-tooltip-card" data-tooltip-object-id="${escapeHtml(details.objectId)}">
+    <div class="wo-tooltip-head">
+      ${details.imageHref
+        ? `<img class="wo-tooltip-image" src="${escapeAttribute(details.imageHref)}" alt="" />`
+        : `<div class="wo-tooltip-image wo-tooltip-image-placeholder">${escapeHtml(details.typeLabel.slice(0, 1))}</div>`}
+      <div class="wo-tooltip-heading">
+        <strong>${escapeHtml(details.title)}</strong>
+        <span>${escapeHtml(details.typeLabel)}</span>
+      </div>
+    </div>
+    ${details.description ? `<p class="wo-tooltip-description">${escapeHtml(details.description)}</p>` : ""}
+    ${tagMarkup}
+    ${fieldMarkup}
+    ${relationBits.length
+        ? `<p class="wo-tooltip-relations">${escapeHtml(relationBits.join(" - "))}</p>`
+        : ""}
+  </article>`;
+}
+function buildTooltipFields(details) {
+    const fields = new Map();
+    for (const key of FIELD_ORDER) {
+        const value = details.object.properties[key];
+        if (value === undefined) {
+            continue;
+        }
+        fields.set(key, {
+            key,
+            label: humanizeField(key),
+            value: formatTooltipValue(value),
+        });
+    }
+    const placement = details.object.placement;
+    if (details.object.groups?.length) {
+        fields.set("groups", {
+            key: "groups",
+            label: "Groups",
+            value: details.object.groups.join(", "),
+        });
+    }
+    if (details.object.epoch) {
+        fields.set("epoch", {
+            key: "epoch",
+            label: "Epoch",
+            value: details.object.epoch,
+        });
+    }
+    if (details.object.referencePlane) {
+        fields.set("referencePlane", {
+            key: "referencePlane",
+            label: "Reference Plane",
+            value: details.object.referencePlane,
+        });
+    }
+    if (details.object.tidalLock !== undefined) {
+        fields.set("tidalLock", {
+            key: "tidalLock",
+            label: "Tidal Lock",
+            value: details.object.tidalLock ? "true" : "false",
+        });
+    }
+    if (details.object.resonance) {
+        fields.set("resonance", {
+            key: "resonance",
+            label: "Resonance",
+            value: `${details.object.resonance.targetObjectId} ${details.object.resonance.ratio}`,
+        });
+    }
+    if (details.relatedEvents.length > 0) {
+        fields.set("events", {
+            key: "events",
+            label: "Events",
+            value: details.relatedEvents
+                .map((event) => event.event.label || event.event.id)
+                .join(", "),
+        });
+    }
+    if (placement?.mode === "at") {
+        fields.set("placement", {
+            key: "placement",
+            label: "Placement",
+            value: `At ${placement.target}`,
+        });
+    }
+    else if (placement?.mode === "surface") {
+        fields.set("placement", {
+            key: "placement",
+            label: "Placement",
+            value: `Surface ${placement.target}`,
+        });
+    }
+    else if (placement?.mode === "free") {
+        fields.set("placement", {
+            key: "placement",
+            label: "Placement",
+            value: placement.distance
+                ? `Free ${formatTooltipValue(placement.distance)}`
+                : `Free ${placement.descriptor ?? "custom"}`,
+        });
+    }
+    return [...fields.values()];
+}
+function normalizeTags(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string");
+}
+function readTooltipDescription(details) {
+    const direct = details.object.info.description?.trim();
+    if (direct) {
+        return direct;
+    }
+    const summary = details.group?.label?.trim();
+    return summary && summary !== details.objectId ? summary : null;
+}
+function formatTooltipValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (Array.isArray(value)) {
+        return value.join(", ");
+    }
+    return formatUnitValue(value);
+}
+function formatUnitValue(value) {
+    return `${value.value}${value.unit ?? ""}`;
+}
+function humanizeType(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function humanizeField(value) {
+    return value
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/[-_]+/g, " ")
+        .replace(/^./, (match) => match.toUpperCase());
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+function escapeAttribute(value) {
+    return escapeHtml(value);
+}

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

@@ -0,0 +1,292 @@
+import type { CoordinatePoint, RenderOrbitVisual, RenderProjectionFallback, RenderPresetName, RenderSceneEvent, RenderSceneGroup, RenderSceneLabel, RenderScaleModel, RenderScene, RenderSceneObject, RenderSceneViewpoint, SceneRenderOptions, SpatialScene, ViewProjection, WorldOrbitObject, WorldOrbitDocument, WorldOrbitViewCamera } from "@worldorbit/core";
+export type WorldOrbitThemeName = "atlas" | "nightglass" | "ember";
+export type WorldOrbitViewMode = "2d" | "3d";
+export type WorldOrbitEmbedMode = "static" | "interactive" | "interactive-2d" | "interactive-3d";
+export type TooltipMode = "hover" | "pinned" | "disabled";
+export interface WorldOrbitTheme {
+    name: string;
+    backgroundStart: string;
+    backgroundEnd: string;
+    backgroundGlow: string;
+    panel: string;
+    panelLine: string;
+    relation: string;
+    orbit: string;
+    orbitBand: string;
+    guide: string;
+    leader: string;
+    ink: string;
+    muted: string;
+    accent: string;
+    accentStrong: string;
+    selected: string;
+    starCore: string;
+    starStroke: string;
+    starGlow: string;
+    fontFamily: string;
+    displayFont: string;
+}
+export interface ViewerLayerOptions {
+    background?: boolean;
+    guides?: boolean;
+    relations?: boolean;
+    events?: boolean;
+    orbits?: boolean;
+    objects?: boolean;
+    labels?: boolean;
+    structures?: boolean;
+    metadata?: boolean;
+}
+export interface ViewerFilter {
+    query?: string;
+    objectTypes?: Array<WorldOrbitObject["type"]>;
+    tags?: string[];
+    groupIds?: string[];
+    includeAncestors?: boolean;
+}
+export interface ViewerSearchResult {
+    objectId: string;
+    label: string;
+    type: WorldOrbitObject["type"];
+    score: number;
+    groupId: string | null;
+    parentId: string | null;
+    tags: string[];
+}
+export interface SvgRenderOptions extends SceneRenderOptions {
+    theme?: WorldOrbitTheme | WorldOrbitThemeName;
+    layers?: ViewerLayerOptions;
+    filter?: ViewerFilter | null;
+    selectedObjectId?: string | null;
+    subtitle?: string;
+}
+export interface ViewerRenderOptions extends Omit<SvgRenderOptions, "selectedObjectId"> {
+    projection?: "document" | ViewProjection;
+    scaleModel?: Partial<RenderScaleModel>;
+    viewMode?: WorldOrbitViewMode;
+}
+export interface ViewerState {
+    scale: number;
+    rotationDeg: number;
+    translateX: number;
+    translateY: number;
+    selectedObjectId: string | null;
+}
+export interface ViewerObjectDetails {
+    objectId: string;
+    object: WorldOrbitObject;
+    renderObject: RenderSceneObject;
+    label: RenderSceneLabel | null;
+    group: RenderSceneGroup | null;
+    semanticGroups: RenderScene["semanticGroups"];
+    orbit: RenderOrbitVisual | null;
+    relatedOrbits: RenderOrbitVisual[];
+    relations: RenderScene["relations"];
+    relatedEvents: RenderSceneEvent[];
+    parent: RenderSceneObject | null;
+    children: RenderSceneObject[];
+    ancestors: RenderSceneObject[];
+    focusPath: RenderSceneObject[];
+}
+export interface ViewerTooltipField {
+    key: string;
+    label: string;
+    value: string;
+}
+export interface ViewerTooltipDetails {
+    objectId: string;
+    title: string;
+    typeLabel: string;
+    imageHref: string | null;
+    description: string | null;
+    tags: string[];
+    fields: ViewerTooltipField[];
+    parentLabel: string | null;
+    orbitLabel: string | null;
+    details: ViewerObjectDetails;
+}
+export interface ViewerAtlasState {
+    version: "2.0" | "2.5";
+    viewpointId: string | null;
+    activeEventId?: string | null;
+    viewerState: ViewerState;
+    renderOptions: {
+        preset?: RenderPresetName;
+        projection?: "document" | ViewProjection;
+        camera?: WorldOrbitViewCamera | null;
+        layers?: ViewerLayerOptions;
+        scaleModel?: Partial<RenderScaleModel>;
+        activeEventId?: string | null;
+        viewMode?: WorldOrbitViewMode;
+    };
+    filter: ViewerFilter | null;
+}
+export interface ViewerAnimationState {
+    playing: boolean;
+    speed: number;
+    timeSeconds: number;
+    frozenByEvent: boolean;
+}
+export interface ViewerBookmark {
+    id: string;
+    label: string;
+    atlasState: ViewerAtlasState;
+}
+export interface AtlasViewerControls {
+    search?: boolean;
+    typeFilter?: boolean;
+    groupFilter?: boolean;
+    viewpointSelect?: boolean;
+    inspector?: boolean;
+    bookmarks?: boolean;
+}
+export interface AtlasInspectorSnapshot {
+    selection: ViewerObjectDetails | null;
+    activeViewpoint: RenderSceneViewpoint | null;
+    filter: ViewerFilter | null;
+    atlasState: ViewerAtlasState;
+    visibleObjectIds: string[];
+    scene: {
+        title: string;
+        projection: ViewProjection;
+        renderProjection: RenderProjectionFallback;
+        camera: WorldOrbitViewCamera | null;
+        renderPreset: RenderPresetName | null;
+        groupCount: number;
+        semanticGroupCount: number;
+        relationCount: number;
+        eventCount: number;
+        viewpointCount: number;
+    };
+}
+export interface InteractiveViewerOptions extends ViewerRenderOptions {
+    source?: string;
+    document?: WorldOrbitDocument;
+    scene?: RenderScene;
+    spatialScene?: SpatialScene;
+    initialViewpointId?: string;
+    initialSelectionObjectId?: string;
+    initialFilter?: ViewerFilter | null;
+    minScale?: number;
+    maxScale?: number;
+    fitPadding?: number;
+    keyboard?: boolean;
+    pointer?: boolean;
+    touch?: boolean;
+    selection?: boolean;
+    tooltipMode?: TooltipMode;
+    tooltipRenderer?: (details: ViewerTooltipDetails, mode: TooltipMode) => HTMLElement | string;
+    minimap?: boolean;
+    panStep?: number;
+    zoomStep?: number;
+    rotationStep?: number;
+    onSelectionChange?: (selectedObject: RenderSceneObject | null) => void;
+    onSelectionDetailsChange?: (details: ViewerObjectDetails | null) => void;
+    onHoverChange?: (hoveredObject: RenderSceneObject | null) => void;
+    onHoverDetailsChange?: (details: ViewerObjectDetails | null) => void;
+    onTooltipChange?: (details: ViewerTooltipDetails | null) => void;
+    onFilterChange?: (filter: ViewerFilter | null, visibleObjects: RenderSceneObject[]) => void;
+    onViewpointChange?: (viewpoint: RenderSceneViewpoint | null) => void;
+    onViewChange?: (state: ViewerState) => void;
+    onAtlasStateChange?: (state: ViewerAtlasState) => void;
+}
+export interface AtlasViewerOptions extends Omit<InteractiveViewerOptions, "initialFilter"> {
+    controls?: AtlasViewerControls;
+    initialFilter?: ViewerFilter | null;
+    initialQuery?: string;
+    initialObjectType?: WorldOrbitObject["type"] | null;
+    onInspectorChange?: (snapshot: AtlasInspectorSnapshot) => void;
+}
+export interface WorldOrbitViewer {
+    setSource(source: string): void;
+    setDocument(document: WorldOrbitDocument): void;
+    setScene(scene: RenderScene): void;
+    getScene(): RenderScene;
+    getRenderOptions(): ViewerRenderOptions;
+    setRenderOptions(options: Partial<ViewerRenderOptions>): void;
+    getViewMode(): WorldOrbitViewMode;
+    setViewMode(mode: WorldOrbitViewMode): void;
+    listViewpoints(): RenderSceneViewpoint[];
+    getActiveViewpoint(): RenderSceneViewpoint | null;
+    goToViewpoint(id: string): boolean;
+    getActiveEventId(): string | null;
+    setActiveEvent(id: string | null): void;
+    playAnimation(): void;
+    pauseAnimation(): void;
+    resetAnimation(): void;
+    setAnimationSpeed(multiplier: number): void;
+    getAnimationState(): ViewerAnimationState;
+    search(query: string, limit?: number): ViewerSearchResult[];
+    getFilter(): ViewerFilter | null;
+    setFilter(filter: ViewerFilter | null): void;
+    getVisibleObjects(): RenderSceneObject[];
+    getFocusPath(id: string): RenderSceneObject[];
+    getObjectDetails(id: string): ViewerObjectDetails | null;
+    getSelectionDetails(): ViewerObjectDetails | null;
+    getTooltipDetails(): ViewerTooltipDetails | null;
+    getAtlasState(): ViewerAtlasState;
+    setAtlasState(state: ViewerAtlasState | string): void;
+    serializeAtlasState(): string;
+    captureBookmark(name: string, label?: string): ViewerBookmark;
+    applyBookmark(bookmark: ViewerBookmark | string): boolean;
+    getState(): ViewerState;
+    setState(state: Partial<ViewerState>): void;
+    zoomBy(factor: number, anchor?: CoordinatePoint): void;
+    panBy(dx: number, dy: number): void;
+    rotateBy(deg: number): void;
+    fitToSystem(): void;
+    focusObject(id: string): void;
+    pinTooltip(id: string | null): void;
+    resetView(): void;
+    exportSvg(): string;
+    destroy(): void;
+}
+export interface WorldOrbitAtlasViewer {
+    element: HTMLElement;
+    viewer: WorldOrbitViewer;
+    getViewer(): WorldOrbitViewer;
+    setSource(source: string): void;
+    setDocument(document: WorldOrbitDocument): void;
+    setScene(scene: RenderScene): void;
+    getAtlasState(): ViewerAtlasState;
+    setAtlasState(state: ViewerAtlasState | string): void;
+    getInspectorSnapshot(): AtlasInspectorSnapshot;
+    getSearchQuery(): string;
+    setSearchQuery(query: string): void;
+    getObjectTypeFilter(): WorldOrbitObject["type"] | null;
+    setObjectTypeFilter(type: WorldOrbitObject["type"] | null): void;
+    listSearchResults(limit?: number): ViewerSearchResult[];
+    listBookmarks(): ViewerBookmark[];
+    captureBookmark(name: string, label?: string): ViewerBookmark;
+    applyBookmark(bookmark: ViewerBookmark | string): boolean;
+    goToViewpoint(id: string): boolean;
+    exportSvg(): string;
+    destroy(): void;
+}
+export interface WorldOrbitEmbedPayload {
+    version: "2.0";
+    mode: WorldOrbitEmbedMode;
+    scene: RenderScene;
+    spatialScene?: SpatialScene;
+    options?: {
+        theme?: WorldOrbitTheme | WorldOrbitThemeName;
+        layers?: ViewerLayerOptions;
+        subtitle?: string;
+        preset?: SceneRenderOptions["preset"];
+        viewMode?: WorldOrbitViewMode;
+        initialViewpointId?: string;
+        initialSelectionObjectId?: string;
+        initialFilter?: ViewerFilter | null;
+        atlasState?: ViewerAtlasState | null;
+        minimap?: boolean;
+    };
+}
+export interface MountWorldOrbitEmbedsOptions extends SvgRenderOptions {
+    mode?: WorldOrbitEmbedMode;
+    viewer?: Omit<InteractiveViewerOptions, "source" | "document" | "scene">;
+    onMount?: (viewer: WorldOrbitViewer | null, element: HTMLElement) => void;
+}
+export interface MountedWorldOrbitEmbeds {
+    viewers: WorldOrbitViewer[];
+    destroy(): void;
+}

package/dist/browser/viewer/dist/types.js

@@ -0,0 +1 @@
+export {};