worldorbit 2.5.1-5.2

package/packages/core/dist/format.js

@@ -0,0 +1,520 @@
+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.1" ||
+        schema === "2.0-draft" ||
+        document.version === "2.0" ||
+        document.version === "2.1" ||
+        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.1"
+                    ? {
+                        ...document,
+                        version: "2.0-draft",
+                        schemaVersion: "2.0-draft",
+                    }
+                    : upgradeDocumentToDraftV2(document);
+            return formatDraftDocument(legacyDraftDocument);
+        }
+        const atlasDocument = document.version === "2.0" || document.version === "2.1"
+            ? document
+            : document.version === "2.0-draft"
+                ? {
+                    ...document,
+                    version: "2.0",
+                    schemaVersion: "2.0",
+                }
+                : upgradeDocumentToV2(document);
+        if (schema === "2.1" && atlasDocument.version !== "2.1") {
+            return formatAtlasDocument({
+                ...atlasDocument,
+                version: "2.1",
+                schemaVersion: "2.1",
+            });
+        }
+        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 ${document.version}`, ""];
+    if (document.system) {
+        lines.push(...formatAtlasSystem(document.system));
+    }
+    for (const group of [...document.groups].sort(compareIdLike)) {
+        lines.push("");
+        lines.push(...formatAtlasGroup(group));
+    }
+    for (const relation of [...document.relations].sort(compareIdLike)) {
+        lines.push("");
+        lines.push(...formatAtlasRelation(relation));
+    }
+    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",
+            schemaVersion: "2.0-draft",
+        };
+    const lines = ["schema 2.0-draft", ""];
+    if (legacy.system) {
+        lines.push(...formatAtlasSystem(legacy.system));
+    }
+    for (const group of [...legacy.groups].sort(compareIdLike)) {
+        lines.push("");
+        lines.push(...formatAtlasGroup(group));
+    }
+    for (const relation of [...legacy.relations].sort(compareIdLike)) {
+        lines.push("");
+        lines.push(...formatAtlasRelation(relation));
+    }
+    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 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 formatAtlasSystem(system) {
+    const lines = [`system ${system.id}`];
+    if (system.title) {
+        lines.push(`  title ${quoteIfNeeded(system.title)}`);
+    }
+    if (system.description) {
+        lines.push(`  description ${quoteIfNeeded(system.description)}`);
+    }
+    if (system.epoch) {
+        lines.push(`  epoch ${quoteIfNeeded(system.epoch)}`);
+    }
+    if (system.referencePlane) {
+        lines.push(`  referencePlane ${quoteIfNeeded(system.referencePlane)}`);
+    }
+    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 formatWorldOrbitObject(object.type, object.id, object);
+}
+function formatAtlasObject(object) {
+    return formatWorldOrbitObject(`object ${object.type}`, object.id, object);
+}
+function formatWorldOrbitObject(objectType, id, object) {
+    const lines = [`${objectType} ${id}`];
+    const fieldLines = [
+        ...formatPlacement(object.placement),
+        ...formatProperties(object.properties),
+        ...formatObjectMetadata(object),
+    ];
+    for (const fieldLine of fieldLines) {
+        lines.push(`  ${fieldLine}`);
+    }
+    const infoEntries = Object.entries(object.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)}`);
+        }
+    }
+    for (const blockName of ["climate", "habitability", "settlement"]) {
+        const blockEntries = Object.entries(object.typedBlocks?.[blockName] ?? {}).sort(([left], [right]) => left.localeCompare(right));
+        if (blockEntries.length > 0) {
+            lines.push("");
+            lines.push(`  ${blockName}`);
+            for (const [key, value] of blockEntries) {
+                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 formatObjectMetadata(object) {
+    const lines = [];
+    if (object.groups?.length) {
+        lines.push(`groups ${object.groups.join(" ")}`);
+    }
+    if (object.epoch) {
+        lines.push(`epoch ${quoteIfNeeded(object.epoch)}`);
+    }
+    if (object.referencePlane) {
+        lines.push(`referencePlane ${quoteIfNeeded(object.referencePlane)}`);
+    }
+    if (object.tidalLock !== undefined) {
+        lines.push(`tidalLock ${object.tidalLock ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderLabel !== undefined) {
+        lines.push(`renderLabel ${object.renderHints.renderLabel ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderOrbit !== undefined) {
+        lines.push(`renderOrbit ${object.renderHints.renderOrbit ? "true" : "false"}`);
+    }
+    if (object.renderHints?.renderPriority !== undefined) {
+        lines.push(`renderPriority ${object.renderHints.renderPriority}`);
+    }
+    if (object.resonance) {
+        lines.push(`resonance ${object.resonance.targetObjectId} ${object.resonance.ratio}`);
+    }
+    for (const rule of object.deriveRules ?? []) {
+        lines.push(`derive ${rule.field} ${rule.strategy}`);
+    }
+    for (const rule of object.validationRules ?? []) {
+        lines.push(`validate ${rule.rule}`);
+    }
+    if (object.lockedFields?.length) {
+        lines.push(`locked ${object.lockedFields.join(" ")}`);
+    }
+    for (const tolerance of object.tolerances ?? []) {
+        lines.push(`tolerance ${tolerance.field} ${formatValue(tolerance.value)}`);
+    }
+    return lines;
+}
+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 formatAtlasGroup(group) {
+    const lines = [`group ${group.id}`, `  label ${quoteIfNeeded(group.label)}`];
+    if (group.summary) {
+        lines.push(`  summary ${quoteIfNeeded(group.summary)}`);
+    }
+    if (group.color) {
+        lines.push(`  color ${quoteIfNeeded(group.color)}`);
+    }
+    if (group.tags.length > 0) {
+        lines.push(`  tags ${group.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    if (group.hidden) {
+        lines.push("  hidden true");
+    }
+    return lines;
+}
+function formatAtlasRelation(relation) {
+    const lines = [`relation ${relation.id}`];
+    if (relation.from) {
+        lines.push(`  from ${quoteIfNeeded(relation.from)}`);
+    }
+    if (relation.to) {
+        lines.push(`  to ${quoteIfNeeded(relation.to)}`);
+    }
+    if (relation.kind) {
+        lines.push(`  kind ${quoteIfNeeded(relation.kind)}`);
+    }
+    if (relation.label) {
+        lines.push(`  label ${quoteIfNeeded(relation.label)}`);
+    }
+    if (relation.summary) {
+        lines.push(`  summary ${quoteIfNeeded(relation.summary)}`);
+    }
+    if (relation.tags.length > 0) {
+        lines.push(`  tags ${relation.tags.map(quoteIfNeeded).join(" ")}`);
+    }
+    if (relation.color) {
+        lines.push(`  color ${quoteIfNeeded(relation.color)}`);
+    }
+    if (relation.hidden) {
+        lines.push("  hidden true");
+    }
+    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", "relations", "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 compareIdLike(left, right) {
+    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>;