human2ai 0.1.0

package/dist/domain/composition/draft.d.ts

@@ -0,0 +1,50 @@
+import type { AddCompositionImageOptions, AddAreaOptions, AreaAspect, CompositionArea, CompositionAreaMetadataPatch, CompositionClipboardItem, CompositionDraft, CompositionFrameBounds, CompositionFrameCorner, CompositionFrameSize, CompositionImage, CompositionNodeMetadataPatch, PasteCompositionItemsResult, CompositionProcessingSemantic, CompositionVisualWeight, Point, Primitive, VisibleAreaMetrics } from "./types.ts";
+export declare const MAX_FOCUS_POINTS = 3;
+export declare const PRIMITIVES: readonly Primitive[];
+export declare const ASPECTS: readonly AreaAspect[];
+export declare const COMPOSITION_TEXT_REGION_SEMANTIC_TYPE = "text-region";
+export declare const COMPOSITION_PROCESSING_SEMANTICS: readonly CompositionProcessingSemantic[];
+export declare const COMPOSITION_VISUAL_WEIGHTS: readonly CompositionVisualWeight[];
+export declare function createDraft(frame?: CompositionFrameSize): CompositionDraft;
+export declare function validateDraft(input: unknown): CompositionDraft;
+export declare function addFocus(input: CompositionDraft, point: Point): {
+    draft: CompositionDraft;
+    id: string;
+};
+export declare function addArea(input: CompositionDraft, options: AddAreaOptions): {
+    draft: CompositionDraft;
+    id: string;
+};
+export declare function addTextRegion(input: CompositionDraft, options?: Omit<AddAreaOptions, "primitive" | "aspect">): {
+    draft: CompositionDraft;
+    id: string;
+};
+export declare function addCompositionImage(input: CompositionDraft, options?: AddCompositionImageOptions): {
+    draft: CompositionDraft;
+    id: string;
+};
+export declare function isCompositionTextRegion(area: Pick<CompositionArea, "semanticType">): boolean;
+export declare function addDirectionLine(input: CompositionDraft): {
+    draft: CompositionDraft;
+    id: "direction-1";
+};
+export declare function copyCompositionItems(input: CompositionDraft, ids: readonly string[]): CompositionClipboardItem[];
+export declare function pasteCompositionItems(input: CompositionDraft, clipboard: readonly CompositionClipboardItem[], offset: Point): PasteCompositionItemsResult;
+export declare function moveItem(input: CompositionDraft, id: string, point: Point): CompositionDraft;
+export declare function resizeArea(input: CompositionDraft, id: string, nextArea: number): CompositionDraft;
+export declare function resizeFreeArea(input: CompositionDraft, id: string, width: number, height: number): CompositionDraft;
+export declare function rotateArea(input: CompositionDraft, id: string, rotation: number): CompositionDraft;
+export declare function resizeCompositionImage(input: CompositionDraft, id: string, width: number, height: number): CompositionDraft;
+export declare function rotateCompositionImage(input: CompositionDraft, id: string, rotation: number): CompositionDraft;
+export declare function rotateDirectionLine(input: CompositionDraft, id: string, rotation: number): CompositionDraft;
+export declare function setAreaAspect(input: CompositionDraft, id: string, aspect: AreaAspect): CompositionDraft;
+export declare function removeItem(input: CompositionDraft, id: string): CompositionDraft;
+export declare function updateItemMetadata(input: CompositionDraft, id: string, patch: CompositionNodeMetadataPatch): CompositionDraft;
+export declare function updateAreaMetadata(input: CompositionDraft, id: string, patch: CompositionAreaMetadataPatch): CompositionDraft;
+export declare function updateCompositionImage(input: CompositionDraft, id: string, patch: Partial<Pick<CompositionImage, "assetId" | "crop" | "visualWeight">>): CompositionDraft;
+export declare function setProcessingSemantic(input: CompositionDraft, processingSemantic: CompositionProcessingSemantic): CompositionDraft;
+export declare function changeFrame(input: CompositionDraft, frame: CompositionFrameSize): CompositionDraft;
+export declare function moveFrame(input: CompositionDraft, point: Point): CompositionDraft;
+export declare function resizeFrame(input: CompositionDraft, scale: number, corner?: CompositionFrameCorner): CompositionDraft;
+export declare function resizeFrameToBounds(input: CompositionDraft, bounds: CompositionFrameBounds): CompositionDraft;
+export declare function visibleAreaMetrics(input: CompositionDraft): VisibleAreaMetrics;

package/dist/domain/composition/draft.js

@@ -0,0 +1,609 @@
+import { compositionLayerOrder } from "./layers.js";
+import { normalizeCompositionStates } from "./states.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import compositionDraftSchema from "../../../schemas/composition-draft.schema.json" with {
+    type: "json"
+};
+import { createHuman2AiCanvasNodeMetadata, normalizeHuman2AiCanvasNodeMetadata, } from "../canvas-node-metadata.js";
+import { calculateVisibleAreaMetrics, freeDimensionsFromArea, } from "./geometry.js";
+import { COMPOSITION_CANVAS, changeCompositionFrameSize, createCompositionFrame, isCompositionFrameRatioSupported, moveCompositionFrame, resizeCompositionFrame, resizeCompositionFrameToBounds, } from "./frame.js";
+export const MAX_FOCUS_POINTS = 3;
+export const PRIMITIVES = ["circle", "triangle", "quadrilateral"];
+export const ASPECTS = ["square", "free", "landscape", "portrait"];
+export const COMPOSITION_TEXT_REGION_SEMANTIC_TYPE = "text-region";
+export const COMPOSITION_PROCESSING_SEMANTICS = [
+    "scene-composition",
+    "editorial-layout",
+];
+export const COMPOSITION_VISUAL_WEIGHTS = [
+    "auto",
+    "high",
+    "medium",
+    "low",
+    "decorative",
+];
+const ajv = new Ajv2020({ allErrors: true });
+const validateSchema = ajv.compile(compositionDraftSchema);
+export function createDraft(frame = { width: 1600, height: 900 }) {
+    return validateDraft({
+        version: 1,
+        kind: "composition-draft",
+        processingSemantic: null,
+        frame: createCompositionFrame(frame),
+        overallNote: "",
+        focusPoints: [],
+        directionLine: null,
+        areas: [],
+        images: [],
+    });
+}
+export function validateDraft(input) {
+    const normalizedInput = normalizeCompositionItemMetadata(input);
+    if (!validateSchema(normalizedInput)) {
+        throw new Error(formatValidationErrors(validateSchema.errors));
+    }
+    const validatedInput = normalizedInput;
+    validateFrame(validatedInput.frame);
+    const legacyFrame = !validatedInput.frame.bounds;
+    const draft = structuredClone(validatedInput);
+    draft.frame = legacyFrame
+        ? createCompositionFrame(validatedInput.frame)
+        : structuredClone(validatedInput.frame);
+    if (legacyFrame)
+        migrateLegacyDraftCoordinates(draft);
+    const ids = new Set();
+    for (const item of [
+        ...draft.focusPoints,
+        ...(draft.directionLine ? [draft.directionLine] : []),
+        ...draft.areas,
+        ...draft.images,
+    ]) {
+        if (ids.has(item.id))
+            throw new Error(`Duplicate draft item id: ${item.id}.`);
+        ids.add(item.id);
+    }
+    draft.directionLine = draft.directionLine
+        ? { ...draft.directionLine, rotation: normalizeRotation(draft.directionLine.rotation) }
+        : null;
+    draft.areas.forEach((area) => {
+        if (area.primitive === "circle" && area.aspect !== "free")
+            area.rotation = 0;
+        if (area.primitive === "quadrilateral" &&
+            (area.aspect === "landscape" || area.aspect === "portrait")) {
+            Object.assign(area, freeDimensionsFromArea(area.area, COMPOSITION_CANVAS, area.aspect === "landscape" ? 1.6 : 0.625, area.primitive));
+            area.aspect = "free";
+        }
+    });
+    if (draft.layerOrder)
+        draft.layerOrder = compositionLayerOrder(draft);
+    draft.images.forEach((image) => {
+        image.rotation = normalizeRotation(image.rotation);
+        if (image.crop)
+            validateImageCrop(image.crop);
+    });
+    return normalizeCompositionStates(draft);
+}
+export function addFocus(input, point) {
+    const draft = validateDraft(input);
+    if (draft.focusPoints.length >= MAX_FOCUS_POINTS) {
+        throw new Error(`A draft may contain at most ${MAX_FOCUS_POINTS} focus points.`);
+    }
+    const focus = {
+        id: nextId("focus", [...draft.focusPoints, ...draft.areas]),
+        x: point.x,
+        y: point.y,
+        ...createCompositionNodeMetadata(),
+    };
+    draft.focusPoints.push(focus);
+    return { draft, id: focus.id };
+}
+export function addArea(input, options) {
+    const draft = validateDraft(input);
+    if (!PRIMITIVES.includes(options.primitive)) {
+        throw new Error(`Unsupported primitive: ${options.primitive}.`);
+    }
+    const initialArea = Number(options.area) > 0 ? Number(options.area) : 0.08;
+    const aspect = options.aspect && ASPECTS.includes(options.aspect) ? options.aspect : "square";
+    let area = {
+        id: nextId("area", [...draft.focusPoints, ...draft.areas]),
+        primitive: options.primitive,
+        x: Number.isFinite(options.x) ? options.x : 0.5,
+        y: Number.isFinite(options.y) ? options.y : 0.5,
+        area: initialArea,
+        aspect,
+        visualWeight: "auto",
+        rotation: options.primitive === "circle" ? 0 : normalizeRotation(Number(options.rotation) || 0),
+        ...createCompositionNodeMetadata(),
+    };
+    if (aspect === "free") {
+        Object.assign(area, freeDimensionsFromArea(initialArea, COMPOSITION_CANVAS, 1.6, options.primitive));
+    }
+    draft.areas.push(area);
+    return { draft, id: area.id };
+}
+export function addTextRegion(input, options = {}) {
+    const added = addArea(input, {
+        ...options,
+        primitive: "quadrilateral",
+        aspect: "free",
+    });
+    const marked = updateItemMetadata(added.draft, added.id, {
+        semanticType: COMPOSITION_TEXT_REGION_SEMANTIC_TYPE,
+    });
+    return {
+        draft: updateAreaMetadata(marked, added.id, { displayText: "" }),
+        id: added.id,
+    };
+}
+export function addCompositionImage(input, options = {}) {
+    const draft = validateDraft(input);
+    const image = {
+        id: nextId("image", [...draft.focusPoints, ...draft.areas, ...draft.images]),
+        x: Number.isFinite(options.x)
+            ? options.x
+            : draft.frame.bounds.x + draft.frame.bounds.width / 2,
+        y: Number.isFinite(options.y)
+            ? options.y
+            : draft.frame.bounds.y + draft.frame.bounds.height / 2,
+        width: Number.isFinite(options.width) && options.width > 0
+            ? options.width
+            : 320 / COMPOSITION_CANVAS.width,
+        height: Number.isFinite(options.height) && options.height > 0
+            ? options.height
+            : 180 / COMPOSITION_CANVAS.height,
+        rotation: normalizeRotation(Number(options.rotation) || 0),
+        visualWeight: "auto",
+        assetId: null,
+        crop: null,
+        ...createCompositionNodeMetadata(),
+    };
+    draft.images.push(image);
+    return { draft, id: image.id };
+}
+export function isCompositionTextRegion(area) {
+    return area.semanticType === COMPOSITION_TEXT_REGION_SEMANTIC_TYPE;
+}
+export function addDirectionLine(input) {
+    const draft = validateDraft(input);
+    if (draft.directionLine) {
+        throw new Error("A draft may contain at most one direction line.");
+    }
+    draft.directionLine = {
+        id: "direction-1",
+        x: 0.5,
+        y: 0.5,
+        rotation: 0,
+        ...createCompositionNodeMetadata(),
+    };
+    return { draft, id: draft.directionLine.id };
+}
+export function copyCompositionItems(input, ids) {
+    const draft = validateDraft(input);
+    return [...new Set(ids)].flatMap((id) => {
+        const focus = draft.focusPoints.find((item) => item.id === id);
+        if (focus)
+            return [{ kind: "focus", item: structuredClone(focus) }];
+        const area = draft.areas.find((item) => item.id === id);
+        if (area)
+            return [{ kind: "area", item: structuredClone(area) }];
+        const image = draft.images.find((item) => item.id === id);
+        if (image)
+            return [{ kind: "image", item: structuredClone(image) }];
+        if (draft.directionLine?.id === id) {
+            return [{ kind: "direction", item: structuredClone(draft.directionLine) }];
+        }
+        return [];
+    });
+}
+export function pasteCompositionItems(input, clipboard, offset) {
+    const draft = validateDraft(input);
+    const ids = [];
+    for (const entry of clipboard) {
+        if (entry.kind === "focus") {
+            if (draft.focusPoints.length >= MAX_FOCUS_POINTS)
+                continue;
+            const item = {
+                ...structuredClone(entry.item),
+                id: nextId("focus", [...draft.focusPoints, ...draft.areas]),
+                x: entry.item.x + offset.x,
+                y: entry.item.y + offset.y,
+            };
+            draft.focusPoints.push(item);
+            ids.push(item.id);
+            continue;
+        }
+        if (entry.kind === "area") {
+            const item = {
+                ...structuredClone(entry.item),
+                id: nextId("area", [...draft.focusPoints, ...draft.areas]),
+                x: entry.item.x + offset.x,
+                y: entry.item.y + offset.y,
+            };
+            draft.areas.push(item);
+            ids.push(item.id);
+            continue;
+        }
+        if (entry.kind === "image") {
+            const item = {
+                ...structuredClone(entry.item),
+                id: nextId("image", [...draft.focusPoints, ...draft.areas, ...draft.images]),
+                x: entry.item.x + offset.x,
+                y: entry.item.y + offset.y,
+            };
+            draft.images.push(item);
+            ids.push(item.id);
+            continue;
+        }
+        if (!draft.directionLine) {
+            draft.directionLine = {
+                ...structuredClone(entry.item),
+                id: "direction-1",
+                x: entry.item.x + offset.x,
+                y: entry.item.y + offset.y,
+            };
+            ids.push(draft.directionLine.id);
+        }
+    }
+    return { draft: validateDraft(draft), ids };
+}
+export function moveItem(input, id, point) {
+    const draft = validateDraft(input);
+    const focus = draft.focusPoints.find((item) => item.id === id);
+    if (focus) {
+        focus.x = point.x;
+        focus.y = point.y;
+        return draft;
+    }
+    if (draft.directionLine?.id === id) {
+        draft.directionLine.x = point.x;
+        draft.directionLine.y = point.y;
+        return draft;
+    }
+    const item = draft.areas.find((candidate) => candidate.id === id)
+        ?? draft.images.find((candidate) => candidate.id === id);
+    if (!item)
+        throw new Error(`Unknown draft item: ${id}.`);
+    item.x = point.x;
+    item.y = point.y;
+    return draft;
+}
+export function resizeArea(input, id, nextArea) {
+    const draft = validateDraft(input);
+    const area = findArea(draft, id);
+    if (!Number.isFinite(nextArea) || nextArea <= 0)
+        return draft;
+    if (area.aspect === "free") {
+        const scale = Math.sqrt(nextArea / (area.width * area.height));
+        area.width *= scale;
+        area.height *= scale;
+    }
+    area.area = nextArea;
+    return draft;
+}
+export function resizeFreeArea(input, id, width, height) {
+    const draft = validateDraft(input);
+    const area = draft.areas.find((item) => item.id === id);
+    if (!area)
+        throw new Error(`Unknown free area: ${id}.`);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return draft;
+    }
+    area.width = width;
+    area.height = height;
+    area.aspect = "free";
+    const areaFactor = area.primitive === "circle" ? Math.PI / 4 : area.primitive === "triangle" ? 0.5 : 1;
+    area.area = width * height * areaFactor;
+    return draft;
+}
+export function rotateArea(input, id, rotation) {
+    const draft = validateDraft(input);
+    const area = findArea(draft, id);
+    if (area.primitive === "circle" && area.aspect !== "free")
+        return draft;
+    area.rotation = normalizeRotation(rotation);
+    return draft;
+}
+export function resizeCompositionImage(input, id, width, height) {
+    const draft = validateDraft(input);
+    const image = findImage(draft, id);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        return draft;
+    }
+    image.width = width;
+    image.height = height;
+    return draft;
+}
+export function rotateCompositionImage(input, id, rotation) {
+    const draft = validateDraft(input);
+    findImage(draft, id).rotation = normalizeRotation(rotation);
+    return draft;
+}
+export function rotateDirectionLine(input, id, rotation) {
+    const draft = validateDraft(input);
+    if (draft.directionLine?.id !== id) {
+        throw new Error(`Unknown draft direction line: ${id}.`);
+    }
+    draft.directionLine.rotation = normalizeRotation(rotation);
+    return draft;
+}
+export function setAreaAspect(input, id, aspect) {
+    const draft = validateDraft(input);
+    if (!ASPECTS.includes(aspect))
+        throw new Error(`Unsupported aspect: ${aspect}.`);
+    const area = findArea(draft, id);
+    area.aspect = aspect;
+    if (aspect === "free" && (!area.width || !area.height)) {
+        Object.assign(area, freeDimensionsFromArea(area.area, COMPOSITION_CANVAS, 1.6, area.primitive));
+    }
+    else if (aspect !== "free") {
+        delete area.width;
+        delete area.height;
+    }
+    return draft;
+}
+export function removeItem(input, id) {
+    const draft = validateDraft(input);
+    draft.focusPoints = draft.focusPoints.filter((item) => item.id !== id);
+    draft.areas = draft.areas.filter((item) => item.id !== id);
+    draft.images = draft.images.filter((item) => item.id !== id);
+    if (draft.directionLine?.id === id)
+        draft.directionLine = null;
+    if (draft.layerOrder)
+        draft.layerOrder = compositionLayerOrder(draft);
+    return draft;
+}
+export function updateItemMetadata(input, id, patch) {
+    const draft = validateDraft(input);
+    const item = draft.focusPoints.find((candidate) => candidate.id === id)
+        ?? draft.areas.find((candidate) => candidate.id === id)
+        ?? draft.images.find((candidate) => candidate.id === id)
+        ?? (draft.directionLine?.id === id ? draft.directionLine : null);
+    if (!item)
+        throw new Error(`Unknown draft item: ${id}.`);
+    Object.assign(item, patch);
+    return draft;
+}
+export function updateAreaMetadata(input, id, patch) {
+    const draft = validateDraft(input);
+    const area = findArea(draft, id);
+    if (patch.visualWeight !== undefined
+        && !COMPOSITION_VISUAL_WEIGHTS.includes(patch.visualWeight)) {
+        throw new Error(`Unsupported visual weight: ${patch.visualWeight}.`);
+    }
+    if (patch.displayText !== undefined && !isCompositionTextRegion(area)) {
+        throw new Error(`Display text is only supported by text regions: ${id}.`);
+    }
+    if (patch.visualWeight !== undefined)
+        area.visualWeight = patch.visualWeight;
+    if (patch.displayText !== undefined)
+        area.displayText = patch.displayText;
+    if (patch.isLightSource !== undefined)
+        area.isLightSource = patch.isLightSource;
+    return validateDraft(draft);
+}
+export function updateCompositionImage(input, id, patch) {
+    const draft = validateDraft(input);
+    const image = findImage(draft, id);
+    if (patch.visualWeight !== undefined
+        && !COMPOSITION_VISUAL_WEIGHTS.includes(patch.visualWeight)) {
+        throw new Error(`Unsupported visual weight: ${patch.visualWeight}.`);
+    }
+    if (patch.assetId !== undefined && patch.assetId !== null && !patch.assetId.trim()) {
+        throw new Error("Image asset id cannot be empty.");
+    }
+    if (patch.crop)
+        validateImageCrop(patch.crop);
+    Object.assign(image, patch);
+    return draft;
+}
+export function setProcessingSemantic(input, processingSemantic) {
+    const draft = validateDraft(input);
+    if (!COMPOSITION_PROCESSING_SEMANTICS.includes(processingSemantic)) {
+        throw new Error(`Unsupported processing semantic: ${processingSemantic}.`);
+    }
+    draft.processingSemantic = processingSemantic;
+    return draft;
+}
+export function changeFrame(input, frame) {
+    const draft = validateDraft(input);
+    validateFrame(frame);
+    draft.frame = changeCompositionFrameSize(draft.frame, frame);
+    return draft;
+}
+export function moveFrame(input, point) {
+    const draft = validateDraft(input);
+    draft.frame = moveCompositionFrame(draft.frame, point);
+    return draft;
+}
+export function resizeFrame(input, scale, corner = "bottom-right") {
+    const draft = validateDraft(input);
+    if (!Number.isFinite(scale) || scale <= 0)
+        return draft;
+    draft.frame = resizeCompositionFrame(draft.frame, scale, corner);
+    return draft;
+}
+export function resizeFrameToBounds(input, bounds) {
+    const draft = validateDraft(input);
+    draft.frame = resizeCompositionFrameToBounds(draft.frame, bounds);
+    return draft;
+}
+export function visibleAreaMetrics(input) {
+    return calculateVisibleAreaMetrics(validateDraft(input));
+}
+function validateFrame(frame) {
+    if (!frame || typeof frame !== "object" || Array.isArray(frame)) {
+        throw new Error("draft.frame must be an object.");
+    }
+    const values = frame;
+    const unknownFields = Object.keys(values).filter((key) => key !== "width" && key !== "height" && key !== "bounds");
+    if (unknownFields.length > 0) {
+        throw new Error(`draft.frame contains unknown fields: ${unknownFields.join(", ")}.`);
+    }
+    for (const key of ["width", "height"]) {
+        if (!Number.isInteger(values[key]) ||
+            values[key] < 256 ||
+            values[key] > 4096) {
+            throw new Error(`draft.frame.${key} must be an integer from 256 to 4096.`);
+        }
+    }
+    const ratio = values.width / values.height;
+    if (!isCompositionFrameRatioSupported(values.width, values.height)) {
+        throw new Error("Draft aspect ratio must be between 1:2 and 2:1.");
+    }
+    if (values.bounds !== undefined)
+        validateFrameBounds(values.bounds, ratio);
+}
+function normalizeCompositionItemMetadata(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return input;
+    const focusPoints = "focusPoints" in input && Array.isArray(input.focusPoints)
+        ? input.focusPoints.map(normalizeCompositionNodeMetadata)
+        : undefined;
+    const areas = "areas" in input && Array.isArray(input.areas)
+        ? input.areas.map(normalizeCompositionAreaMetadata)
+        : undefined;
+    const images = "images" in input && Array.isArray(input.images)
+        ? input.images.map(normalizeCompositionImageMetadata)
+        : [];
+    const directionLine = "directionLine" in input
+        ? input.directionLine === null
+            ? null
+            : normalizeCompositionNodeMetadata(input.directionLine)
+        : undefined;
+    return {
+        ...input,
+        ...(!("processingSemantic" in input)
+            ? { processingSemantic: null }
+            : {}),
+        ...(!("overallNote" in input) ? { overallNote: "" } : {}),
+        ...(focusPoints ? { focusPoints } : {}),
+        ...(areas ? { areas } : {}),
+        images,
+        ...(directionLine !== undefined ? { directionLine } : {}),
+    };
+}
+function createCompositionNodeMetadata() {
+    return {
+        ...createHuman2AiCanvasNodeMetadata(),
+        shotScale: "auto",
+    };
+}
+function normalizeCompositionNodeMetadata(input) {
+    const normalized = normalizeHuman2AiCanvasNodeMetadata(input);
+    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+        return normalized;
+    }
+    return { shotScale: "auto", ...normalized };
+}
+function normalizeCompositionAreaMetadata(input) {
+    const normalized = normalizeCompositionNodeMetadata(input);
+    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+        return normalized;
+    }
+    const area = {
+        visualWeight: "auto",
+        ...normalized,
+    };
+    return area.semanticType === COMPOSITION_TEXT_REGION_SEMANTIC_TYPE
+        && !("displayText" in area)
+        ? { ...area, displayText: "" }
+        : area;
+}
+function normalizeCompositionImageMetadata(input) {
+    const normalized = normalizeCompositionNodeMetadata(input);
+    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+        return normalized;
+    }
+    return {
+        visualWeight: "auto",
+        assetId: null,
+        crop: null,
+        ...normalized,
+    };
+}
+function validateFrameBounds(bounds, ratio) {
+    if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) {
+        throw new Error("draft.frame.bounds must be an object.");
+    }
+    const values = bounds;
+    const unknownFields = Object.keys(values).filter((key) => !["x", "y", "width", "height"].includes(key));
+    if (unknownFields.length > 0) {
+        throw new Error(`draft.frame.bounds contains unknown fields: ${unknownFields.join(", ")}.`);
+    }
+    for (const key of ["x", "y", "width", "height"]) {
+        if (!Number.isFinite(values[key])) {
+            throw new Error(`draft.frame.bounds.${key} must be a finite number.`);
+        }
+    }
+    const width = values.width;
+    const height = values.height;
+    if (width <= 0 || height <= 0) {
+        throw new Error("draft.frame.bounds width and height must be positive.");
+    }
+    const boundsRatio = (width * COMPOSITION_CANVAS.width) / (height * COMPOSITION_CANVAS.height);
+    if (Math.abs(boundsRatio - ratio) > 0.002) {
+        throw new Error("draft.frame.bounds must match the frame aspect ratio.");
+    }
+}
+function migrateLegacyDraftCoordinates(draft) {
+    const bounds = draft.frame.bounds;
+    const areaScale = bounds.width * bounds.height;
+    const migratePoint = (point) => {
+        point.x = bounds.x + point.x * bounds.width;
+        point.y = bounds.y + point.y * bounds.height;
+    };
+    draft.focusPoints.forEach(migratePoint);
+    if (draft.directionLine)
+        migratePoint(draft.directionLine);
+    draft.areas.forEach((area) => {
+        migratePoint(area);
+        area.area *= areaScale;
+        if (area.width !== undefined)
+            area.width *= bounds.width;
+        if (area.height !== undefined)
+            area.height *= bounds.height;
+    });
+    draft.images.forEach((image) => {
+        migratePoint(image);
+        image.width *= bounds.width;
+        image.height *= bounds.height;
+    });
+}
+function findArea(draft, id) {
+    const area = draft.areas.find((item) => item.id === id);
+    if (!area)
+        throw new Error(`Unknown draft area: ${id}.`);
+    return area;
+}
+function findImage(draft, id) {
+    const image = draft.images.find((item) => item.id === id);
+    if (!image)
+        throw new Error(`Unknown draft image: ${id}.`);
+    return image;
+}
+function nextId(prefix, items) {
+    const used = new Set(items.map((item) => item.id));
+    let index = 1;
+    while (used.has(`${prefix}-${index}`))
+        index += 1;
+    return `${prefix}-${index}`;
+}
+function validateImageCrop(crop) {
+    if (crop.x + crop.width > 1 + 1e-9 || crop.y + crop.height > 1 + 1e-9) {
+        throw new Error("Image crop must stay inside the source image.");
+    }
+}
+function normalizeRotation(value) {
+    return ((value % 360) + 360) % 360;
+}
+function formatValidationErrors(errors) {
+    return (errors ?? [])
+        .map((error) => {
+        if (error.keyword === "additionalProperties") {
+            return `${error.instancePath || "draft"} contains unknown field: ${String(error.params.additionalProperty)}`;
+        }
+        return `${error.instancePath || "draft"} ${error.message ?? "is invalid"}`;
+    })
+        .join("; ");
+}
+//# sourceMappingURL=draft.js.map