worldorbit 2.5.15 → 2.5.17

package/packages/editor/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "./types.js";
+export { createWorldOrbitEditor } from "./editor.js";

package/packages/editor/dist/index.js

@@ -0,0 +1 @@
+export { createWorldOrbitEditor } from "./editor.js";

package/packages/editor/dist/types.d.ts

@@ -0,0 +1,55 @@
+import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitEvent, WorldOrbitAtlasSystem, WorldOrbitAtlasViewpoint, WorldOrbitObject } from "@worldorbit/core";
+export interface WorldOrbitEditorSelection {
+    path: AtlasDocumentPath | null;
+}
+export interface WorldOrbitEditorSnapshot {
+    source: string;
+    atlasDocument: WorldOrbitAtlasDocument;
+    diagnostics: AtlasResolvedDiagnostic[];
+    selection: WorldOrbitEditorSelection | null;
+}
+export interface WorldOrbitEditorOptions {
+    source?: string;
+    atlasDocument?: WorldOrbitAtlasDocument;
+    showTextPane?: boolean;
+    showInspector?: boolean;
+    showPreview?: boolean;
+    viewerWidth?: number;
+    viewerHeight?: number;
+    shortcuts?: boolean;
+    onChange?: (snapshot: WorldOrbitEditorSnapshot) => void;
+    onDiagnosticsChange?: (diagnostics: AtlasResolvedDiagnostic[]) => void;
+    onSelectionChange?: (selection: WorldOrbitEditorSelection | null) => void;
+    onDirtyChange?: (dirty: boolean) => void;
+}
+export interface WorldOrbitEditor {
+    setSource(source: string): void;
+    setAtlasDocument(document: WorldOrbitAtlasDocument): void;
+    getSource(): string;
+    getAtlasDocument(): WorldOrbitAtlasDocument;
+    getDiagnostics(): AtlasResolvedDiagnostic[];
+    getSelection(): WorldOrbitEditorSelection | null;
+    isDirty(): boolean;
+    markSaved(): void;
+    selectPath(path: AtlasDocumentPath | null): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    addObject(type?: WorldOrbitObject["type"]): string;
+    addEvent(): string;
+    addViewpoint(): string;
+    addAnnotation(): string;
+    addMetadata(key?: string, value?: string): string;
+    removeSelection(): boolean;
+    exportSvg(): string;
+    exportEmbedMarkup(): string;
+    destroy(): void;
+}
+export interface WorldOrbitEditorFormState {
+    selection: WorldOrbitEditorSelection | null;
+    system: WorldOrbitAtlasSystem | null;
+    viewpoints: WorldOrbitAtlasViewpoint[];
+    events: WorldOrbitEvent[];
+    objects: WorldOrbitObject[];
+}

package/packages/editor/dist/types.js

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

package/packages/markdown/dist/html.d.ts

@@ -0,0 +1,3 @@
+import type { WorldOrbitMarkdownOptions } from "./types.js";
+export declare function renderWorldOrbitBlock(source: string, options?: WorldOrbitMarkdownOptions): string;
+export declare function renderWorldOrbitError(message: string): string;

package/packages/markdown/dist/html.js

@@ -0,0 +1,57 @@
+import { loadWorldOrbitSource, renderDocumentToScene, } from "@worldorbit/core";
+import { createEmbedPayload, createWorldOrbitEmbedMarkup, renderSceneToSvg, } from "@worldorbit/viewer";
+export function renderWorldOrbitBlock(source, options = {}) {
+    try {
+        const loaded = loadWorldOrbitSource(source);
+        const scene = renderDocumentToScene(loaded.document, resolveSourceRenderOptions(loaded, options));
+        if ((options.mode ?? "static") === "interactive") {
+            return createWorldOrbitEmbedMarkup(createEmbedPayload(scene, "interactive", {
+                initialViewpointId: options.initialViewpointId,
+                initialSelectionObjectId: options.initialSelectionObjectId,
+                initialFilter: options.initialFilter ?? null,
+                atlasState: options.atlasState ?? null,
+                minimap: options.minimap,
+            }), {
+                className: options.className ?? "worldorbit-block worldorbit-interactive",
+                theme: options.theme,
+                layers: options.layers,
+                subtitle: options.subtitle,
+                preset: options.preset,
+                initialViewpointId: options.initialViewpointId,
+                initialSelectionObjectId: options.initialSelectionObjectId,
+                initialFilter: options.initialFilter ?? null,
+                atlasState: options.atlasState ?? null,
+                minimap: options.minimap,
+            });
+        }
+        return `<figure class="${escapeAttribute(options.className ?? "worldorbit-block worldorbit-static")}">${renderSceneToSvg(scene, options)}</figure>`;
+    }
+    catch (error) {
+        if (options.strict) {
+            throw error;
+        }
+        return renderWorldOrbitError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function renderWorldOrbitError(message) {
+    return `<pre class="worldorbit-error">WorldOrbit error: ${escapeHtml(message)}</pre>`;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replaceAll("\"", "&quot;");
+}
+function resolveSourceRenderOptions(loaded, options) {
+    const atlasDocument = loaded.atlasDocument ?? loaded.draftDocument;
+    if (options.preset || !atlasDocument?.system?.defaults.preset) {
+        return options;
+    }
+    return {
+        ...options,
+        preset: atlasDocument.system.defaults.preset,
+    };
+}

package/packages/markdown/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./types.js";
+export { renderWorldOrbitBlock, renderWorldOrbitError } from "./html.js";
+export { remarkWorldOrbit } from "./remark.js";
+export { rehypeWorldOrbit } from "./rehype.js";

package/packages/markdown/dist/index.js

@@ -0,0 +1,3 @@
+export { renderWorldOrbitBlock, renderWorldOrbitError } from "./html.js";
+export { remarkWorldOrbit } from "./remark.js";
+export { rehypeWorldOrbit } from "./rehype.js";

package/packages/markdown/dist/rehype.d.ts

@@ -0,0 +1,10 @@
+import type { WorldOrbitMarkdownOptions } from "./types.js";
+interface HastNode {
+    type: string;
+    tagName?: string;
+    value?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+}
+export declare function rehypeWorldOrbit(options?: WorldOrbitMarkdownOptions): (tree: HastNode) => void;
+export {};

package/packages/markdown/dist/rehype.js

@@ -0,0 +1,49 @@
+import { renderWorldOrbitBlock } from "./html.js";
+export function rehypeWorldOrbit(options = {}) {
+    return function transform(tree) {
+        visitHastNodes(tree, (node, index, parent) => {
+            if (!parent || index === -1 || node.type !== "element" || node.tagName !== "pre") {
+                return;
+            }
+            const codeElement = node.children?.[0];
+            if (!codeElement || codeElement.type !== "element" || codeElement.tagName !== "code") {
+                return;
+            }
+            const classNames = normalizeClassNames(codeElement.properties?.className);
+            if (!classNames.includes("language-worldorbit")) {
+                return;
+            }
+            const source = collectText(codeElement);
+            parent.children[index] = {
+                type: "raw",
+                value: renderWorldOrbitBlock(source, options),
+            };
+        });
+    };
+}
+function visitHastNodes(node, visitor, parent = null) {
+    const children = node.children ?? [];
+    for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        visitor(child, index, node);
+        visitHastNodes(child, visitor, node);
+    }
+    if (!parent) {
+        visitor(node, -1, null);
+    }
+}
+function normalizeClassNames(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => String(entry));
+    }
+    if (typeof value === "string") {
+        return value.split(/\s+/).filter(Boolean);
+    }
+    return [];
+}
+function collectText(node) {
+    if (node.type === "text") {
+        return node.value ?? "";
+    }
+    return (node.children ?? []).map((child) => collectText(child)).join("");
+}

package/packages/markdown/dist/remark.d.ts

@@ -0,0 +1,9 @@
+import type { WorldOrbitMarkdownOptions } from "./types.js";
+interface MdNode {
+    type: string;
+    lang?: string | null;
+    value?: string;
+    children?: MdNode[];
+}
+export declare function remarkWorldOrbit(options?: WorldOrbitMarkdownOptions): (tree: MdNode) => void;
+export {};

package/packages/markdown/dist/remark.js

@@ -0,0 +1,28 @@
+import { renderWorldOrbitBlock } from "./html.js";
+export function remarkWorldOrbit(options = {}) {
+    return function transform(tree) {
+        visitMdNodes(tree, (node, index, parent) => {
+            if (!parent || index === -1 || node.type !== "code" || !isWorldOrbitLanguage(node.lang)) {
+                return;
+            }
+            parent.children[index] = {
+                type: "html",
+                value: renderWorldOrbitBlock(node.value ?? "", options),
+            };
+        });
+    };
+}
+function visitMdNodes(node, visitor, parent = null) {
+    const children = node.children ?? [];
+    for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        visitor(child, index, node);
+        visitMdNodes(child, visitor, node);
+    }
+    if (!parent) {
+        visitor(node, -1, null);
+    }
+}
+function isWorldOrbitLanguage(language) {
+    return (language ?? "").trim().toLowerCase() === "worldorbit";
+}

package/packages/markdown/dist/types.d.ts

@@ -0,0 +1,11 @@
+import type { SvgRenderOptions, ViewerAtlasState, ViewerFilter, WorldOrbitEmbedMode } from "@worldorbit/viewer";
+export interface WorldOrbitMarkdownOptions extends SvgRenderOptions {
+    mode?: WorldOrbitEmbedMode;
+    strict?: boolean;
+    className?: string;
+    initialViewpointId?: string;
+    initialSelectionObjectId?: string;
+    initialFilter?: ViewerFilter | null;
+    atlasState?: ViewerAtlasState | null;
+    minimap?: boolean;
+}

package/packages/markdown/dist/types.js

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

package/packages/viewer/dist/atlas-state.js

@@ -64,12 +64,14 @@ export function createAtlasStateSnapshot(viewerState, renderOptions, filter, vie
     return {
         version: "2.0",
         viewpointId,
+        activeEventId: renderOptions.activeEventId ?? null,
         viewerState: { ...viewerState },
         renderOptions: {
             preset: renderOptions.preset,
             projection: renderOptions.projection,
             layers: renderOptions.layers ? { ...renderOptions.layers } : undefined,
             scaleModel: renderOptions.scaleModel ? { ...renderOptions.scaleModel } : undefined,
+            activeEventId: renderOptions.activeEventId ?? null,
         },
         filter: normalizeViewerFilter(filter),
     };
@@ -82,6 +84,7 @@ export function deserializeViewerAtlasState(serialized) {
     return {
         version: "2.0",
         viewpointId: raw.viewpointId ?? null,
+        activeEventId: raw.activeEventId ?? raw.renderOptions?.activeEventId ?? null,
         viewerState: {
             scale: raw.viewerState?.scale ?? 1,
             rotationDeg: raw.viewerState?.rotationDeg ?? 0,
@@ -96,6 +99,7 @@ export function deserializeViewerAtlasState(serialized) {
             scaleModel: raw.renderOptions?.scaleModel
                 ? { ...raw.renderOptions.scaleModel }
                 : undefined,
+            activeEventId: raw.activeEventId ?? raw.renderOptions?.activeEventId ?? null,
         },
         filter: normalizeViewerFilter(raw.filter ?? null),
     };
@@ -117,6 +121,7 @@ export function createViewerBookmark(name, label, atlasState) {
                 scaleModel: atlasState.renderOptions.scaleModel
                     ? { ...atlasState.renderOptions.scaleModel }
                     : undefined,
+                activeEventId: atlasState.renderOptions.activeEventId ?? null,
             },
             filter: atlasState.filter ? { ...atlasState.filter } : null,
         },
@@ -134,6 +139,7 @@ export function sceneViewpointToLayerOptions(viewpoint) {
         background: viewpoint.layers.background,
         guides: viewpoint.layers.guides,
         relations: viewpoint.layers.relations,
+        events: viewpoint.layers.events,
         orbits: viewpoint.layers["orbits-front"] === undefined && viewpoint.layers["orbits-back"] === undefined
             ? undefined
             : viewpoint.layers["orbits-front"] !== false || viewpoint.layers["orbits-back"] !== false,

package/packages/viewer/dist/atlas-viewer.js

@@ -339,6 +339,7 @@ export function createAtlasViewer(container, options) {
                 groupCount: activeViewer.getScene().groups.length,
                 semanticGroupCount: activeViewer.getScene().semanticGroups.length,
                 relationCount: activeViewer.getScene().relations.length,
+                eventCount: activeViewer.getScene().events.length,
                 viewpointCount: activeViewer.getScene().viewpoints.length,
             },
         };

package/packages/viewer/dist/render.js

@@ -39,6 +39,12 @@ export function renderSceneToSvg(scene, options = {}) {
             .map((relation) => `<line class="wo-relation" x1="${relation.x1}" y1="${relation.y1}" x2="${relation.x2}" y2="${relation.y2}" data-render-id="${escapeXml(relation.renderId)}" data-relation-id="${escapeAttribute(relation.relationId)}" />`)
             .join("")
         : "";
+    const eventMarkup = layers.events
+        ? scene.events
+            .filter((event) => !event.hidden)
+            .map((event) => renderSceneEventOverlay(scene, event, visibleObjectIds, theme))
+            .join("")
+        : "";
     const objectMarkup = layers.objects
         ? visibleObjects
             .map((object) => renderSceneObject(object, options.selectedObjectId ?? null, theme))
@@ -86,6 +92,9 @@ export function renderSceneToSvg(scene, options = {}) {
     .wo-orbit-front { opacity: 0.9; }
     .wo-orbit-band { stroke: ${theme.orbitBand}; stroke-linecap: round; }
     .wo-relation { stroke: ${theme.relation}; stroke-width: 2; stroke-dasharray: 10 6; }
+    .wo-event-line { stroke: ${theme.accent}; stroke-width: 1.6; stroke-dasharray: 5 5; opacity: 0.72; }
+    .wo-event-node { fill: ${theme.accent}; stroke: ${theme.selected}; stroke-width: 1.4; opacity: 0.92; }
+    .wo-event-label { fill: ${theme.accent}; font-family: ${theme.fontFamily}; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
     .wo-leader { stroke: ${theme.leader}; stroke-width: 1.5; stroke-dasharray: 6 5; }
     .wo-label { fill: ${theme.ink}; font-family: ${theme.fontFamily}; font-weight: 600; letter-spacing: 0.02em; }
     .wo-label-secondary { fill: ${theme.muted}; font-family: ${theme.fontFamily}; font-weight: 500; }
@@ -120,14 +129,34 @@ export function renderSceneToSvg(scene, options = {}) {
         ${layers.orbits ? `<g data-layer-id="orbits-back">${orbitMarkup.back}</g>` : ""}
         ${layers.guides ? `<g data-layer-id="guides">${leaderMarkup}</g>` : ""}
         ${layers.relations ? `<g data-layer-id="relations">${relationMarkup}</g>` : ""}
+        ${layers.events ? `<g data-layer-id="events">${eventMarkup}</g>` : ""}
         ${layers.objects ? `<g data-layer-id="objects">${objectMarkup}</g>` : ""}
-        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
-        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
+        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
+        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
       </g>
     </g>
   </g>
 </svg>`;
 }
+function renderSceneEventOverlay(scene, event, visibleObjectIds, theme) {
+    const participants = event.objectIds
+        .filter((objectId) => visibleObjectIds.has(objectId))
+        .map((objectId) => scene.objects.find((object) => object.objectId === objectId && !object.hidden))
+        .filter(Boolean);
+    if (participants.length === 0) {
+        return "";
+    }
+    const stroke = event.event.color || theme.accent;
+    const label = event.event.label || event.event.id;
+    const lineMarkup = participants
+        .map((object) => `<line class="wo-event-line" x1="${event.x}" y1="${event.y}" x2="${object.x}" y2="${object.y}" stroke="${escapeAttribute(stroke)}" data-event-id="${escapeAttribute(event.eventId)}" data-object-id="${escapeAttribute(object.objectId)}" />`)
+        .join("");
+    return `<g class="wo-event" data-render-id="${escapeXml(event.renderId)}" data-event-id="${escapeAttribute(event.eventId)}">
+    ${lineMarkup}
+    <circle class="wo-event-node" cx="${event.x}" cy="${event.y}" r="5" fill="${escapeAttribute(stroke)}" />
+    <text class="wo-event-label" x="${event.x}" y="${event.y - 10}" text-anchor="middle" font-size="10">${escapeXml(label)}</text>
+  </g>`;
+}
 export function renderDocumentToSvg(document, options = {}) {
     return renderSceneToSvg(renderDocumentToScene(document, options), options);
 }

package/packages/viewer/dist/theme.js

@@ -2,6 +2,7 @@ const DEFAULT_LAYERS = {
     background: true,
     guides: true,
     relations: true,
+    events: true,
     orbits: true,
     objects: true,
     labels: true,

package/packages/viewer/dist/tooltip.js

@@ -111,6 +111,15 @@ function buildTooltipFields(details) {
             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",

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

@@ -1,4 +1,4 @@
-import type { CoordinatePoint, RenderOrbitVisual, RenderPresetName, RenderSceneGroup, RenderSceneLabel, RenderScaleModel, RenderScene, RenderSceneObject, RenderSceneViewpoint, SceneRenderOptions, ViewProjection, WorldOrbitObject, WorldOrbitDocument } from "@worldorbit/core";
+import type { CoordinatePoint, RenderOrbitVisual, RenderPresetName, RenderSceneEvent, 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";
@@ -29,6 +29,7 @@ export interface ViewerLayerOptions {
     background?: boolean;
     guides?: boolean;
     relations?: boolean;
+    events?: boolean;
     orbits?: boolean;
     objects?: boolean;
     labels?: boolean;
@@ -79,6 +80,7 @@ export interface ViewerObjectDetails {
     orbit: RenderOrbitVisual | null;
     relatedOrbits: RenderOrbitVisual[];
     relations: RenderScene["relations"];
+    relatedEvents: RenderSceneEvent[];
     parent: RenderSceneObject | null;
     children: RenderSceneObject[];
     ancestors: RenderSceneObject[];
@@ -104,12 +106,14 @@ export interface ViewerTooltipDetails {
 export interface ViewerAtlasState {
     version: "2.0";
     viewpointId: string | null;
+    activeEventId?: string | null;
     viewerState: ViewerState;
     renderOptions: {
         preset?: RenderPresetName;
         projection?: "document" | ViewProjection;
         layers?: ViewerLayerOptions;
         scaleModel?: Partial<RenderScaleModel>;
+        activeEventId?: string | null;
     };
     filter: ViewerFilter | null;
 }
@@ -139,6 +143,7 @@ export interface AtlasInspectorSnapshot {
         groupCount: number;
         semanticGroupCount: number;
         relationCount: number;
+        eventCount: number;
         viewpointCount: number;
     };
 }
@@ -189,6 +194,8 @@ export interface WorldOrbitViewer {
     listViewpoints(): RenderSceneViewpoint[];
     getActiveViewpoint(): RenderSceneViewpoint | null;
     goToViewpoint(id: string): boolean;
+    getActiveEventId(): string | null;
+    setActiveEvent(id: string | null): void;
     search(query: string, limit?: number): ViewerSearchResult[];
     getFilter(): ViewerFilter | null;
     setFilter(filter: ViewerFilter | null): void;

package/packages/viewer/dist/viewer.js

@@ -355,6 +355,12 @@ export function createInteractiveViewer(container, options) {
             emitAtlasStateChange();
             return true;
         },
+        getActiveEventId() {
+            return renderOptions.activeEventId ?? null;
+        },
+        setActiveEvent(id) {
+            api.setRenderOptions({ activeEventId: id });
+        },
         search(query, limit = 12) {
             return searchSceneObjects(scene, query, limit);
         },
@@ -653,6 +659,9 @@ export function createInteractiveViewer(container, options) {
             relations: scene.relations.filter((relation) => !relation.hidden &&
                 (relation.fromObjectId === renderObject.objectId ||
                     relation.toObjectId === renderObject.objectId)),
+            relatedEvents: scene.events.filter((event) => !event.hidden &&
+                (event.targetObjectId === renderObject.objectId ||
+                    event.objectIds.includes(renderObject.objectId))),
             parent: getObjectById(renderObject.parentId),
             children: renderObject.childIds.map((childId) => getObjectById(childId)).filter(Boolean),
             ancestors: renderObject.ancestorIds
@@ -989,6 +998,7 @@ function cloneRenderOptions(renderOptions) {
         theme: renderOptions.theme && typeof renderOptions.theme === "object"
             ? { ...renderOptions.theme }
             : renderOptions.theme,
+        activeEventId: renderOptions.activeEventId ?? null,
     };
 }
 function mergeRenderOptions(current, next) {
@@ -1027,7 +1037,8 @@ function hasSceneAffectingRenderOptions(options) {
         options.padding !== undefined ||
         options.preset !== undefined ||
         options.projection !== undefined ||
-        options.scaleModel !== undefined);
+        options.scaleModel !== undefined ||
+        options.activeEventId !== undefined);
 }
 function resolveSourceRenderOptions(loaded, renderOptions) {
     const atlasDocument = loaded.atlasDocument ?? loaded.draftDocument;