worldorbit 2.5.2

package/packages/viewer/dist/theme.d.ts

@@ -0,0 +1,4 @@
+import type { ViewerLayerOptions, WorldOrbitTheme, WorldOrbitThemeName } from "./types.js";
+export declare function resolveTheme(theme?: WorldOrbitTheme | WorldOrbitThemeName): WorldOrbitTheme;
+export declare function resolveLayers(layers?: ViewerLayerOptions): Required<ViewerLayerOptions>;
+export declare function getThemePreset(name: WorldOrbitThemeName): WorldOrbitTheme;

package/packages/viewer/dist/theme.js

@@ -0,0 +1,98 @@
+const DEFAULT_LAYERS = {
+    background: true,
+    guides: true,
+    orbits: true,
+    objects: true,
+    labels: true,
+    structures: true,
+    metadata: true,
+};
+const THEME_PRESETS = {
+    atlas: {
+        name: "atlas",
+        backgroundStart: "#041018",
+        backgroundEnd: "#0a2331",
+        backgroundGlow: "rgba(240, 180, 100, 0.18)",
+        panel: "rgba(7, 17, 27, 0.9)",
+        panelLine: "rgba(168, 207, 242, 0.18)",
+        orbit: "rgba(163, 209, 255, 0.24)",
+        orbitBand: "rgba(255, 190, 120, 0.28)",
+        guide: "rgba(255, 255, 255, 0.04)",
+        leader: "rgba(225, 238, 255, 0.4)",
+        ink: "#e8f0ff",
+        muted: "rgba(232, 240, 255, 0.7)",
+        accent: "#f0b464",
+        accentStrong: "#ff7f5f",
+        selected: "rgba(255, 214, 139, 0.92)",
+        starCore: "#ffcc67",
+        starStroke: "rgba(255, 245, 203, 0.85)",
+        starGlow: "#ffe8a3",
+        fontFamily: "\"Segoe UI Variable\", \"Bahnschrift\", sans-serif",
+        displayFont: "\"Bahnschrift\", \"Segoe UI Variable\", sans-serif"
+    },
+    nightglass: {
+        name: "nightglass",
+        backgroundStart: "#07131f",
+        backgroundEnd: "#13283a",
+        backgroundGlow: "rgba(120, 255, 215, 0.16)",
+        panel: "rgba(7, 20, 30, 0.9)",
+        panelLine: "rgba(120, 255, 215, 0.16)",
+        orbit: "rgba(120, 255, 215, 0.2)",
+        orbitBand: "rgba(137, 185, 255, 0.24)",
+        guide: "rgba(255, 255, 255, 0.035)",
+        leader: "rgba(192, 255, 233, 0.42)",
+        ink: "#edfff8",
+        muted: "rgba(237, 255, 248, 0.68)",
+        accent: "#78ffd7",
+        accentStrong: "#9ce7ff",
+        selected: "rgba(120, 255, 215, 0.9)",
+        starCore: "#e5f98c",
+        starStroke: "rgba(246, 255, 217, 0.9)",
+        starGlow: "#fffab4",
+        fontFamily: "\"Segoe UI Variable\", \"Bahnschrift\", sans-serif",
+        displayFont: "\"Bahnschrift\", \"Segoe UI Variable\", sans-serif"
+    },
+    ember: {
+        name: "ember",
+        backgroundStart: "#17090b",
+        backgroundEnd: "#31111a",
+        backgroundGlow: "rgba(255, 127, 95, 0.18)",
+        panel: "rgba(24, 9, 13, 0.9)",
+        panelLine: "rgba(255, 166, 149, 0.16)",
+        orbit: "rgba(255, 188, 164, 0.22)",
+        orbitBand: "rgba(255, 214, 139, 0.24)",
+        guide: "rgba(255, 255, 255, 0.03)",
+        leader: "rgba(255, 223, 209, 0.42)",
+        ink: "#fff3ee",
+        muted: "rgba(255, 243, 238, 0.68)",
+        accent: "#ffb27d",
+        accentStrong: "#ff7f5f",
+        selected: "rgba(255, 178, 125, 0.9)",
+        starCore: "#ffb766",
+        starStroke: "rgba(255, 236, 205, 0.88)",
+        starGlow: "#ffe2ad",
+        fontFamily: "\"Segoe UI Variable\", \"Bahnschrift\", sans-serif",
+        displayFont: "\"Bahnschrift\", \"Segoe UI Variable\", sans-serif"
+    }
+};
+export function resolveTheme(theme) {
+    if (!theme) {
+        return THEME_PRESETS.atlas;
+    }
+    if (typeof theme === "string") {
+        return THEME_PRESETS[theme] ?? THEME_PRESETS.atlas;
+    }
+    return {
+        ...THEME_PRESETS.atlas,
+        ...theme,
+    };
+}
+export function resolveLayers(layers) {
+    return {
+        ...DEFAULT_LAYERS,
+        ...layers,
+    };
+}
+export function getThemePreset(name) {
+    return THEME_PRESETS[name];
+}

package/packages/viewer/dist/tooltip.d.ts

@@ -0,0 +1,3 @@
+import type { TooltipMode, ViewerObjectDetails, ViewerTooltipDetails } from "./types.js";
+export declare function buildViewerTooltipDetails(details: ViewerObjectDetails): ViewerTooltipDetails;
+export declare function renderDefaultTooltipContent(details: ViewerTooltipDetails, mode: TooltipMode): string;

package/packages/viewer/dist/tooltip.js

@@ -0,0 +1,154 @@
+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 (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/packages/viewer/dist/types.d.ts

@@ -0,0 +1,256 @@
+import type { CoordinatePoint, RenderOrbitVisual, RenderPresetName, RenderSceneGroup, RenderSceneLabel, RenderScaleModel, RenderScene, RenderSceneObject, RenderSceneViewpoint, SceneRenderOptions, ViewProjection, WorldOrbitObject, WorldOrbitDocument } from "@worldorbit/core";
+export type WorldOrbitThemeName = "atlas" | "nightglass" | "ember";
+export type WorldOrbitEmbedMode = "static" | "interactive";
+export type TooltipMode = "hover" | "pinned" | "disabled";
+export interface WorldOrbitTheme {
+    name: string;
+    backgroundStart: string;
+    backgroundEnd: string;
+    backgroundGlow: string;
+    panel: string;
+    panelLine: 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;
+    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>;
+}
+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;
+    orbit: RenderOrbitVisual | null;
+    relatedOrbits: RenderOrbitVisual[];
+    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";
+    viewpointId: string | null;
+    viewerState: ViewerState;
+    renderOptions: {
+        preset?: RenderPresetName;
+        projection?: "document" | ViewProjection;
+        layers?: ViewerLayerOptions;
+        scaleModel?: Partial<RenderScaleModel>;
+    };
+    filter: ViewerFilter | null;
+}
+export interface ViewerBookmark {
+    id: string;
+    label: string;
+    atlasState: ViewerAtlasState;
+}
+export interface AtlasViewerControls {
+    search?: boolean;
+    typeFilter?: 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;
+        renderPreset: RenderPresetName | null;
+        groupCount: number;
+        viewpointCount: number;
+    };
+}
+export interface InteractiveViewerOptions extends ViewerRenderOptions {
+    source?: string;
+    document?: WorldOrbitDocument;
+    scene?: RenderScene;
+    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;
+    listViewpoints(): RenderSceneViewpoint[];
+    getActiveViewpoint(): RenderSceneViewpoint | null;
+    goToViewpoint(id: string): boolean;
+    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;
+    options?: {
+        theme?: WorldOrbitTheme | WorldOrbitThemeName;
+        layers?: ViewerLayerOptions;
+        subtitle?: string;
+        preset?: SceneRenderOptions["preset"];
+        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/packages/viewer/dist/types.js

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

package/packages/viewer/dist/viewer-state.d.ts

@@ -0,0 +1,19 @@
+import { type CoordinatePoint, type RenderBounds, type RenderScene } from "@worldorbit/core";
+import type { ViewerState } from "./types.js";
+export interface ViewerConstraints {
+    minScale: number;
+    maxScale: number;
+    fitPadding: number;
+}
+export declare const DEFAULT_VIEWER_STATE: ViewerState;
+export declare function normalizeRotation(rotationDeg: number): number;
+export declare function clampScale(scale: number, constraints: ViewerConstraints): number;
+export declare function panViewerState(state: ViewerState, dx: number, dy: number): ViewerState;
+export declare function rotateViewerState(state: ViewerState, deltaDeg: number): ViewerState;
+export declare function zoomViewerStateAt(scene: RenderScene, state: ViewerState, factor: number, anchor: CoordinatePoint, constraints: ViewerConstraints): ViewerState;
+export declare function fitViewerState(scene: RenderScene, state: ViewerState, constraints: ViewerConstraints): ViewerState;
+export declare function focusViewerState(scene: RenderScene, state: ViewerState, objectId: string, constraints: ViewerConstraints): ViewerState;
+export declare function composeViewerTransform(scene: RenderScene, state: ViewerState): string;
+export declare function invertViewerPoint(scene: RenderScene, state: ViewerState, point: CoordinatePoint): CoordinatePoint;
+export declare function getViewerVisibleBounds(scene: RenderScene, state: ViewerState): RenderBounds;
+export declare function getSceneCenter(scene: RenderScene): CoordinatePoint;