worldorbit 2.6.0 → 3.0.1

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

@@ -0,0 +1,11 @@
+import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitAtlasDocumentVersion, WorldOrbitDiagnostic } from "./types.js";
+export declare function createEmptyAtlasDocument(systemId?: string, version?: WorldOrbitAtlasDocumentVersion): 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/dist/unpkg/core/dist/atlas-edit.js

@@ -0,0 +1,347 @@
+import { collectAtlasDiagnostics } from "./atlas-validate.js";
+export function createEmptyAtlasDocument(systemId = "WorldOrbit", version = "2.5") {
+    return {
+        format: "worldorbit",
+        version,
+        schemaVersion: version,
+        sourceVersion: "1.0",
+        system: {
+            type: "system",
+            id: systemId,
+            title: systemId,
+            description: null,
+            epoch: null,
+            referencePlane: null,
+            defaults: {
+                view: "topdown",
+                scale: null,
+                units: null,
+                preset: null,
+                theme: null,
+            },
+            atlasMetadata: {},
+            viewpoints: [],
+            annotations: [],
+        },
+        groups: [],
+        relations: [],
+        events: [],
+        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 group of [...document.groups].sort(compareIdLike)) {
+        paths.push({ kind: "group", id: group.id });
+    }
+    for (const relation of [...document.relations].sort(compareIdLike)) {
+        paths.push({ kind: "relation", id: relation.id });
+    }
+    for (const event of [...document.events].sort(compareIdLike)) {
+        paths.push({ kind: "event", id: event.id });
+        for (const pose of [...event.positions].sort(comparePoseObjectId)) {
+            paths.push({ kind: "event-pose", id: event.id, key: pose.objectId });
+        }
+    }
+    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 "group":
+            return path.id ? findGroup(document, path.id) : null;
+        case "event":
+            return path.id ? findEvent(document, path.id) : null;
+        case "event-pose":
+            return path.id && path.key ? findEventPose(document, path.id, path.key) : 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;
+        case "relation":
+            return path.id ? findRelation(document, 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 "group":
+            if (!path.id) {
+                throw new Error('Group updates require an "id" value.');
+            }
+            upsertById(next.groups, value);
+            return next;
+        case "event":
+            if (!path.id) {
+                throw new Error('Event updates require an "id" value.');
+            }
+            upsertById(next.events, value);
+            return next;
+        case "event-pose":
+            if (!path.id || !path.key) {
+                throw new Error('Event pose updates require an event "id" and pose "key" value.');
+            }
+            upsertEventPose(next.events, path.id, 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;
+        case "relation":
+            if (!path.id) {
+                throw new Error('Relation updates require an "id" value.');
+            }
+            upsertById(next.relations, 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 "group":
+            if (path.id) {
+                next.groups = next.groups.filter((group) => group.id !== path.id);
+            }
+            return next;
+        case "event":
+            if (path.id) {
+                next.events = next.events.filter((event) => event.id !== path.id);
+            }
+            return next;
+        case "event-pose":
+            if (path.id && path.key) {
+                const event = findEvent(next, path.id);
+                if (event) {
+                    event.positions = event.positions.filter((pose) => pose.objectId !== path.key);
+                }
+            }
+            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;
+        case "relation":
+            if (path.id) {
+                next.relations = next.relations.filter((relation) => relation.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("group.")) {
+        const parts = diagnostic.field.split(".");
+        if (parts[1] && findGroup(document, parts[1])) {
+            return {
+                kind: "group",
+                id: parts[1],
+            };
+        }
+    }
+    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?.startsWith("relation.")) {
+        const parts = diagnostic.field.split(".");
+        if (parts[1] && findRelation(document, parts[1])) {
+            return {
+                kind: "relation",
+                id: parts[1],
+            };
+        }
+    }
+    if (diagnostic.field?.startsWith("event.")) {
+        const parts = diagnostic.field.split(".");
+        if (parts[1] && findEvent(document, parts[1])) {
+            if (parts[2] === "pose" && parts[3] && findEventPose(document, parts[1], parts[3])) {
+                return {
+                    kind: "event-pose",
+                    id: parts[1],
+                    key: parts[3],
+                };
+            }
+            return {
+                kind: "event",
+                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 diagnostics = [
+        ...document.diagnostics,
+        ...collectAtlasDiagnostics(document, document.version),
+    ];
+    return resolveAtlasDiagnostics(document, 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 findGroup(document, groupId) {
+    return document.groups.find((group) => group.id === groupId) ?? null;
+}
+function findRelation(document, relationId) {
+    return document.relations.find((relation) => relation.id === relationId) ?? null;
+}
+function findEvent(document, eventId) {
+    return document.events.find((event) => event.id === eventId) ?? null;
+}
+function findEventPose(document, eventId, objectId) {
+    return findEvent(document, eventId)?.positions.find((pose) => pose.objectId === 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 upsertEventPose(events, eventId, value) {
+    const event = events.find((entry) => entry.id === eventId);
+    if (!event) {
+        throw new Error(`Unknown event "${eventId}" for pose update.`);
+    }
+    const index = event.positions.findIndex((entry) => entry.objectId === value.objectId);
+    if (index === -1) {
+        event.positions.push(value);
+        event.positions.sort(comparePoseObjectId);
+        return;
+    }
+    event.positions[index] = value;
+}
+function compareIdLike(left, right) {
+    return left.id.localeCompare(right.id);
+}
+function comparePoseObjectId(left, right) {
+    return left.objectId.localeCompare(right.objectId);
+}

package/dist/unpkg/core/dist/atlas-utils.d.ts

@@ -0,0 +1,22 @@
+import type { AstFieldNode, AstSourceLocation, AtReference, NormalizedValue, UnitValue, WorldOrbitObjectType } from "./types.js";
+export interface AtlasFieldLike {
+    key: string;
+    values: string[];
+    location: AstSourceLocation;
+}
+export declare function normalizeIdentifier(value: string): string;
+export declare function humanizeIdentifier(value: string): string;
+export declare function parseAtlasUnitValue(input: string, location?: AstSourceLocation, fieldKey?: string): UnitValue;
+export declare function tryParseAtlasUnitValue(input: string): UnitValue | null;
+export declare function parseAtlasNumber(input: string, key: string, location?: AstSourceLocation): number;
+export declare function parseAtlasBoolean(input: string, key: string, location?: AstSourceLocation): boolean;
+export declare function parseAtlasFieldBoolean(field: AtlasFieldLike): boolean;
+export declare function parseAtlasAtReference(target: string, location?: AstSourceLocation): AtReference;
+export declare function validateAtlasImageSource(value: string, location?: AstSourceLocation): void;
+export declare function normalizeLegacyScalarValue(key: string, values: string[], location: AstSourceLocation): NormalizedValue;
+export declare function ensureAtlasFieldSupported(key: string, objectType: WorldOrbitObjectType, location: AstSourceLocation): void;
+export declare function singleAtlasFieldValue(field: Pick<AtlasFieldLike, "key" | "values" | "location">): string;
+export declare function singleAtlasValue(values: string[], key: string, location?: AstSourceLocation): string;
+export declare function isStructureLikeObjectType(objectType: WorldOrbitObjectType): boolean;
+export declare function cloneNormalizedValue(value: NormalizedValue): NormalizedValue;
+export declare function cloneFieldNode(field: AstFieldNode): AstFieldNode;

package/dist/unpkg/core/dist/atlas-utils.js

@@ -0,0 +1,189 @@
+import { WorldOrbitError } from "./errors.js";
+import { getFieldSchema, unitFamilyAllowsUnit } from "./schema.js";
+const UNIT_PATTERN = /^(-?\d+(?:\.\d+)?)(kpc|min|mj|rj|ky|my|gy|au|km|me|re|pc|ly|deg|sol|K|m|s|h|d|y)?$/;
+const BOOLEAN_VALUES = new Map([
+    ["true", true],
+    ["false", false],
+    ["yes", true],
+    ["no", false],
+]);
+const URL_SCHEME_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+export function normalizeIdentifier(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function humanizeIdentifier(value) {
+    return value
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join(" ");
+}
+export function parseAtlasUnitValue(input, location, fieldKey) {
+    const match = input.match(UNIT_PATTERN);
+    if (!match) {
+        throw WorldOrbitError.fromLocation(`Invalid unit value "${input}"`, location);
+    }
+    const unitValue = {
+        value: Number(match[1]),
+        unit: match[2] ?? null,
+    };
+    if (fieldKey) {
+        const schema = getFieldSchema(fieldKey);
+        if (schema?.unitFamily && !unitFamilyAllowsUnit(schema.unitFamily, unitValue.unit)) {
+            throw WorldOrbitError.fromLocation(`Unit "${unitValue.unit ?? "none"}" is not valid for "${fieldKey}"`, location);
+        }
+    }
+    return unitValue;
+}
+export function tryParseAtlasUnitValue(input) {
+    const match = input.match(UNIT_PATTERN);
+    if (!match) {
+        return null;
+    }
+    return {
+        value: Number(match[1]),
+        unit: match[2] ?? null,
+    };
+}
+export function parseAtlasNumber(input, key, location) {
+    const value = Number(input);
+    if (!Number.isFinite(value)) {
+        throw WorldOrbitError.fromLocation(`Invalid numeric value "${input}" for "${key}"`, location);
+    }
+    return value;
+}
+export function parseAtlasBoolean(input, key, location) {
+    const parsed = BOOLEAN_VALUES.get(input.toLowerCase());
+    if (parsed === undefined) {
+        throw WorldOrbitError.fromLocation(`Invalid boolean value "${input}" for "${key}"`, location);
+    }
+    return parsed;
+}
+export function parseAtlasFieldBoolean(field) {
+    return parseAtlasBoolean(singleAtlasFieldValue(field), field.key, field.location);
+}
+export function parseAtlasAtReference(target, location) {
+    if (/^[A-Za-z0-9._-]+-[A-Za-z0-9._-]+:L\d+$/i.test(target)) {
+        throw WorldOrbitError.fromLocation(`Invalid special position "${target}"`, location);
+    }
+    const pairedMatch = target.match(/^([A-Za-z0-9._-]+)-([A-Za-z0-9._-]+):(L[1-5])$/);
+    if (pairedMatch) {
+        return {
+            kind: "lagrange",
+            primary: pairedMatch[1],
+            secondary: pairedMatch[2],
+            point: pairedMatch[3],
+        };
+    }
+    const simpleMatch = target.match(/^([A-Za-z0-9._-]+):(L[1-5])$/);
+    if (simpleMatch) {
+        return {
+            kind: "lagrange",
+            primary: simpleMatch[1],
+            secondary: null,
+            point: simpleMatch[2],
+        };
+    }
+    if (/^[A-Za-z0-9._-]+:L\d+$/i.test(target)) {
+        throw WorldOrbitError.fromLocation(`Invalid special position "${target}"`, location);
+    }
+    const anchorMatch = target.match(/^([A-Za-z0-9._-]+):([A-Za-z0-9._-]+)$/);
+    if (anchorMatch) {
+        return {
+            kind: "anchor",
+            objectId: anchorMatch[1],
+            anchor: anchorMatch[2],
+        };
+    }
+    return {
+        kind: "named",
+        name: target,
+    };
+}
+export function validateAtlasImageSource(value, location) {
+    if (!value) {
+        throw WorldOrbitError.fromLocation('Field "image" must not be empty', location);
+    }
+    if (value.startsWith("//")) {
+        throw WorldOrbitError.fromLocation('Field "image" must use a relative path, root-relative path, or an http/https URL', location);
+    }
+    const schemeMatch = value.match(URL_SCHEME_PATTERN);
+    if (!schemeMatch) {
+        return;
+    }
+    const scheme = schemeMatch[0].slice(0, -1).toLowerCase();
+    if (scheme !== "http" && scheme !== "https") {
+        throw WorldOrbitError.fromLocation(`Field "image" does not support the "${scheme}" scheme`, location);
+    }
+}
+export function normalizeLegacyScalarValue(key, values, location) {
+    const schema = getFieldSchema(key);
+    if (!schema) {
+        throw WorldOrbitError.fromLocation(`Unknown field "${key}"`, location);
+    }
+    if (schema.arity === "single" && values.length !== 1) {
+        throw WorldOrbitError.fromLocation(`Field "${key}" expects exactly one value`, location);
+    }
+    switch (schema.kind) {
+        case "list":
+            return values;
+        case "boolean":
+            return parseAtlasBoolean(singleAtlasValue(values, key, location), key, location);
+        case "number":
+            return parseAtlasNumber(singleAtlasValue(values, key, location), key, location);
+        case "unit":
+            return parseAtlasUnitValue(singleAtlasValue(values, key, location), location, key);
+        case "string": {
+            const value = values.join(" ").trim();
+            if (key === "image") {
+                validateAtlasImageSource(value, location);
+            }
+            return value;
+        }
+    }
+}
+export function ensureAtlasFieldSupported(key, objectType, location) {
+    const schema = getFieldSchema(key);
+    if (!schema) {
+        throw WorldOrbitError.fromLocation(`Unknown field "${key}"`, location);
+    }
+    if (!schema.objectTypes.includes(objectType)) {
+        throw WorldOrbitError.fromLocation(`Field "${key}" is not valid on "${objectType}"`, location);
+    }
+}
+export function singleAtlasFieldValue(field) {
+    return singleAtlasValue(field.values, field.key, field.location);
+}
+export function singleAtlasValue(values, key, location) {
+    if (values.length !== 1) {
+        throw WorldOrbitError.fromLocation(`Field "${key}" expects exactly one value`, location);
+    }
+    return values[0];
+}
+export function isStructureLikeObjectType(objectType) {
+    return objectType === "structure" || objectType === "phenomenon";
+}
+export function cloneNormalizedValue(value) {
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+    if (value && typeof value === "object" && "value" in value) {
+        return {
+            value: value.value,
+            unit: value.unit,
+        };
+    }
+    return value;
+}
+export function cloneFieldNode(field) {
+    return {
+        type: "field",
+        key: field.key,
+        values: [...field.values],
+        location: { ...field.location },
+    };
+}

package/dist/unpkg/core/dist/atlas-validate.d.ts

@@ -0,0 +1,2 @@
+import type { WorldOrbitAnyDocumentVersion, WorldOrbitAtlasDocument, WorldOrbitDiagnostic, WorldOrbitDraftDocument } from "./types.js";
+export declare function collectAtlasDiagnostics(document: WorldOrbitAtlasDocument | WorldOrbitDraftDocument, sourceSchemaVersion?: WorldOrbitAnyDocumentVersion): WorldOrbitDiagnostic[];