worldorbit 2.5.2

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const OBJECT_TYPES: ReadonlySet<string>;
+export declare const KNOWN_FIELD_KEYS: ReadonlySet<string>;
+export declare const LIST_KEYS: ReadonlySet<string>;
+export declare const BOOLEAN_KEYS: ReadonlySet<string>;
+export declare const INLINE_MULTI_VALUE_KEYS: ReadonlySet<string>;
+export declare const UNIT_VALUE_KEYS: ReadonlySet<string>;
+export declare const NUMBER_KEYS: ReadonlySet<string>;
+export declare const PLACEMENT_KEYS: ReadonlySet<string>;

package/dist/constants.js

@@ -0,0 +1,84 @@
+export const OBJECT_TYPES = new Set([
+    "system",
+    "star",
+    "planet",
+    "moon",
+    "belt",
+    "asteroid",
+    "comet",
+    "ring",
+    "structure",
+    "phenomenon",
+]);
+export const KNOWN_FIELD_KEYS = new Set([
+    "orbit",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "at",
+    "surface",
+    "free",
+    "kind",
+    "class",
+    "tags",
+    "color",
+    "hidden",
+    "radius",
+    "mass",
+    "density",
+    "gravity",
+    "temperature",
+    "albedo",
+    "atmosphere",
+    "inner",
+    "outer",
+    "view",
+    "scale",
+    "units",
+    "title",
+    "on",
+    "source",
+    "cycle",
+]);
+export const LIST_KEYS = new Set(["tags"]);
+export const BOOLEAN_KEYS = new Set(["hidden"]);
+export const INLINE_MULTI_VALUE_KEYS = new Set([
+    ...LIST_KEYS,
+]);
+export const UNIT_VALUE_KEYS = new Set([
+    "distance",
+    "semiMajor",
+    "inner",
+    "outer",
+    "radius",
+    "mass",
+    "density",
+    "gravity",
+    "temperature",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+    "cycle",
+]);
+export const NUMBER_KEYS = new Set([
+    "eccentricity",
+    "albedo",
+]);
+export const PLACEMENT_KEYS = new Set([
+    "orbit",
+    "at",
+    "surface",
+    "free",
+    "distance",
+    "semiMajor",
+    "eccentricity",
+    "period",
+    "angle",
+    "inclination",
+    "phase",
+]);

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+import type { AstSourceLocation } from "./types.js";
+export declare class WorldOrbitError extends Error {
+    readonly line?: number;
+    readonly column?: number;
+    constructor(message: string, line?: number, column?: number);
+    static fromLocation(message: string, location?: AstSourceLocation): WorldOrbitError;
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+export class WorldOrbitError extends Error {
+    line;
+    column;
+    constructor(message, line, column) {
+        const locationSuffix = line === undefined
+            ? ""
+            : ` (line ${line}${column === undefined ? "" : `, column ${column}`})`;
+        super(`${message}${locationSuffix}`);
+        this.name = "WorldOrbitError";
+        this.line = line;
+        this.column = column;
+    }
+    static fromLocation(message, location) {
+        return new WorldOrbitError(message, location?.line, location?.column);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./types.js";
+export * from "./errors.js";
+export { tokenizeLine, tokenizeLineDetailed } from "./tokenize.js";
+export { parseWorldOrbit } from "./parse.js";
+export { normalizeDocument } from "./normalize.js";
+export { validateDocument } from "./validate.js";
+export { renderDocumentToScene, renderSceneToSvg, renderDocumentToSvg, renderSourceToSvg, } from "./render.js";
+export { createInteractiveViewer } from "./viewer.js";
+import type { AstDocument, WorldOrbitDocument } from "./types.js";
+export interface ParseResult {
+    ast: AstDocument;
+    document: WorldOrbitDocument;
+}
+export interface RenderResult extends ParseResult {
+    svg: string;
+}
+export declare function parse(source: string): ParseResult;
+export declare function render(source: string): RenderResult;

package/dist/index.js

@@ -0,0 +1,25 @@
+export * from "./types.js";
+export * from "./errors.js";
+export { tokenizeLine, tokenizeLineDetailed } from "./tokenize.js";
+export { parseWorldOrbit } from "./parse.js";
+export { normalizeDocument } from "./normalize.js";
+export { validateDocument } from "./validate.js";
+export { renderDocumentToScene, renderSceneToSvg, renderDocumentToSvg, renderSourceToSvg, } from "./render.js";
+export { createInteractiveViewer } from "./viewer.js";
+import { normalizeDocument } from "./normalize.js";
+import { parseWorldOrbit } from "./parse.js";
+import { renderDocumentToSvg } from "./render.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,
+        svg: renderDocumentToSvg(result.document),
+    };
+}

package/dist/normalize.d.ts

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

package/dist/normalize.js

@@ -0,0 +1,243 @@
+import { BOOLEAN_KEYS, LIST_KEYS, NUMBER_KEYS, PLACEMENT_KEYS, UNIT_VALUE_KEYS, } from "./constants.js";
+import { WorldOrbitError } from "./errors.js";
+const UNIT_PATTERN = /^(-?\d+(?:\.\d+)?)(au|km|re|sol|me|d|y|h|deg)?$/;
+const BOOLEAN_VALUES = new Map([
+    ["true", true],
+    ["false", false],
+    ["yes", true],
+    ["no", false],
+]);
+export function normalizeDocument(ast) {
+    let system = null;
+    const objects = [];
+    for (const node of ast.objects) {
+        const normalized = normalizeObject(node);
+        if (node.objectType === "system") {
+            if (system) {
+                throw WorldOrbitError.fromLocation("Only one system object is allowed", node.location);
+            }
+            system = normalized;
+        }
+        else {
+            objects.push(normalized);
+        }
+    }
+    return {
+        format: "worldorbit",
+        version: "0.1",
+        system,
+        objects,
+    };
+}
+function normalizeObject(node) {
+    const mergedFields = [...node.inlineFields, ...node.blockFields];
+    const fieldMap = collectFields(mergedFields);
+    const placement = extractPlacement(fieldMap);
+    const properties = normalizeProperties(fieldMap);
+    const info = normalizeInfo(node.infoEntries);
+    if (node.objectType === "system") {
+        return {
+            type: "system",
+            id: node.name,
+            properties,
+            info,
+        };
+    }
+    return {
+        type: node.objectType,
+        id: node.name,
+        properties,
+        placement,
+        info,
+    };
+}
+function collectFields(fields) {
+    const map = new Map();
+    for (const field of fields) {
+        if (map.has(field.key)) {
+            throw WorldOrbitError.fromLocation(`Duplicate field "${field.key}"`, field.location);
+        }
+        map.set(field.key, field);
+    }
+    return map;
+}
+function extractPlacement(fieldMap) {
+    const hasOrbit = fieldMap.has("orbit");
+    const hasAt = fieldMap.has("at");
+    const hasSurface = fieldMap.has("surface");
+    const hasFree = fieldMap.has("free");
+    const count = [hasOrbit, hasAt, hasSurface, hasFree].filter(Boolean).length;
+    if (count > 1) {
+        const conflictingField = fieldMap.get("orbit") ??
+            fieldMap.get("at") ??
+            fieldMap.get("surface") ??
+            fieldMap.get("free");
+        throw WorldOrbitError.fromLocation("Object has multiple placement modes", conflictingField?.location);
+    }
+    if (hasOrbit) {
+        return {
+            mode: "orbit",
+            target: singleValue(fieldMap, "orbit"),
+            distance: parseOptionalUnitValue(fieldMap, "distance"),
+            semiMajor: parseOptionalUnitValue(fieldMap, "semiMajor"),
+            eccentricity: parseOptionalNumber(fieldMap, "eccentricity"),
+            period: parseOptionalUnitValue(fieldMap, "period"),
+            angle: parseOptionalUnitValue(fieldMap, "angle"),
+            inclination: parseOptionalUnitValue(fieldMap, "inclination"),
+            phase: parseOptionalUnitValue(fieldMap, "phase"),
+        };
+    }
+    if (hasAt) {
+        const field = getField(fieldMap, "at");
+        const target = singleValue(fieldMap, "at");
+        return {
+            mode: "at",
+            target,
+            reference: parseAtReference(target, field.location),
+        };
+    }
+    if (hasSurface) {
+        return {
+            mode: "surface",
+            target: singleValue(fieldMap, "surface"),
+        };
+    }
+    if (hasFree) {
+        const raw = singleValue(fieldMap, "free");
+        const distance = tryParseUnitValue(raw);
+        return {
+            mode: "free",
+            distance: distance ?? undefined,
+            descriptor: distance ? undefined : raw,
+        };
+    }
+    return null;
+}
+function normalizeProperties(fieldMap) {
+    const result = {};
+    for (const [key, field] of fieldMap.entries()) {
+        if (PLACEMENT_KEYS.has(key)) {
+            continue;
+        }
+        if (LIST_KEYS.has(key)) {
+            result[key] = field.values;
+            continue;
+        }
+        if (BOOLEAN_KEYS.has(key)) {
+            result[key] = parseBoolean(field);
+            continue;
+        }
+        if (NUMBER_KEYS.has(key)) {
+            result[key] = parseNumber(singleFieldValue(field), key, field.location);
+            continue;
+        }
+        if (UNIT_VALUE_KEYS.has(key)) {
+            result[key] = parseUnitValue(singleFieldValue(field), field.location);
+            continue;
+        }
+        result[key] = field.values.join(" ");
+    }
+    return result;
+}
+function normalizeInfo(entries) {
+    const info = {};
+    for (const entry of entries) {
+        if (entry.key in info) {
+            throw WorldOrbitError.fromLocation(`Duplicate info key "${entry.key}"`, entry.location);
+        }
+        info[entry.key] = entry.value;
+    }
+    return info;
+}
+function parseAtReference(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 (target.includes(":L")) {
+        throw WorldOrbitError.fromLocation(`Invalid special position "${target}"`, location);
+    }
+    return {
+        kind: "named",
+        name: target,
+    };
+}
+function parseUnitValue(input, location) {
+    const match = input.match(UNIT_PATTERN);
+    if (!match) {
+        throw WorldOrbitError.fromLocation(`Invalid unit value "${input}"`, location);
+    }
+    return {
+        value: Number(match[1]),
+        unit: match[2] ?? null,
+    };
+}
+function tryParseUnitValue(input) {
+    const match = input.match(UNIT_PATTERN);
+    if (!match) {
+        return null;
+    }
+    return {
+        value: Number(match[1]),
+        unit: match[2] ?? null,
+    };
+}
+function parseOptionalUnitValue(fieldMap, key) {
+    if (!fieldMap.has(key)) {
+        return undefined;
+    }
+    const field = getField(fieldMap, key);
+    return parseUnitValue(singleFieldValue(field), field.location);
+}
+function parseOptionalNumber(fieldMap, key) {
+    if (!fieldMap.has(key)) {
+        return undefined;
+    }
+    const field = getField(fieldMap, key);
+    return parseNumber(singleFieldValue(field), key, field.location);
+}
+function parseNumber(input, key, location) {
+    const value = Number(input);
+    if (!Number.isFinite(value)) {
+        throw WorldOrbitError.fromLocation(`Invalid numeric value "${input}" for "${key}"`, location);
+    }
+    return value;
+}
+function parseBoolean(field) {
+    const rawValue = singleFieldValue(field).toLowerCase();
+    const parsed = BOOLEAN_VALUES.get(rawValue);
+    if (parsed === undefined) {
+        throw WorldOrbitError.fromLocation(`Invalid boolean value "${rawValue}" for "${field.key}"`, field.location);
+    }
+    return parsed;
+}
+function getField(fieldMap, key) {
+    const field = fieldMap.get(key);
+    if (!field) {
+        throw new WorldOrbitError(`Missing value for key "${key}"`);
+    }
+    return field;
+}
+function singleValue(fieldMap, key) {
+    return singleFieldValue(getField(fieldMap, key));
+}
+function singleFieldValue(field) {
+    if (field.values.length !== 1) {
+        throw WorldOrbitError.fromLocation(`Field "${field.key}" expects exactly one value`, field.location);
+    }
+    return field.values[0];
+}

package/dist/parse.d.ts

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

package/dist/parse.js

@@ -0,0 +1,126 @@
+import { INLINE_MULTI_VALUE_KEYS, KNOWN_FIELD_KEYS, OBJECT_TYPES, } from "./constants.js";
+import { WorldOrbitError } from "./errors.js";
+import { getIndent, tokenizeLineDetailed } from "./tokenize.js";
+export function parseWorldOrbit(source) {
+    const lines = source.split(/\r?\n/);
+    const objects = [];
+    let currentObject = null;
+    let inInfoBlock = false;
+    let infoIndent = null;
+    for (let index = 0; index < lines.length; index++) {
+        const rawLine = lines[index];
+        const lineNumber = index + 1;
+        if (!rawLine.trim()) {
+            continue;
+        }
+        const indent = getIndent(rawLine);
+        const tokens = tokenizeLineDetailed(rawLine.slice(indent), {
+            line: lineNumber,
+            columnOffset: indent,
+        });
+        if (tokens.length === 0) {
+            continue;
+        }
+        if (indent === 0) {
+            inInfoBlock = false;
+            infoIndent = null;
+            const objectNode = parseObjectHeader(tokens, lineNumber);
+            objects.push(objectNode);
+            currentObject = objectNode;
+            continue;
+        }
+        if (!currentObject) {
+            throw new WorldOrbitError("Indented line without parent object", lineNumber, indent + 1);
+        }
+        if (tokens.length === 1 && tokens[0].value === "info") {
+            inInfoBlock = true;
+            infoIndent = indent;
+            continue;
+        }
+        if (inInfoBlock && indent <= (infoIndent ?? 0)) {
+            inInfoBlock = false;
+        }
+        if (inInfoBlock) {
+            currentObject.infoEntries.push(parseInfoEntry(tokens, lineNumber));
+        }
+        else {
+            currentObject.blockFields.push(parseField(tokens, lineNumber));
+        }
+    }
+    return {
+        type: "document",
+        objects,
+    };
+}
+function parseObjectHeader(tokens, line) {
+    if (tokens.length < 2) {
+        throw new WorldOrbitError("Invalid object declaration", line, tokens[0]?.column ?? 1);
+    }
+    const [objectTypeToken, nameToken, ...rest] = tokens;
+    if (!OBJECT_TYPES.has(objectTypeToken.value)) {
+        throw new WorldOrbitError(`Unknown object type "${objectTypeToken.value}"`, line, objectTypeToken.column);
+    }
+    return {
+        type: "object",
+        objectType: objectTypeToken.value,
+        name: nameToken.value,
+        inlineFields: parseInlineFields(rest, line),
+        blockFields: [],
+        infoEntries: [],
+        location: { line, column: objectTypeToken.column },
+    };
+}
+function parseInlineFields(tokens, line) {
+    const fields = [];
+    let index = 0;
+    while (index < tokens.length) {
+        const keyToken = tokens[index];
+        index++;
+        const valueTokens = [];
+        if (INLINE_MULTI_VALUE_KEYS.has(keyToken.value)) {
+            while (index < tokens.length && !KNOWN_FIELD_KEYS.has(tokens[index].value)) {
+                valueTokens.push(tokens[index]);
+                index++;
+            }
+        }
+        else {
+            const nextToken = tokens[index];
+            if (nextToken) {
+                valueTokens.push(nextToken);
+                index++;
+            }
+        }
+        if (valueTokens.length === 0) {
+            throw new WorldOrbitError(`Missing value for field "${keyToken.value}"`, line, keyToken.column);
+        }
+        fields.push({
+            type: "field",
+            key: keyToken.value,
+            values: valueTokens.map((token) => token.value),
+            location: { line, column: keyToken.column },
+        });
+    }
+    return fields;
+}
+function parseField(tokens, line) {
+    if (tokens.length < 2) {
+        throw new WorldOrbitError("Invalid field line", line, tokens[0]?.column ?? 1);
+    }
+    return {
+        type: "field",
+        key: tokens[0].value,
+        values: tokens.slice(1).map((token) => token.value),
+        location: { line, column: tokens[0].column },
+    };
+}
+function parseInfoEntry(tokens, line) {
+    if (tokens.length < 2) {
+        throw new WorldOrbitError("Invalid info entry", line, tokens[0]?.column ?? 1);
+    }
+    return {
+        type: "info-entry",
+        key: tokens[0].value,
+        value: tokens.slice(1).map((token) => token.value).join(" "),
+        location: { line, column: tokens[0].column },
+    };
+}

package/dist/render.d.ts

@@ -0,0 +1,6 @@
+import type { CoordinatePoint, RenderScene, SvgRenderOptions, WorldOrbitDocument } from "./types.js";
+export declare function renderDocumentToScene(document: WorldOrbitDocument, options?: SvgRenderOptions): RenderScene;
+export declare function renderSceneToSvg(scene: RenderScene): string;
+export declare function renderDocumentToSvg(document: WorldOrbitDocument, options?: SvgRenderOptions): string;
+export declare function renderSourceToSvg(source: string, options?: SvgRenderOptions): string;
+export declare function rotatePoint(point: CoordinatePoint, center: CoordinatePoint, rotationDeg: number): CoordinatePoint;