worldorbit 2.5.2

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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,109 @@
+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

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