worldorbit 2.5.2

package/packages/core/dist/format.js

@@ -0,0 +1,364 @@
+import { upgradeDocumentToDraftV2, upgradeDocumentToV2 } from "./draft.js";
+const CANONICAL_FIELD_ORDER = [
+    "title",
+    "view",
+    "scale",
+    "units",
+    "kind",
+    "class",
+    "tags",
+    "color",
+    "image",
+    "hidden",
+    "orbit",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "at",
+    "surface",
+    "free",
+    "radius",
+    "mass",
+    "density",
+    "gravity",
+    "temperature",
+    "albedo",
+    "atmosphere",
+    "inner",
+    "outer",
+    "on",
+    "source",
+    "cycle",
+];
+export function formatDocument(document, options = {}) {
+    const schema = options.schema ?? "auto";
+    const useDraft = schema === "2.0" ||
+        schema === "2.0-draft" ||
+        document.version === "2.0" ||
+        document.version === "2.0-draft";
+    if (useDraft) {
+        if (schema === "2.0-draft") {
+            const legacyDraftDocument = document.version === "2.0-draft"
+                ? document
+                : document.version === "2.0"
+                    ? {
+                        ...document,
+                        version: "2.0-draft",
+                    }
+                    : upgradeDocumentToDraftV2(document);
+            return formatDraftDocument(legacyDraftDocument);
+        }
+        const atlasDocument = document.version === "2.0"
+            ? document
+            : document.version === "2.0-draft"
+                ? {
+                    ...document,
+                    version: "2.0",
+                }
+                : upgradeDocumentToV2(document);
+        return formatAtlasDocument(atlasDocument);
+    }
+    const lines = [];
+    const stableDocument = document;
+    if (stableDocument.system) {
+        lines.push(...formatSystem(stableDocument.system));
+    }
+    const sortedObjects = [...stableDocument.objects].sort(compareObjects);
+    for (const object of sortedObjects) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push(...formatObject(object));
+    }
+    return lines.join("\n");
+}
+export function formatAtlasDocument(document) {
+    const lines = ["schema 2.0", ""];
+    if (document.system) {
+        lines.push(...formatAtlasSystem(document.system));
+    }
+    const sortedObjects = [...document.objects].sort(compareObjects);
+    if (sortedObjects.length > 0 && lines.at(-1) !== "") {
+        lines.push("");
+    }
+    sortedObjects.forEach((object, index) => {
+        if (index > 0) {
+            lines.push("");
+        }
+        lines.push(...formatAtlasObject(object));
+    });
+    return lines.join("\n");
+}
+export function formatDraftDocument(document) {
+    const legacy = document.version === "2.0-draft"
+        ? document
+        : {
+            ...document,
+            version: "2.0-draft",
+        };
+    const lines = ["schema 2.0-draft", ""];
+    if (legacy.system) {
+        lines.push(...formatAtlasSystem(legacy.system));
+    }
+    const sortedObjects = [...legacy.objects].sort(compareObjects);
+    if (sortedObjects.length > 0 && lines.at(-1) !== "") {
+        lines.push("");
+    }
+    sortedObjects.forEach((object, index) => {
+        if (index > 0) {
+            lines.push("");
+        }
+        lines.push(...formatAtlasObject(object));
+    });
+    return lines.join("\n");
+}
+function formatSystem(system) {
+    return formatLines("system", system.id, system.properties, null, system.info);
+}
+function formatAtlasSystem(system) {
+    const lines = [`system ${system.id}`];
+    if (system.title) {
+        lines.push(`  title ${quoteIfNeeded(system.title)}`);
+    }
+    lines.push("");
+    lines.push("defaults");
+    lines.push(`  view ${system.defaults.view}`);
+    if (system.defaults.scale) {
+        lines.push(`  scale ${quoteIfNeeded(system.defaults.scale)}`);
+    }
+    if (system.defaults.units) {
+        lines.push(`  units ${quoteIfNeeded(system.defaults.units)}`);
+    }
+    if (system.defaults.preset) {
+        lines.push(`  preset ${system.defaults.preset}`);
+    }
+    if (system.defaults.theme) {
+        lines.push(`  theme ${quoteIfNeeded(system.defaults.theme)}`);
+    }
+    if (Object.keys(system.atlasMetadata).length > 0) {
+        lines.push("");
+        lines.push("atlas");
+        lines.push("  metadata");
+        for (const [key, value] of Object.entries(system.atlasMetadata).sort(([left], [right]) => left.localeCompare(right))) {
+            lines.push(`    ${key} ${quoteIfNeeded(value)}`);
+        }
+    }
+    for (const viewpoint of system.viewpoints) {
+        lines.push("");
+        lines.push(...formatAtlasViewpoint(viewpoint));
+    }
+    for (const annotation of system.annotations) {
+        lines.push("");
+        lines.push(...formatAtlasAnnotation(annotation));
+    }
+    return lines;
+}
+function formatObject(object) {
+    return formatLines(object.type, object.id, object.properties, object.placement, object.info);
+}
+function formatAtlasObject(object) {
+    return formatLines(`object ${object.type}`, object.id, object.properties, object.placement, object.info);
+}
+function formatLines(objectType, id, properties, placement, info) {
+    const lines = [`${objectType} ${id}`];
+    const fieldLines = [...formatPlacement(placement), ...formatProperties(properties)];
+    for (const fieldLine of fieldLines) {
+        lines.push(`  ${fieldLine}`);
+    }
+    const infoEntries = Object.entries(info).sort(([left], [right]) => left.localeCompare(right));
+    if (infoEntries.length > 0) {
+        if (fieldLines.length > 0) {
+            lines.push("");
+        }
+        lines.push("  info");
+        for (const [key, value] of infoEntries) {
+            lines.push(`    ${key} ${quoteIfNeeded(value)}`);
+        }
+    }
+    return lines;
+}
+function formatPlacement(placement) {
+    if (!placement)
+        return [];
+    switch (placement.mode) {
+        case "orbit":
+            return [
+                `orbit ${placement.target}`,
+                ...formatOptionalUnit("distance", placement.distance),
+                ...formatOptionalUnit("semiMajor", placement.semiMajor),
+                ...formatOptionalNumber("eccentricity", placement.eccentricity),
+                ...formatOptionalUnit("period", placement.period),
+                ...formatOptionalUnit("angle", placement.angle),
+                ...formatOptionalUnit("inclination", placement.inclination),
+                ...formatOptionalUnit("phase", placement.phase),
+            ];
+        case "at":
+            return [`at ${formatAtReference(placement.reference)}`];
+        case "surface":
+            return [`surface ${placement.target}`];
+        case "free":
+            return [`free ${placement.distance ? formatUnitValue(placement.distance) : placement.descriptor ?? ""}`.trim()];
+    }
+}
+function formatProperties(properties) {
+    return Object.keys(properties)
+        .sort(compareFieldKeys)
+        .map((key) => `${key} ${formatValue(properties[key])}`);
+}
+function formatAtlasViewpoint(viewpoint) {
+    const lines = [`viewpoint ${viewpoint.id}`, `  label ${quoteIfNeeded(viewpoint.label)}`];
+    if (viewpoint.focusObjectId) {
+        lines.push(`  focus ${viewpoint.focusObjectId}`);
+    }
+    if (viewpoint.selectedObjectId && viewpoint.selectedObjectId !== viewpoint.focusObjectId) {
+        lines.push(`  select ${viewpoint.selectedObjectId}`);
+    }
+    if (viewpoint.summary) {
+        lines.push(`  summary ${quoteIfNeeded(viewpoint.summary)}`);
+    }
+    if (viewpoint.projection) {
+        lines.push(`  projection ${viewpoint.projection}`);
+    }
+    if (viewpoint.preset) {
+        lines.push(`  preset ${viewpoint.preset}`);
+    }
+    if (viewpoint.zoom !== null) {
+        lines.push(`  zoom ${viewpoint.zoom}`);
+    }
+    if (viewpoint.rotationDeg !== 0) {
+        lines.push(`  rotation ${viewpoint.rotationDeg}`);
+    }
+    const layerTokens = formatDraftLayers(viewpoint.layers);
+    if (layerTokens.length > 0) {
+        lines.push(`  layers ${layerTokens.join(" ")}`);
+    }
+    if (viewpoint.filter) {
+        lines.push("  filter");
+        if (viewpoint.filter.query) {
+            lines.push(`    query ${quoteIfNeeded(viewpoint.filter.query)}`);
+        }
+        if (viewpoint.filter.objectTypes.length > 0) {
+            lines.push(`    objectTypes ${viewpoint.filter.objectTypes.join(" ")}`);
+        }
+        if (viewpoint.filter.tags.length > 0) {
+            lines.push(`    tags ${viewpoint.filter.tags.map(quoteIfNeeded).join(" ")}`);
+        }
+        if (viewpoint.filter.groupIds.length > 0) {
+            lines.push(`    groups ${viewpoint.filter.groupIds.join(" ")}`);
+        }
+    }
+    return lines;
+}
+function formatAtlasAnnotation(annotation) {
+    const lines = [`annotation ${annotation.id}`, `  label ${quoteIfNeeded(annotation.label)}`];
+    if (annotation.targetObjectId) {
+        lines.push(`  target ${annotation.targetObjectId}`);
+    }
+    lines.push(`  body ${quoteIfNeeded(annotation.body)}`);
+    if (annotation.tags.length > 0) {
+        lines.push(`  tags ${annotation.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    return lines;
+}
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => quoteIfNeeded(item)).join(" ");
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "string") {
+        return quoteIfNeeded(value);
+    }
+    return formatUnitValue(value);
+}
+function formatUnitValue(value) {
+    return `${value.value}${value.unit ?? ""}`;
+}
+function formatOptionalUnit(key, value) {
+    return value ? [`${key} ${formatUnitValue(value)}`] : [];
+}
+function formatOptionalNumber(key, value) {
+    return value === undefined ? [] : [`${key} ${value}`];
+}
+function formatAtReference(reference) {
+    switch (reference.kind) {
+        case "lagrange":
+            return reference.secondary
+                ? `${reference.primary}-${reference.secondary}:${reference.point}`
+                : `${reference.primary}:${reference.point}`;
+        case "anchor":
+            return `${reference.objectId}:${reference.anchor}`;
+        case "named":
+            return reference.name;
+    }
+}
+function formatDraftLayers(layers) {
+    const tokens = [];
+    const orbitFront = layers["orbits-front"];
+    const orbitBack = layers["orbits-back"];
+    if (orbitFront !== undefined || orbitBack !== undefined) {
+        tokens.push(orbitFront !== false || orbitBack !== false
+            ? "orbits"
+            : "-orbits");
+    }
+    for (const key of ["background", "guides", "objects", "labels", "metadata"]) {
+        if (layers[key] !== undefined) {
+            tokens.push(layers[key] ? key : `-${key}`);
+        }
+    }
+    return tokens;
+}
+function compareFieldKeys(left, right) {
+    const leftIndex = CANONICAL_FIELD_ORDER.indexOf(left);
+    const rightIndex = CANONICAL_FIELD_ORDER.indexOf(right);
+    if (leftIndex === -1 && rightIndex === -1)
+        return left.localeCompare(right);
+    if (leftIndex === -1)
+        return 1;
+    if (rightIndex === -1)
+        return -1;
+    return leftIndex - rightIndex;
+}
+function compareObjects(left, right) {
+    const leftIndex = objectTypeIndex(left.type);
+    const rightIndex = objectTypeIndex(right.type);
+    if (leftIndex !== rightIndex)
+        return leftIndex - rightIndex;
+    return left.id.localeCompare(right.id);
+}
+function objectTypeIndex(objectType) {
+    switch (objectType) {
+        case "star":
+            return 0;
+        case "planet":
+            return 1;
+        case "moon":
+            return 2;
+        case "belt":
+            return 3;
+        case "asteroid":
+            return 4;
+        case "comet":
+            return 5;
+        case "ring":
+            return 6;
+        case "structure":
+            return 7;
+        case "phenomenon":
+            return 8;
+    }
+}
+function quoteIfNeeded(value) {
+    if (!/\s/.test(value) && !value.includes('"')) {
+        return value;
+    }
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}

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

@@ -0,0 +1,28 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./schema.js";
+export { tokenizeLine, tokenizeLineDetailed } from "./tokenize.js";
+export { parseWorldOrbit } from "./parse.js";
+export { normalizeDocument } from "./normalize.js";
+export { validateDocument } from "./validate.js";
+export { createDiagnostic, diagnosticFromError, normalizeWithDiagnostics, parseWithDiagnostics, validateDocumentWithDiagnostics, } from "./diagnostics.js";
+export { renderDocumentToScene, rotatePoint } from "./scene.js";
+export { formatAtlasDocument, formatDocument, formatDraftDocument } from "./format.js";
+export { materializeAtlasDocument, materializeDraftDocument, upgradeDocumentToDraftV2, upgradeDocumentToV2, } from "./draft.js";
+export { parseWorldOrbitAtlas, parseWorldOrbitDraft } from "./draft-parse.js";
+export { cloneAtlasDocument, createEmptyAtlasDocument, getAtlasDocumentNode, listAtlasDocumentPaths, removeAtlasDocumentNode, resolveAtlasDiagnosticPath, resolveAtlasDiagnostics, updateAtlasDocumentNode, upsertAtlasDocumentNode, validateAtlasDocumentWithDiagnostics, } from "./atlas-edit.js";
+export { detectWorldOrbitSchemaVersion, loadWorldOrbitSource, loadWorldOrbitSourceWithDiagnostics, } from "./load.js";
+export { extractWorldOrbitBlocks } from "./markdown.js";
+import type { AstDocument, FormatDocumentOptions, FormattableWorldOrbitDocument, RenderScene, WorldOrbitDocument } from "./types.js";
+export interface ParseResult {
+    ast: AstDocument;
+    document: WorldOrbitDocument;
+}
+export interface RenderResult extends ParseResult {
+    scene: RenderScene;
+}
+export declare function parse(source: string): ParseResult;
+export declare function render(source: string): RenderResult;
+export declare function load(source: string): import("./types.js").LoadedWorldOrbitSource;
+export declare function parseSafe(source: string): import("./types.js").DiagnosticResult<import("./diagnostics.js").ParsedWorldOrbitDocument>;
+export declare function stringify(document: FormattableWorldOrbitDocument, options?: FormatDocumentOptions): string;

package/packages/core/dist/index.js

@@ -0,0 +1,44 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./schema.js";
+export { tokenizeLine, tokenizeLineDetailed } from "./tokenize.js";
+export { parseWorldOrbit } from "./parse.js";
+export { normalizeDocument } from "./normalize.js";
+export { validateDocument } from "./validate.js";
+export { createDiagnostic, diagnosticFromError, normalizeWithDiagnostics, parseWithDiagnostics, validateDocumentWithDiagnostics, } from "./diagnostics.js";
+export { renderDocumentToScene, rotatePoint } from "./scene.js";
+export { formatAtlasDocument, formatDocument, formatDraftDocument } from "./format.js";
+export { materializeAtlasDocument, materializeDraftDocument, upgradeDocumentToDraftV2, upgradeDocumentToV2, } from "./draft.js";
+export { parseWorldOrbitAtlas, parseWorldOrbitDraft } from "./draft-parse.js";
+export { cloneAtlasDocument, createEmptyAtlasDocument, getAtlasDocumentNode, listAtlasDocumentPaths, removeAtlasDocumentNode, resolveAtlasDiagnosticPath, resolveAtlasDiagnostics, updateAtlasDocumentNode, upsertAtlasDocumentNode, validateAtlasDocumentWithDiagnostics, } from "./atlas-edit.js";
+export { detectWorldOrbitSchemaVersion, loadWorldOrbitSource, loadWorldOrbitSourceWithDiagnostics, } from "./load.js";
+export { extractWorldOrbitBlocks } from "./markdown.js";
+import { parseWithDiagnostics } from "./diagnostics.js";
+import { formatDocument } from "./format.js";
+import { loadWorldOrbitSource } from "./load.js";
+import { normalizeDocument } from "./normalize.js";
+import { parseWorldOrbit } from "./parse.js";
+import { renderDocumentToScene } from "./scene.js";
+import { validateDocument } from "./validate.js";
+export function parse(source) {
+    const ast = parseWorldOrbit(source);
+    const document = normalizeDocument(ast);
+    validateDocument(document);
+    return { ast, document };
+}
+export function render(source) {
+    const result = parse(source);
+    return {
+        ...result,
+        scene: renderDocumentToScene(result.document),
+    };
+}
+export function load(source) {
+    return loadWorldOrbitSource(source);
+}
+export function parseSafe(source) {
+    return parseWithDiagnostics(source);
+}
+export function stringify(document, options = {}) {
+    return formatDocument(document, options);
+}

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

@@ -0,0 +1,4 @@
+import type { DiagnosticResult, LoadedWorldOrbitSource, WorldOrbitAnyDocumentVersion } from "./types.js";
+export declare function detectWorldOrbitSchemaVersion(source: string): WorldOrbitAnyDocumentVersion;
+export declare function loadWorldOrbitSource(source: string): LoadedWorldOrbitSource;
+export declare function loadWorldOrbitSourceWithDiagnostics(source: string): DiagnosticResult<LoadedWorldOrbitSource>;

package/packages/core/dist/load.js

@@ -0,0 +1,130 @@
+import { diagnosticFromError } from "./diagnostics.js";
+import { materializeAtlasDocument } from "./draft.js";
+import { parseWorldOrbitAtlas } from "./draft-parse.js";
+import { WorldOrbitError } from "./errors.js";
+import { normalizeDocument } from "./normalize.js";
+import { parseWorldOrbit } from "./parse.js";
+import { validateDocument } from "./validate.js";
+const ATLAS_SCHEMA_PATTERN = /^schema\s+2(?:\.0)?$/i;
+const LEGACY_DRAFT_SCHEMA_PATTERN = /^schema\s+2\.0-draft$/i;
+export function detectWorldOrbitSchemaVersion(source) {
+    for (const line of source.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (LEGACY_DRAFT_SCHEMA_PATTERN.test(trimmed)) {
+            return "2.0-draft";
+        }
+        if (ATLAS_SCHEMA_PATTERN.test(trimmed)) {
+            return "2.0";
+        }
+        return "1.0";
+    }
+    return "1.0";
+}
+export function loadWorldOrbitSource(source) {
+    const result = loadWorldOrbitSourceWithDiagnostics(source);
+    if (!result.ok || !result.value) {
+        const diagnostic = result.diagnostics[0];
+        throw new WorldOrbitError(diagnostic?.message ?? "Failed to load WorldOrbit source", diagnostic?.line, diagnostic?.column);
+    }
+    return result.value;
+}
+export function loadWorldOrbitSourceWithDiagnostics(source) {
+    const schemaVersion = detectWorldOrbitSchemaVersion(source);
+    if (schemaVersion === "2.0" || schemaVersion === "2.0-draft") {
+        return loadAtlasSourceWithDiagnostics(source, schemaVersion);
+    }
+    let ast;
+    try {
+        ast = parseWorldOrbit(source);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            value: null,
+            diagnostics: [diagnosticFromError(error, "parse")],
+        };
+    }
+    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: {
+            schemaVersion,
+            ast,
+            document,
+            atlasDocument: null,
+            draftDocument: null,
+            diagnostics: [],
+        },
+        diagnostics: [],
+    };
+}
+function loadAtlasSourceWithDiagnostics(source, schemaVersion) {
+    let atlasDocument;
+    try {
+        atlasDocument = parseWorldOrbitAtlas(source);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            value: null,
+            diagnostics: [diagnosticFromError(error, "parse", "load.atlas.failed")],
+        };
+    }
+    let document;
+    try {
+        document = materializeAtlasDocument(atlasDocument);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            value: null,
+            diagnostics: [diagnosticFromError(error, "normalize", "load.atlas.materialize.failed")],
+        };
+    }
+    try {
+        validateDocument(document);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            value: null,
+            diagnostics: [diagnosticFromError(error, "validate", "load.atlas.validate.failed")],
+        };
+    }
+    const loaded = {
+        schemaVersion,
+        ast: null,
+        document,
+        atlasDocument,
+        draftDocument: atlasDocument,
+        diagnostics: [...atlasDocument.diagnostics],
+    };
+    return {
+        ok: true,
+        value: loaded,
+        diagnostics: [...atlasDocument.diagnostics],
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { MarkdownFenceBlock } from "./types.js";
+export declare function extractWorldOrbitBlocks(markdown: string): MarkdownFenceBlock[];

package/packages/core/dist/markdown.js

@@ -0,0 +1,37 @@
+const FENCE_PATTERN = /^```worldorbit(?:\s+(.*))?\s*$/;
+export function extractWorldOrbitBlocks(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const blocks = [];
+    let active = false;
+    let activeInfo = null;
+    let activeStartLine = 0;
+    let buffer = [];
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        if (!active) {
+            const match = line.match(FENCE_PATTERN);
+            if (match) {
+                active = true;
+                activeInfo = match[1] ?? null;
+                activeStartLine = lineNumber;
+                buffer = [];
+            }
+            return;
+        }
+        if (line.trim() === "```") {
+            blocks.push({
+                source: buffer.join("\n"),
+                info: activeInfo,
+                startLine: activeStartLine,
+                endLine: lineNumber,
+            });
+            active = false;
+            activeInfo = null;
+            activeStartLine = 0;
+            buffer = [];
+            return;
+        }
+        buffer.push(line);
+    });
+    return blocks;
+}

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

@@ -0,0 +1,2 @@
+import type { AstDocument, WorldOrbitDocument } from "./types.js";
+export declare function normalizeDocument(ast: AstDocument): WorldOrbitDocument;