worldorbit 2.5.10 → 2.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worldorbit",
-  "version": "2.5.10",
+  "version": "2.5.11",
   "description": "A text-based DSL and parser pipeline for orbital worldbuilding",
   "type": "module",
   "main": "./dist/unpkg/worldorbit.esm.js",

package/packages/editor/dist/editor.js

@@ -466,7 +466,9 @@ export function createWorldOrbitEditor(container, options = {}) {
         }
         renderToolbar();
         renderOutline();
-        renderInspector();
+        if (!inspector?.contains(document.activeElement)) {
+            renderInspector();
+        }
         renderStageOverlay();
         renderStatusBar();
         updateLiveRegion();
@@ -491,7 +493,11 @@ export function createWorldOrbitEditor(container, options = {}) {
         renderOutline();
         renderDiagnostics();
         renderSourceDiagnostics();
-        renderInspector();
+        // Do not rebuild the inspector DOM if the user is currently typing in it, 
+        // to prevent losing focus/cursor position and making input glitchy.
+        if (!inspector?.contains(document.activeElement)) {
+            renderInspector();
+        }
         renderSourcePane();
         renderPreview(immediatePreview);
         renderStageOverlay();

package/packages/viewer/dist/viewer.js

@@ -109,6 +109,10 @@ export function createInteractiveViewer(container, options) {
             if (touchPoints.size === 2) {
                 touchGesture = createTouchGestureState(scene, state, touchPoints);
             }
+            else if (touchPoints.size === 1) {
+                dragDistance = 0;
+                suppressClick = false;
+            }
             return;
         }
         activePointerId = event.pointerId;
@@ -125,7 +129,9 @@ export function createInteractiveViewer(container, options) {
             if (!behavior.touch || !touchPoints.has(event.pointerId)) {
                 return;
             }
-            touchPoints.set(event.pointerId, getViewportPointFromClient(event.clientX, event.clientY));
+            const prevPoint = touchPoints.get(event.pointerId);
+            const nextPoint = getViewportPointFromClient(event.clientX, event.clientY);
+            touchPoints.set(event.pointerId, nextPoint);
             if (touchPoints.size === 2) {
                 if (!touchGesture) {
                     touchGesture = createTouchGestureState(scene, state, touchPoints);
@@ -137,6 +143,15 @@ export function createInteractiveViewer(container, options) {
                 const deltaY = current.center.y - touchGesture.startViewportCenter.y;
                 updateState(panViewerState(zoomedState, deltaX, deltaY));
             }
+            else if (touchPoints.size === 1) {
+                const deltaX = nextPoint.x - prevPoint.x;
+                const deltaY = nextPoint.y - prevPoint.y;
+                dragDistance += Math.abs(deltaX) + Math.abs(deltaY);
+                if (dragDistance > 2) {
+                    suppressClick = true;
+                }
+                updateState(panViewerState(state, deltaX, deltaY));
+            }
             return;
         }
         if (!behavior.pointer || activePointerId !== event.pointerId || !lastPointerPoint) {

package/packages/core/dist/atlas-edit.d.ts

@@ -1,11 +0,0 @@
-import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitDiagnostic } from "./types.js";
-export declare function createEmptyAtlasDocument(systemId?: string): WorldOrbitAtlasDocument;
-export declare function cloneAtlasDocument(document: WorldOrbitAtlasDocument): WorldOrbitAtlasDocument;
-export declare function listAtlasDocumentPaths(document: WorldOrbitAtlasDocument): AtlasDocumentPath[];
-export declare function getAtlasDocumentNode(document: WorldOrbitAtlasDocument, path: AtlasDocumentPath): unknown;
-export declare function upsertAtlasDocumentNode(document: WorldOrbitAtlasDocument, path: AtlasDocumentPath, value: unknown): WorldOrbitAtlasDocument;
-export declare function updateAtlasDocumentNode(document: WorldOrbitAtlasDocument, path: AtlasDocumentPath, updater: (value: unknown) => unknown): WorldOrbitAtlasDocument;
-export declare function removeAtlasDocumentNode(document: WorldOrbitAtlasDocument, path: AtlasDocumentPath): WorldOrbitAtlasDocument;
-export declare function resolveAtlasDiagnostics(document: WorldOrbitAtlasDocument, diagnostics: WorldOrbitDiagnostic[]): AtlasResolvedDiagnostic[];
-export declare function resolveAtlasDiagnosticPath(document: WorldOrbitAtlasDocument, diagnostic: WorldOrbitDiagnostic): AtlasDocumentPath | null;
-export declare function validateAtlasDocumentWithDiagnostics(document: WorldOrbitAtlasDocument): AtlasResolvedDiagnostic[];

package/packages/core/dist/atlas-edit.js

@@ -1,210 +0,0 @@
-import { materializeAtlasDocument } from "./draft.js";
-import { validateDocumentWithDiagnostics } from "./diagnostics.js";
-export function createEmptyAtlasDocument(systemId = "WorldOrbit") {
-    return {
-        format: "worldorbit",
-        version: "2.0",
-        sourceVersion: "1.0",
-        system: {
-            type: "system",
-            id: systemId,
-            title: systemId,
-            defaults: {
-                view: "topdown",
-                scale: null,
-                units: null,
-                preset: null,
-                theme: null,
-            },
-            atlasMetadata: {},
-            viewpoints: [],
-            annotations: [],
-        },
-        objects: [],
-        diagnostics: [],
-    };
-}
-export function cloneAtlasDocument(document) {
-    return structuredClone(document);
-}
-export function listAtlasDocumentPaths(document) {
-    const paths = [{ kind: "system" }, { kind: "defaults" }];
-    if (document.system) {
-        for (const key of Object.keys(document.system.atlasMetadata).sort()) {
-            paths.push({ kind: "metadata", key });
-        }
-        for (const viewpoint of [...document.system.viewpoints].sort(compareIdLike)) {
-            paths.push({ kind: "viewpoint", id: viewpoint.id });
-        }
-        for (const annotation of [...document.system.annotations].sort(compareIdLike)) {
-            paths.push({ kind: "annotation", id: annotation.id });
-        }
-    }
-    for (const object of [...document.objects].sort(compareIdLike)) {
-        paths.push({ kind: "object", id: object.id });
-    }
-    return paths;
-}
-export function getAtlasDocumentNode(document, path) {
-    switch (path.kind) {
-        case "system":
-            return document.system;
-        case "defaults":
-            return document.system?.defaults ?? null;
-        case "metadata":
-            return path.key ? (document.system?.atlasMetadata[path.key] ?? null) : null;
-        case "object":
-            return path.id ? findObject(document, path.id) : null;
-        case "viewpoint":
-            return path.id ? findViewpoint(document.system, path.id) : null;
-        case "annotation":
-            return path.id ? findAnnotation(document.system, path.id) : null;
-    }
-}
-export function upsertAtlasDocumentNode(document, path, value) {
-    const next = cloneAtlasDocument(document);
-    const system = ensureSystem(next);
-    switch (path.kind) {
-        case "system":
-            next.system = value;
-            return next;
-        case "defaults":
-            system.defaults = {
-                ...system.defaults,
-                ...value,
-            };
-            return next;
-        case "metadata":
-            if (!path.key) {
-                throw new Error('Metadata updates require a "key" value.');
-            }
-            if (value === null || value === undefined || value === "") {
-                delete system.atlasMetadata[path.key];
-            }
-            else {
-                system.atlasMetadata[path.key] = String(value);
-            }
-            return next;
-        case "object":
-            if (!path.id) {
-                throw new Error('Object updates require an "id" value.');
-            }
-            upsertById(next.objects, value);
-            return next;
-        case "viewpoint":
-            if (!path.id) {
-                throw new Error('Viewpoint updates require an "id" value.');
-            }
-            upsertById(system.viewpoints, value);
-            return next;
-        case "annotation":
-            if (!path.id) {
-                throw new Error('Annotation updates require an "id" value.');
-            }
-            upsertById(system.annotations, value);
-            return next;
-    }
-}
-export function updateAtlasDocumentNode(document, path, updater) {
-    return upsertAtlasDocumentNode(document, path, updater(getAtlasDocumentNode(document, path)));
-}
-export function removeAtlasDocumentNode(document, path) {
-    const next = cloneAtlasDocument(document);
-    const system = ensureSystem(next);
-    switch (path.kind) {
-        case "metadata":
-            if (path.key) {
-                delete system.atlasMetadata[path.key];
-            }
-            return next;
-        case "object":
-            if (path.id) {
-                next.objects = next.objects.filter((object) => object.id !== path.id);
-            }
-            return next;
-        case "viewpoint":
-            if (path.id) {
-                system.viewpoints = system.viewpoints.filter((viewpoint) => viewpoint.id !== path.id);
-            }
-            return next;
-        case "annotation":
-            if (path.id) {
-                system.annotations = system.annotations.filter((annotation) => annotation.id !== path.id);
-            }
-            return next;
-        default:
-            return next;
-    }
-}
-export function resolveAtlasDiagnostics(document, diagnostics) {
-    return diagnostics.map((diagnostic) => ({
-        diagnostic,
-        path: resolveAtlasDiagnosticPath(document, diagnostic),
-    }));
-}
-export function resolveAtlasDiagnosticPath(document, diagnostic) {
-    if (diagnostic.objectId && findObject(document, diagnostic.objectId)) {
-        return {
-            kind: "object",
-            id: diagnostic.objectId,
-        };
-    }
-    if (diagnostic.field?.startsWith("viewpoint.")) {
-        const parts = diagnostic.field.split(".");
-        if (parts[1] && findViewpoint(document.system, parts[1])) {
-            return {
-                kind: "viewpoint",
-                id: parts[1],
-            };
-        }
-    }
-    if (diagnostic.field?.startsWith("annotation.")) {
-        const parts = diagnostic.field.split(".");
-        if (parts[1] && findAnnotation(document.system, parts[1])) {
-            return {
-                kind: "annotation",
-                id: parts[1],
-            };
-        }
-    }
-    if (diagnostic.field && diagnostic.field in ensureSystem(document).atlasMetadata) {
-        return {
-            kind: "metadata",
-            key: diagnostic.field,
-        };
-    }
-    return null;
-}
-export function validateAtlasDocumentWithDiagnostics(document) {
-    const materialized = materializeAtlasDocument(document);
-    const result = validateDocumentWithDiagnostics(materialized);
-    return resolveAtlasDiagnostics(document, result.diagnostics);
-}
-function ensureSystem(document) {
-    if (document.system) {
-        return document.system;
-    }
-    document.system = createEmptyAtlasDocument().system;
-    return document.system;
-}
-function findObject(document, objectId) {
-    return document.objects.find((object) => object.id === objectId) ?? null;
-}
-function findViewpoint(system, viewpointId) {
-    return system?.viewpoints.find((viewpoint) => viewpoint.id === viewpointId) ?? null;
-}
-function findAnnotation(system, annotationId) {
-    return system?.annotations.find((annotation) => annotation.id === annotationId) ?? null;
-}
-function upsertById(items, value) {
-    const index = items.findIndex((item) => item.id === value.id);
-    if (index === -1) {
-        items.push(value);
-        items.sort(compareIdLike);
-        return;
-    }
-    items[index] = value;
-}
-function compareIdLike(left, right) {
-    return left.id.localeCompare(right.id);
-}

package/packages/core/dist/diagnostics.d.ts

@@ -1,10 +0,0 @@
-import type { AstDocument, DiagnosticResult, WorldOrbitDiagnostic, WorldOrbitDiagnosticSource, WorldOrbitDocument } from "./types.js";
-export interface ParsedWorldOrbitDocument {
-    ast: AstDocument;
-    document: WorldOrbitDocument;
-}
-export declare function createDiagnostic(diagnostic: WorldOrbitDiagnostic): WorldOrbitDiagnostic;
-export declare function diagnosticFromError(error: unknown, source: WorldOrbitDiagnosticSource, code?: string): WorldOrbitDiagnostic;
-export declare function parseWithDiagnostics(source: string): DiagnosticResult<ParsedWorldOrbitDocument>;
-export declare function normalizeWithDiagnostics(ast: AstDocument): DiagnosticResult<WorldOrbitDocument>;
-export declare function validateDocumentWithDiagnostics(document: WorldOrbitDocument): DiagnosticResult<WorldOrbitDocument>;

package/packages/core/dist/diagnostics.js

@@ -1,109 +0,0 @@
-import { WorldOrbitError } from "./errors.js";
-import { normalizeDocument } from "./normalize.js";
-import { parseWorldOrbit } from "./parse.js";
-import { validateDocument } from "./validate.js";
-export function createDiagnostic(diagnostic) {
-    return { ...diagnostic };
-}
-export function diagnosticFromError(error, source, code = `${source}.failed`) {
-    if (error instanceof WorldOrbitError) {
-        return {
-            code,
-            severity: "error",
-            source,
-            message: error.message,
-            line: error.line,
-            column: error.column,
-        };
-    }
-    if (error instanceof Error) {
-        return {
-            code,
-            severity: "error",
-            source,
-            message: error.message,
-        };
-    }
-    return {
-        code,
-        severity: "error",
-        source,
-        message: String(error),
-    };
-}
-export function parseWithDiagnostics(source) {
-    let ast;
-    try {
-        ast = parseWorldOrbit(source);
-    }
-    catch (error) {
-        const diagnostic = diagnosticFromError(error, "parse");
-        return {
-            ok: false,
-            value: null,
-            diagnostics: [diagnostic],
-        };
-    }
-    let document;
-    try {
-        document = normalizeDocument(ast);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            value: null,
-            diagnostics: [diagnosticFromError(error, "normalize")],
-        };
-    }
-    try {
-        validateDocument(document);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            value: null,
-            diagnostics: [diagnosticFromError(error, "validate")],
-        };
-    }
-    return {
-        ok: true,
-        value: {
-            ast,
-            document,
-        },
-        diagnostics: [],
-    };
-}
-export function normalizeWithDiagnostics(ast) {
-    try {
-        return {
-            ok: true,
-            value: normalizeDocument(ast),
-            diagnostics: [],
-        };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            value: null,
-            diagnostics: [diagnosticFromError(error, "normalize")],
-        };
-    }
-}
-export function validateDocumentWithDiagnostics(document) {
-    try {
-        validateDocument(document);
-        return {
-            ok: true,
-            value: document,
-            diagnostics: [],
-        };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            value: null,
-            diagnostics: [diagnosticFromError(error, "validate")],
-        };
-    }
-}

package/packages/core/dist/draft-parse.d.ts

@@ -1,3 +0,0 @@
-import type { WorldOrbitAtlasDocument, WorldOrbitDraftDocument } from "./types.js";
-export declare function parseWorldOrbitAtlas(source: string): WorldOrbitAtlasDocument;
-export declare function parseWorldOrbitDraft(source: string): WorldOrbitDraftDocument;