@sebastianwessel/isostate 0.1.2 → 0.2.0

package/dist/dsl/index.js

@@ -45,6 +45,7 @@ const VALID_CONNECTOR_SIDES = new Set(["auto", "top", "right", "bottom", "left",
 const VALID_CONNECTOR_ROUTING_MODES = new Set(["straight", "orthogonal", "manual"]);
 const VALID_CONNECTOR_ROUTING_PREFERENCES = new Set(["direct", "fewest-bends", "shortest"]);
 const VALID_CONNECTOR_LANES = new Set(["none", "center-dashed"]);
+const VALID_CAMERA_EASINGS = new Set(["linear", "ease-in-out", "ease-out"]);
 const VALID_TEXT_ALIGN = new Set(["start", "middle", "end"]);
 const VALID_TEXT_WEIGHT = new Set(["normal", "bold"]);
 const VALID_LINE_CAPS = new Set(["butt", "round", "square"]);
@@ -557,6 +558,7 @@ function validateSceneObjectDeltas(document, errors) {
         }
         connectors.set(connection.id, normalizeConnectionPlacement(document, connection));
     }
+    validateCamera(first.camera, first.id, elements, connectors, errors);
     for (const scene of document.scenes.slice(1)) {
         const updateIds = new Set();
         for (const update of scene.update?.elements ?? []) {
@@ -648,6 +650,7 @@ function validateSceneObjectDeltas(document, errors) {
                 }));
             }
         }
+        validateCamera(scene.camera, scene.id, elementsForConnections, connectors, errors);
         for (const update of scene.update?.elements ?? []) {
             const existing = elements.get(update.id);
             if (existing) {
@@ -688,6 +691,55 @@ function collectDocumentElementIds(document) {
     }
     return ids;
 }
+function validateCamera(camera, sceneId, elements, connectors, errors) {
+    if (!camera)
+        return;
+    const target = camera.target;
+    const hasElement = "element" in target && target.element !== undefined;
+    const hasArea = "area" in target && target.area !== undefined;
+    const hasReset = "reset" in target && target.reset !== undefined;
+    const targetCount = Number(hasElement) + Number(hasArea) + Number(hasReset);
+    if (targetCount !== 1) {
+        errors.push(issue("INVALID_CAMERA_TARGET", "Camera target must use exactly one target kind", { sceneId }));
+    }
+    if (hasElement) {
+        if (!isValidIdentifier(target.element)) {
+            errors.push(issue("INVALID_CAMERA_TARGET", "Camera element target must be kebab-case", { sceneId }));
+        }
+        else if (connectors.has(target.element)) {
+            errors.push(issue("INVALID_CAMERA_TARGET", "Camera element target cannot reference a connector", { sceneId }));
+        }
+        else if (!elements.has(target.element)) {
+            errors.push(issue("CAMERA_TARGET_NOT_FOUND", `Camera target "${target.element}" was not found`, {
+                sceneId,
+                elementId: target.element,
+            }));
+        }
+    }
+    if (hasArea) {
+        if (!isValidPosition(target.area.at) || !isValidPositiveTuple(target.area.size)) {
+            errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera area must use non-negative at and positive size", { sceneId }));
+        }
+    }
+    if (hasReset && target.reset !== true) {
+        errors.push(issue("INVALID_CAMERA_TARGET", "Camera reset target must be true", { sceneId }));
+    }
+    if (camera.padding !== undefined) {
+        if (hasReset) {
+            errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera reset must not define padding", { sceneId }));
+        }
+        if (!Number.isFinite(camera.padding) || camera.padding < 0 || camera.padding > 2048) {
+            errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera padding is invalid", { sceneId }));
+        }
+    }
+    if (camera.duration !== undefined &&
+        (!Number.isInteger(camera.duration) || camera.duration < 0 || camera.duration > 10000)) {
+        errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera duration is invalid", { sceneId }));
+    }
+    if (camera.easing !== undefined && !VALID_CAMERA_EASINGS.has(camera.easing)) {
+        errors.push(issue("INVALID_CAMERA_OPTIONS", "Camera easing is invalid", { sceneId }));
+    }
+}
 function validateEndpointRemovalRule(scene, connectors, errors) {
     const removedElements = new Set((scene.remove?.elements ?? []).map((removal) => removal.id));
     if (removedElements.size === 0)
@@ -1089,6 +1141,7 @@ function resolveSceneSnapshots(document) {
             progress: progress[index],
             elements: snapshotElements,
             connectors: snapshotConnectors,
+            ...(scene.camera ? { camera: normalizeCamera(scene.camera) } : {}),
         });
         for (const removal of scene.remove?.connections ?? []) {
             currentConnectors.delete(removal.id);
@@ -1099,6 +1152,26 @@ function resolveSceneSnapshots(document) {
     }
     return snapshots;
 }
+function normalizeCamera(camera) {
+    const normalized = "element" in camera.target && camera.target.element !== undefined
+        ? {
+            target: { type: "element", id: camera.target.element },
+            padding: camera.padding ?? 32,
+        }
+        : "area" in camera.target && camera.target.area !== undefined
+            ? {
+                target: { type: "area", at: camera.target.area.at, size: camera.target.area.size },
+                padding: camera.padding ?? 32,
+            }
+            : {
+                target: { type: "reset" },
+            };
+    if (camera.duration !== undefined)
+        normalized.duration = camera.duration;
+    if (camera.easing !== undefined)
+        normalized.easing = camera.easing;
+    return normalized;
+}
 function deriveProgresses(scenes) {
     if (scenes.length <= 1) {
         return scenes.map(() => 0);
@@ -1413,7 +1486,7 @@ function isGridAxisRoute(route) {
     return true;
 }
 
-const DEFAULT_VERSION = "0.1.2";
+const DEFAULT_VERSION = "0.2.0";
 const RUNTIME_BUNDLE_FORMAT = "isostate-runtime-bundle";
 const BUILT_IN_TEXT_ASSET_ID = "text";
 const BUILT_IN_PRIMITIVE_ASSET_IDS = new Set(["rectangle", "circle", "polygon", "line"]);
@@ -2116,10 +2189,43 @@ function parseConnectionRemoval(raw, context) {
     }
     return parsed;
 }
+function parseCamera(raw, context) {
+    const camera = requireObject(raw, context);
+    assertKnownFields(camera, new Set(["target", "padding", "duration", "easing"]), context);
+    const target = requireObject(camera.target, `${context}.target`);
+    assertKnownFields(target, new Set(["element", "area", "reset"]), `${context}.target`);
+    const parsed = { target: {} };
+    if (target.element !== undefined) {
+        parsed.target = { element: requireIdentifier(target.element, `${context}.target.element`) };
+    }
+    if (target.area !== undefined) {
+        const area = requireObject(target.area, `${context}.target.area`);
+        assertKnownFields(area, new Set(["at", "size"]), `${context}.target.area`);
+        parsed.target = {
+            area: {
+                at: parseTuple2(area.at, `${context}.target.area.at`),
+                size: parseTuple2(area.size, `${context}.target.area.size`),
+            },
+        };
+    }
+    if (target.reset !== undefined) {
+        parsed.target = { reset: requireBoolean(target.reset, `${context}.target.reset`) };
+    }
+    if (camera.padding !== undefined) {
+        parsed.padding = requireNumber(camera.padding, `${context}.padding`);
+    }
+    if (camera.duration !== undefined) {
+        parsed.duration = requireNumber(camera.duration, `${context}.duration`);
+    }
+    if (camera.easing !== undefined) {
+        parsed.easing = requireString(camera.easing, `${context}.easing`);
+    }
+    return parsed;
+}
 function parseScenes(raw) {
     return requireArray(raw, "scenes").map((item, index) => {
         const scene = requireObject(item, `scenes[${index}]`);
-        assertKnownFields(scene, new Set(["id", "elements", "connections", "add", "update", "remove"]), `scenes[${index}]`);
+        assertKnownFields(scene, new Set(["id", "elements", "connections", "add", "update", "remove", "camera"]), `scenes[${index}]`);
         const parsed = {
             id: requireIdentifier(scene.id, `scenes[${index}].id`),
         };
@@ -2162,6 +2268,9 @@ function parseScenes(raw) {
                 parsed.remove.connections = requireArray(remove.connections, `scenes[${index}].remove.connections`).map((removal, removalIndex) => parseConnectionRemoval(removal, `scenes[${index}].remove.connections[${removalIndex}]`));
             }
         }
+        if (scene.camera !== undefined) {
+            parsed.camera = parseCamera(scene.camera, `scenes[${index}].camera`);
+        }
         return parsed;
     });
 }