freshcoat 0.1.0

package/src/validate-commands.js

@@ -0,0 +1,206 @@
+const MASK_KINDS = new Set([
+    "rect",
+    "rounded-rect",
+    "circle",
+    "ellipse",
+    "polygon",
+    "squircle",
+]);
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+export function validateCommands(commands) {
+    const issues = [];
+    const add = (code, message, path, id) => issues.push(id ? { code, message, path, id } : { code, message, path });
+    const setups = commands.filter((c) => c.op === "createCanvas");
+    if (setups.length === 0)
+        add("missing_create_canvas", "no createCanvas command", "commands");
+    if (setups.length > 1)
+        add("duplicate_create_canvas", `${setups.length} createCanvas commands; a scene is one surface`, "commands");
+    if (setups.length > 0 && commands[0]?.op !== "createCanvas")
+        add("create_canvas_not_first", "createCanvas must be the first command", "commands[0]");
+    commands.forEach((cmd, i) => {
+        const path = `commands[${i}]`;
+        if (cmd.op === "createCanvas") {
+            if (!finite(cmd.width) || cmd.width <= 0)
+                add("bad_canvas_size", `width must be > 0, got ${cmd.width}`, `${path}.width`);
+            if (!finite(cmd.height) || cmd.height <= 0)
+                add("bad_canvas_size", `height must be > 0, got ${cmd.height}`, `${path}.height`);
+            if (cmd.scale !== undefined && (!finite(cmd.scale) || cmd.scale <= 0))
+                add("bad_scale", `scale must be > 0, got ${cmd.scale}`, `${path}.scale`);
+            if (cmd.supersample !== undefined &&
+                (!finite(cmd.supersample) || cmd.supersample < 1))
+                add("bad_supersample", `supersample must be >= 1, got ${cmd.supersample}`, `${path}.supersample`);
+            return;
+        }
+        if (cmd.op === "finishFrame") {
+            validateFinish(cmd.finish, path, add);
+            return;
+        }
+        if (cmd.op === "loadFonts" || cmd.op === "loadImages")
+            return;
+        validateDrawable(cmd, path, add);
+    });
+    return issues;
+}
+function validateFinish(finish, path, add) {
+    const threshold = (v, name) => {
+        if (v === undefined)
+            return;
+        if (!finite(v) || v < 0 || v > 255)
+            add("bad_finish_threshold", `${name} must be within 0..255, got ${v}`, `${path}.finish.${name}`);
+    };
+    threshold(finish.whiteClamp, "whiteClamp");
+    threshold(finish.blackExtract, "blackExtract");
+    const amount = typeof finish.dither === "number" ? finish.dither : finish.dither?.amount;
+    if (amount !== undefined && !finite(amount))
+        add("bad_dither", `dither amount must be finite, got ${amount}`, `${path}.finish.dither`);
+}
+function validateDrawable(cmd, path, add) {
+    const id = cmd.id;
+    if (!finite(cmd.pos?.x) || !finite(cmd.pos?.y))
+        add("bad_pos", "pos.x and pos.y must be finite", `${path}.pos`, id);
+    if (!finite(cmd.size?.width) || !finite(cmd.size?.height))
+        add("bad_size", "size.width and size.height must be finite", `${path}.size`, id);
+    else if (cmd.size.width < 0 || cmd.size.height < 0)
+        add("bad_size", "size must not be negative", `${path}.size`, id);
+    if (cmd.opacity !== undefined &&
+        (!finite(cmd.opacity) || cmd.opacity < 0 || cmd.opacity > 1))
+        add("bad_opacity", `opacity must be within 0..1, got ${cmd.opacity}`, `${path}.opacity`, id);
+    if (cmd.rotation !== undefined && !finite(cmd.rotation))
+        add("bad_rotation", "rotation must be finite", `${path}.rotation`, id);
+    if (cmd.blur !== undefined && (!finite(cmd.blur) || cmd.blur < 0))
+        add("bad_blur", `blur must be >= 0, got ${cmd.blur}`, `${path}.blur`, id);
+    if (cmd.clip && !MASK_KINDS.has(cmd.clip.kind))
+        add("unknown_clip_kind", `unknown clip kind "${cmd.clip.kind}"`, `${path}.clip`, id);
+    if (cmd.clip?.kind === "polygon" &&
+        (!finite(cmd.clip.sides) || cmd.clip.sides < 3))
+        add("bad_polygon", `polygon needs >= 3 sides, got ${cmd.clip.sides}`, `${path}.clip.sides`, id);
+    for (const shadow of cmd.shadow
+        ? Array.isArray(cmd.shadow)
+            ? cmd.shadow
+            : [cmd.shadow]
+        : []) {
+        if (!finite(shadow.blur) || shadow.blur < 0)
+            add("bad_shadow", `shadow.blur must be >= 0, got ${shadow.blur}`, `${path}.shadow`, id);
+        if (!finite(shadow.dx) || !finite(shadow.dy))
+            add("bad_shadow", "shadow dx/dy must be finite", `${path}.shadow`, id);
+    }
+    if (cmd.adjust)
+        validateAdjust(cmd.adjust, `${path}.adjust`, add, id);
+    if ("fills" in cmd && cmd.fills)
+        cmd.fills.forEach((f, i) => {
+            validateFill(f, `${path}.fills[${i}]`, add, id);
+        });
+    if ("stroke" in cmd && cmd.stroke)
+        validateStroke(cmd.stroke, `${path}.stroke`, add, id);
+    if ("cornerRadius" in cmd && cmd.cornerRadius !== undefined)
+        validateCornerRadius(cmd.cornerRadius, `${path}.cornerRadius`, add, id);
+    switch (cmd.op) {
+        case "drawBitmap": {
+            const { pixelWidth: w, pixelHeight: h, pixels } = cmd;
+            if (!Number.isInteger(w) || w <= 0 || !Number.isInteger(h) || h <= 0)
+                add("bad_bitmap_size", `pixelWidth/pixelHeight must be positive integers, got ${w}x${h}`, `${path}`, id);
+            else if (pixels.length !== w * h * 4)
+                add("bitmap_buffer_mismatch", `pixels.length ${pixels.length} != pixelWidth*pixelHeight*4 (${w * h * 4})`, `${path}.pixels`, id);
+            if (cmd.role !== undefined && cmd.role !== "barcode")
+                add("bad_bitmap_role", `role must be "barcode" when set, got ${String(cmd.role)}`, `${path}.role`, id);
+            break;
+        }
+        case "drawPath": {
+            if (!cmd.d)
+                add("empty_path", "path `d` is empty", `${path}.d`, id);
+            if (cmd.viewBox) {
+                const { width, height } = cmd.viewBox;
+                if (!finite(width) || width <= 0 || !finite(height) || height <= 0)
+                    add("bad_viewbox", `viewBox must have positive width/height, got ${width}x${height}`, `${path}.viewBox`, id);
+            }
+            break;
+        }
+        case "drawImage":
+            if (!cmd.src)
+                add("empty_image_src", "image src is empty", `${path}.src`, id);
+            break;
+        case "drawText":
+            if (!cmd.layout?.lines)
+                add("missing_text_lines", "text layout has no lines", `${path}.layout`, id);
+            else
+                cmd.layout.lines.forEach((line, i) => {
+                    if (!line.spans || line.spans.length === 0)
+                        add("empty_text_line", `line ${i} has no spans`, `${path}.layout.lines[${i}]`, id);
+                    if (line.baseline !== undefined && !finite(line.baseline))
+                        add("bad_baseline", `line ${i} baseline is not finite`, `${path}.layout.lines[${i}].baseline`, id);
+                });
+            break;
+        case "drawGroup":
+            cmd.children.forEach((c, i) => {
+                validateDrawable(c, `${path}.children[${i}]`, add);
+            });
+            break;
+        case "drawMasked":
+            if (cmd.channel && cmd.channel !== "alpha" && cmd.channel !== "luminance")
+                add("unknown_mask_channel", `unknown mask channel "${cmd.channel}"`, `${path}.channel`, id);
+            validateDrawable(cmd.mask, `${path}.mask`, add);
+            cmd.children.forEach((c, i) => {
+                validateDrawable(c, `${path}.children[${i}]`, add);
+            });
+            break;
+    }
+}
+function validateAdjust(adjust, path, add, id) {
+    if (adjust.colorMatrix) {
+        if (adjust.colorMatrix.length !== 20)
+            add("bad_color_matrix", `colorMatrix must have 20 entries (4x5), got ${adjust.colorMatrix.length}`, `${path}.colorMatrix`, id);
+        if (!adjust.colorMatrix.every(finite))
+            add("bad_color_matrix", "colorMatrix has a non-finite entry", `${path}.colorMatrix`, id);
+    }
+    if (adjust.lut)
+        for (const ch of ["r", "g", "b"])
+            if (adjust.lut[ch]?.length !== 256)
+                add("bad_lut", `lut.${ch} must have 256 entries, got ${adjust.lut[ch]?.length}`, `${path}.lut.${ch}`, id);
+    if (adjust.lut3d) {
+        const { size, data } = adjust.lut3d;
+        if (!Number.isInteger(size) || size < 2)
+            add("bad_lut3d", `lut3d.size must be an integer >= 2, got ${size}`, `${path}.lut3d.size`, id);
+        else if (data.length !== size ** 3 * 3)
+            add("bad_lut3d", `lut3d.data.length ${data.length} != size^3*3 (${size ** 3 * 3})`, `${path}.lut3d.data`, id);
+    }
+    if (adjust.sharpen !== undefined && !finite(adjust.sharpen))
+        add("bad_sharpen", "sharpen must be finite", `${path}.sharpen`, id);
+    if (adjust.gamut &&
+        adjust.gamut !== "clip" &&
+        adjust.gamut !== "preserve-hue")
+        add("unknown_gamut", `unknown gamut mode "${adjust.gamut}"`, `${path}.gamut`, id);
+}
+function validateFill(fill, path, add, id) {
+    if (fill.kind === "solid")
+        return;
+    const stops = fill.stops;
+    if (!stops || stops.length === 0) {
+        add("empty_gradient", "gradient has no stops", `${path}.stops`, id);
+        return;
+    }
+    let previous = Number.NEGATIVE_INFINITY;
+    stops.forEach((stop, i) => {
+        if (!finite(stop.offset) || stop.offset < 0 || stop.offset > 1)
+            add("bad_stop_offset", `stop offset must be within 0..1, got ${stop.offset}`, `${path}.stops[${i}].offset`, id);
+        // Skia and every vector format read stops in order; an unsorted list is a
+        // different gradient in each, rather than an error in any.
+        if (stop.offset < previous)
+            add("unsorted_stops", `stop ${i} offset ${stop.offset} is below the previous ${previous}`, `${path}.stops[${i}].offset`, id);
+        previous = stop.offset;
+    });
+    if (fill.kind === "radial" && (!finite(fill.radius) || fill.radius <= 0))
+        add("bad_radius", `radial radius must be > 0, got ${fill.radius}`, `${path}.radius`, id);
+}
+function validateStroke(stroke, path, add, id) {
+    if (!finite(stroke.width) || stroke.width < 0)
+        add("bad_stroke_width", `stroke width must be >= 0, got ${stroke.width}`, `${path}.width`, id);
+    if (stroke.dash && !stroke.dash.every((d) => finite(d) && d >= 0))
+        add("bad_dash", "dash segments must be finite and >= 0", `${path}.dash`, id);
+}
+function validateCornerRadius(radius, path, add, id) {
+    const values = Array.isArray(radius) ? radius : [radius];
+    if (Array.isArray(radius) && radius.length !== 4)
+        add("bad_corner_radius", `per-corner radius needs 4 entries, got ${radius.length}`, path, id);
+    if (!values.every((v) => finite(v) && v >= 0))
+        add("bad_corner_radius", "corner radius entries must be finite and >= 0", path, id);
+}