worldorbit 2.5.2

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,53 @@
+import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, 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;
+    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[];
+    objects: WorldOrbitObject[];
+}

package/packages/editor/dist/types.js

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

package/packages/markdown/README.md

@@ -0,0 +1,9 @@
+# @worldorbit/markdown
+
+WorldOrbit markdown contains build-time integration for fenced `worldorbit` blocks in Unified, Remark, and Rehype pipelines.
+
+Main exports:
+
+- `renderWorldOrbitBlock(source, options?)`
+- `remarkWorldOrbit(options?)`
+- `rehypeWorldOrbit(options?)`

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/README.md

@@ -0,0 +1,12 @@
+# @worldorbit/viewer
+
+WorldOrbit viewer contains scene-to-SVG rendering, theme presets, browser interactivity, and embed hydration helpers.
+
+Main exports:
+
+- `renderSceneToSvg(scene, options?)`
+- `renderDocumentToSvg(document, options?)`
+- `renderSourceToSvg(source, options?)`
+- `createInteractiveViewer(container, options)`
+- `createWorldOrbitEmbedMarkup(payload, options?)`
+- `mountWorldOrbitEmbeds(root?, options?)`

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

@@ -0,0 +1,12 @@
+import type { RenderScene, RenderSceneViewpoint } from "@worldorbit/core";
+import type { ViewerAtlasState, ViewerBookmark, ViewerFilter, ViewerLayerOptions, ViewerRenderOptions, ViewerSearchResult, ViewerState } from "./types.js";
+export declare function normalizeViewerFilter(filter: ViewerFilter | null | undefined): ViewerFilter | null;
+export declare function isViewerFilterActive(filter: ViewerFilter | null | undefined): boolean;
+export declare function computeVisibleObjectIds(scene: RenderScene, filter: ViewerFilter | null | undefined): Set<string>;
+export declare function searchSceneObjects(scene: RenderScene, query: string, limit?: number): ViewerSearchResult[];
+export declare function createAtlasStateSnapshot(viewerState: ViewerState, renderOptions: ViewerRenderOptions, filter: ViewerFilter | null, viewpointId: string | null): ViewerAtlasState;
+export declare function serializeViewerAtlasState(state: ViewerAtlasState): string;
+export declare function deserializeViewerAtlasState(serialized: string): ViewerAtlasState;
+export declare function createViewerBookmark(name: string, label: string | undefined, atlasState: ViewerAtlasState): ViewerBookmark;
+export declare function sceneViewpointToLayerOptions(viewpoint: RenderSceneViewpoint | null | undefined): ViewerLayerOptions | undefined;
+export declare function viewpointToViewerFilter(viewpoint: RenderSceneViewpoint | null | undefined): ViewerFilter | null;

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

@@ -0,0 +1,251 @@
+export function normalizeViewerFilter(filter) {
+    if (!filter) {
+        return null;
+    }
+    const normalized = {
+        query: filter.query?.trim() || undefined,
+        objectTypes: dedupeList(filter.objectTypes ?? []),
+        tags: dedupeList((filter.tags ?? []).map((tag) => tag.trim()).filter(Boolean)),
+        groupIds: dedupeList((filter.groupIds ?? []).map((groupId) => groupId.trim()).filter(Boolean)),
+        includeAncestors: filter.includeAncestors ?? true,
+    };
+    return isViewerFilterActive(normalized) ? normalized : null;
+}
+export function isViewerFilterActive(filter) {
+    return Boolean(filter &&
+        (filter.query?.trim() ||
+            filter.objectTypes?.length ||
+            filter.tags?.length ||
+            filter.groupIds?.length));
+}
+export function computeVisibleObjectIds(scene, filter) {
+    const normalized = normalizeViewerFilter(filter);
+    const visible = new Set();
+    for (const object of scene.objects) {
+        if (object.hidden) {
+            continue;
+        }
+        if (matchesObjectFilter(object, normalized)) {
+            visible.add(object.objectId);
+            if (normalized?.includeAncestors !== false) {
+                for (const ancestorId of object.ancestorIds) {
+                    visible.add(ancestorId);
+                }
+            }
+        }
+    }
+    if (!normalized) {
+        return new Set(scene.objects.filter((object) => !object.hidden).map((object) => object.objectId));
+    }
+    return visible;
+}
+export function searchSceneObjects(scene, query, limit = 12) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return scene.objects
+            .filter((object) => !object.hidden)
+            .slice()
+            .sort((left, right) => left.label.localeCompare(right.label))
+            .slice(0, limit)
+            .map((object) => createSearchResult(object, 1));
+    }
+    return scene.objects
+        .filter((object) => !object.hidden)
+        .map((object) => ({
+        object,
+        score: scoreSearchMatch(object, normalizedQuery),
+    }))
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score || left.object.label.localeCompare(right.object.label))
+        .slice(0, limit)
+        .map((entry) => createSearchResult(entry.object, entry.score));
+}
+export function createAtlasStateSnapshot(viewerState, renderOptions, filter, viewpointId) {
+    return {
+        version: "2.0",
+        viewpointId,
+        viewerState: { ...viewerState },
+        renderOptions: {
+            preset: renderOptions.preset,
+            projection: renderOptions.projection,
+            layers: renderOptions.layers ? { ...renderOptions.layers } : undefined,
+            scaleModel: renderOptions.scaleModel ? { ...renderOptions.scaleModel } : undefined,
+        },
+        filter: normalizeViewerFilter(filter),
+    };
+}
+export function serializeViewerAtlasState(state) {
+    return encodeURIComponent(JSON.stringify(state));
+}
+export function deserializeViewerAtlasState(serialized) {
+    const raw = JSON.parse(decodeURIComponent(serialized));
+    return {
+        version: "2.0",
+        viewpointId: raw.viewpointId ?? null,
+        viewerState: {
+            scale: raw.viewerState?.scale ?? 1,
+            rotationDeg: raw.viewerState?.rotationDeg ?? 0,
+            translateX: raw.viewerState?.translateX ?? 0,
+            translateY: raw.viewerState?.translateY ?? 0,
+            selectedObjectId: raw.viewerState?.selectedObjectId ?? null,
+        },
+        renderOptions: {
+            preset: raw.renderOptions?.preset,
+            projection: raw.renderOptions?.projection,
+            layers: raw.renderOptions?.layers ? { ...raw.renderOptions.layers } : undefined,
+            scaleModel: raw.renderOptions?.scaleModel
+                ? { ...raw.renderOptions.scaleModel }
+                : undefined,
+        },
+        filter: normalizeViewerFilter(raw.filter ?? null),
+    };
+}
+export function createViewerBookmark(name, label, atlasState) {
+    const normalizedName = name.trim() || "bookmark";
+    return {
+        id: normalizedName
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]+/g, "-")
+            .replace(/^-+|-+$/g, "") || "bookmark",
+        label: label?.trim() || normalizedName,
+        atlasState: {
+            ...atlasState,
+            viewerState: { ...atlasState.viewerState },
+            renderOptions: {
+                ...atlasState.renderOptions,
+                layers: atlasState.renderOptions.layers ? { ...atlasState.renderOptions.layers } : undefined,
+                scaleModel: atlasState.renderOptions.scaleModel
+                    ? { ...atlasState.renderOptions.scaleModel }
+                    : undefined,
+            },
+            filter: atlasState.filter ? { ...atlasState.filter } : null,
+        },
+    };
+}
+export function sceneViewpointToLayerOptions(viewpoint) {
+    if (!viewpoint) {
+        return undefined;
+    }
+    const hasLayerState = Object.keys(viewpoint.layers).length > 0;
+    if (!hasLayerState) {
+        return undefined;
+    }
+    return {
+        background: viewpoint.layers.background,
+        guides: viewpoint.layers.guides,
+        orbits: viewpoint.layers["orbits-front"] === undefined && viewpoint.layers["orbits-back"] === undefined
+            ? undefined
+            : viewpoint.layers["orbits-front"] !== false || viewpoint.layers["orbits-back"] !== false,
+        objects: viewpoint.layers.objects,
+        labels: viewpoint.layers.labels,
+        metadata: viewpoint.layers.metadata,
+    };
+}
+export function viewpointToViewerFilter(viewpoint) {
+    if (!viewpoint?.filter) {
+        return null;
+    }
+    return normalizeViewerFilter({
+        query: viewpoint.filter.query ?? undefined,
+        objectTypes: viewpoint.filter.objectTypes,
+        tags: viewpoint.filter.tags,
+        groupIds: viewpoint.filter.groupIds,
+        includeAncestors: true,
+    });
+}
+function createSearchResult(object, score) {
+    return {
+        objectId: object.objectId,
+        label: object.label,
+        type: object.object.type,
+        score,
+        groupId: object.groupId,
+        parentId: object.parentId,
+        tags: Array.isArray(object.object.properties.tags)
+            ? object.object.properties.tags.filter((entry) => typeof entry === "string")
+            : [],
+    };
+}
+function matchesObjectFilter(object, filter) {
+    if (!filter) {
+        return true;
+    }
+    if (filter.objectTypes?.length && !filter.objectTypes.includes(object.object.type)) {
+        return false;
+    }
+    if (filter.groupIds?.length && (!object.groupId || !filter.groupIds.includes(object.groupId))) {
+        return false;
+    }
+    if (filter.tags?.length) {
+        const objectTags = Array.isArray(object.object.properties.tags)
+            ? object.object.properties.tags.filter((entry) => typeof entry === "string")
+            : [];
+        if (!filter.tags.every((tag) => objectTags.includes(tag))) {
+            return false;
+        }
+    }
+    if (filter.query?.trim()) {
+        const haystack = buildSearchText(object.object, object.label).toLowerCase();
+        const tokens = filter.query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(Boolean);
+        if (!tokens.every((token) => haystack.includes(token))) {
+            return false;
+        }
+    }
+    return true;
+}
+function scoreSearchMatch(object, query) {
+    const id = object.objectId.toLowerCase();
+    const label = object.label.toLowerCase();
+    const haystack = buildSearchText(object.object, object.label).toLowerCase();
+    let score = 0;
+    if (id === query || label === query) {
+        score += 120;
+    }
+    else if (id.startsWith(query) || label.startsWith(query)) {
+        score += 96;
+    }
+    else if (id.includes(query) || label.includes(query)) {
+        score += 72;
+    }
+    const tokens = query.split(/\s+/).filter(Boolean);
+    if (tokens.every((token) => haystack.includes(token))) {
+        score += 32;
+    }
+    if (object.object.type === query) {
+        score += 24;
+    }
+    const tags = Array.isArray(object.object.properties.tags)
+        ? object.object.properties.tags.filter((entry) => typeof entry === "string")
+        : [];
+    if (tags.some((tag) => tag.toLowerCase() === query)) {
+        score += 18;
+    }
+    return score;
+}
+function buildSearchText(object, label) {
+    const infoValues = Object.values(object.info);
+    const propertyValues = Object.values(object.properties)
+        .flatMap((value) => {
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === "object" && value && "value" in value) {
+            return [String(value.value), String(value.unit ?? "")];
+        }
+        return [String(value)];
+    })
+        .filter(Boolean);
+    return [
+        object.id,
+        label,
+        object.type,
+        ...propertyValues,
+        ...infoValues,
+    ].join(" ");
+}
+function dedupeList(values) {
+    return [...new Set(values)];
+}

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

@@ -0,0 +1,2 @@
+import type { AtlasViewerOptions, WorldOrbitAtlasViewer } from "./types.js";
+export declare function createAtlasViewer(container: HTMLElement, options: AtlasViewerOptions): WorldOrbitAtlasViewer;