@graph-knowledge/api 0.3.2 → 0.9.0

package/src/lib/utils/element-builder.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementBuilder = void 0;
+const uuid_1 = require("./uuid");
+const api_errors_1 = require("../errors/api-errors");
+const element_defaults_1 = require("../constants/element-defaults");
+const text_measurement_service_1 = require("./text-measurement/text-measurement-service");
+const rotation_1 = require("./rotation");
+/**
+ * Builds GraphElement objects from AnyElementInput without persisting to Firestore.
+ *
+ * Handles: validation, default dimensions, centerX/centerY resolution,
+ * text auto-measurement, property building, custom shape enrichment.
+ *
+ * Shared by ElementOperations (single create) and NodeOperations (createWithElements).
+ */
+class ElementBuilder {
+    validatorRegistry;
+    firestore;
+    auth;
+    static _textMeasurementService = null;
+    constructor(validatorRegistry, firestore, auth) {
+        this.validatorRegistry = validatorRegistry;
+        this.firestore = firestore;
+        this.auth = auth;
+    }
+    /**
+     * Builds multiple GraphElements from inputs.
+     * Pre-fetches custom shape definitions with deduplication for efficiency.
+     */
+    async buildMany(inputs) {
+        // Pre-fetch custom shape definitions (one fetch per unique shape)
+        const shapeCache = await this._prefetchCustomShapes(inputs);
+        const elements = [];
+        for (const input of inputs) {
+            elements.push(await this.build(input, shapeCache));
+        }
+        return elements;
+    }
+    /**
+     * Builds a GraphElement from input.
+     * Validates, resolves defaults and center positioning, builds properties,
+     * enriches custom shapes. Does NOT write to Firestore.
+     */
+    async build(input, shapeCache) {
+        // Custom shapes require premium
+        if (input.type.startsWith("custom:")) {
+            await this.auth.requirePremium();
+        }
+        // Validate centerX/centerY conflicts before anything else
+        this.validateCenterPosition(input);
+        // Resolve default dimensions
+        const defaults = this.getDefaultDimensions(input.type);
+        // Resolve text width
+        let resolvedWidth = input.width;
+        if (input.type === "text" && resolvedWidth === undefined) {
+            const textInput = input;
+            if (textInput.maxWidth !== undefined) {
+                resolvedWidth = textInput.maxWidth;
+            }
+            else {
+                resolvedWidth = this.measureTextWidth(textInput);
+            }
+        }
+        const width = resolvedWidth ?? defaults.width;
+        const height = input.height ?? defaults.height;
+        // Resolve centerX/centerY → x/y (after defaults, since center depends on dimensions)
+        const { x, y } = this.resolvePosition(input, width, height);
+        // Create a resolved copy of the input with x/y set for validation
+        const resolvedInput = { ...input, x, y };
+        // Remove center fields so validators don't see unknown properties
+        delete resolvedInput["centerX"];
+        delete resolvedInput["centerY"];
+        // Validate the resolved input (validators expect x/y to be numbers)
+        this.validatorRegistry.validate(resolvedInput);
+        let properties = this.buildProperties(input);
+        // For custom shapes, bake shape definition into properties
+        if (input.type.startsWith("custom:")) {
+            properties = await this._enrichCustomShapeProperties(properties, shapeCache);
+        }
+        const element = {
+            id: (0, uuid_1.generateUuid)(),
+            elementType: input.type,
+            x,
+            y,
+            width,
+            height,
+            rotation: (0, rotation_1.normalizeRotation)(input.rotation ?? 0),
+            properties
+        };
+        // Only add link properties if they have values (Firestore rejects undefined)
+        if (input.isLink !== undefined) {
+            element.isLink = input.isLink;
+        }
+        if (input.linkTarget !== undefined) {
+            element.linkTarget = input.linkTarget;
+        }
+        return element;
+    }
+    /**
+     * Validates that centerX/centerY are not used together with x/y.
+     */
+    validateCenterPosition(input) {
+        // ConnectorInput doesn't support center positioning
+        if (input.type === "connector") {
+            return;
+        }
+        const record = input;
+        const hasCenterX = record["centerX"] !== undefined;
+        const hasCenterY = record["centerY"] !== undefined;
+        if (hasCenterX && input.x !== undefined) {
+            throw new api_errors_1.ValidationError("Cannot specify both x and centerX", "centerX");
+        }
+        if (hasCenterY && input.y !== undefined) {
+            throw new api_errors_1.ValidationError("Cannot specify both y and centerY", "centerY");
+        }
+        // Validate types if provided
+        if (hasCenterX) {
+            const centerX = record["centerX"];
+            if (typeof centerX !== "number" || isNaN(centerX)) {
+                throw new api_errors_1.ValidationError("centerX must be a valid number", "centerX");
+            }
+        }
+        if (hasCenterY) {
+            const centerY = record["centerY"];
+            if (typeof centerY !== "number" || isNaN(centerY)) {
+                throw new api_errors_1.ValidationError("centerY must be a valid number", "centerY");
+            }
+        }
+    }
+    /**
+     * Resolves x/y position, handling centerX/centerY conversion.
+     */
+    resolvePosition(input, width, height) {
+        const record = input;
+        const centerX = record["centerX"];
+        const centerY = record["centerY"];
+        return {
+            x: centerX !== undefined
+                ? centerX - width / 2
+                : (input.x ?? 0),
+            y: centerY !== undefined
+                ? centerY - height / 2
+                : (input.y ?? 0)
+        };
+    }
+    /**
+     * Gets default dimensions for an element type.
+     */
+    getDefaultDimensions(type) {
+        if (type.startsWith("custom:")) {
+            return element_defaults_1.DEFAULT_CUSTOM_SHAPE_DIMENSIONS;
+        }
+        return (element_defaults_1.DEFAULT_ELEMENT_DIMENSIONS[type] ?? element_defaults_1.DEFAULT_CUSTOM_SHAPE_DIMENSIONS);
+    }
+    /**
+     * Auto-measures text width for text elements created without explicit width/maxWidth.
+     */
+    measureTextWidth(input) {
+        if (!ElementBuilder._textMeasurementService) {
+            ElementBuilder._textMeasurementService =
+                new text_measurement_service_1.TextMeasurementService();
+        }
+        const metrics = ElementBuilder._textMeasurementService.measureText(input.text, {
+            fontSize: input.fontSize,
+            fontFamily: input.fontFamily,
+            fontWeight: input.fontWeight,
+            textAlign: input.textAlign,
+            lineHeight: input.lineHeight
+        });
+        return Math.ceil(metrics.width);
+    }
+    /**
+     * Pre-fetches custom shape definitions from the shape store.
+     * Each unique shape is fetched only once for efficiency.
+     */
+    async _prefetchCustomShapes(inputs) {
+        const shapeIds = new Set();
+        for (const input of inputs) {
+            if (input.type.startsWith("custom:")) {
+                const shapeId = input["customShapeId"];
+                if (shapeId) {
+                    shapeIds.add(shapeId);
+                }
+            }
+        }
+        const cache = new Map();
+        await Promise.all(Array.from(shapeIds).map(async (shapeId) => {
+            const shape = await this.firestore.getDocument(`shapeStore/${shapeId}`);
+            if (shape) {
+                cache.set(shapeId, shape);
+            }
+        }));
+        return cache;
+    }
+    /**
+     * Enriches custom shape element properties with shape definition data
+     * from the published shape store or a pre-fetched cache.
+     */
+    async _enrichCustomShapeProperties(properties, shapeCache) {
+        const shapeId = properties["customShapeId"];
+        if (!shapeId) {
+            return properties;
+        }
+        // Skip if already has svgPathData (caller provided it explicitly)
+        if (properties["svgPathData"]) {
+            return properties;
+        }
+        // Use cache if available, otherwise fetch directly
+        const shape = shapeCache
+            ? shapeCache.get(shapeId) ?? null
+            : await this.firestore.getDocument(`shapeStore/${shapeId}`);
+        if (!shape) {
+            return properties;
+        }
+        return {
+            ...properties,
+            svgPathData: shape.svgPathData,
+            viewBox: shape.viewBox,
+            aspectRatioLocked: shape.aspectRatioLocked ?? false
+        };
+    }
+    /**
+     * Builds properties object from element input.
+     * Extracts type-specific properties, excluding common/positional fields.
+     */
+    buildProperties(input) {
+        const props = {
+            __schemaVersion: 1
+        };
+        // Exclude common fields, positional aliases, and convenience aliases
+        const commonFields = new Set([
+            "type",
+            "x",
+            "y",
+            "centerX",
+            "centerY",
+            "width",
+            "height",
+            "rotation",
+            "isLink",
+            "linkTarget",
+            "maxWidth"
+        ]);
+        for (const [key, value] of Object.entries(input)) {
+            if (!commonFields.has(key) && value !== undefined) {
+                props[key] = value;
+            }
+        }
+        // For text elements, set __usesTopLeft: true so the app knows
+        // that x/y is the bounding box top-left, not the text anchor point.
+        if (input.type === "text") {
+            props["__usesTopLeft"] = true;
+        }
+        return props;
+    }
+}
+exports.ElementBuilder = ElementBuilder;

package/src/lib/utils/rotation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Normalizes rotation to integer in range [0, 360).
+ */
+export declare function normalizeRotation(rotation: number): number;

package/src/lib/utils/rotation.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRotation = normalizeRotation;
+/**
+ * Normalizes rotation to integer in range [0, 360).
+ */
+function normalizeRotation(rotation) {
+    let normalized = rotation % 360;
+    if (normalized < 0) {
+        normalized += 360;
+    }
+    return Math.round(normalized);
+}

package/src/lib/validators/custom-shape-definition-validator.d.ts

@@ -0,0 +1,17 @@
+import { CreateCustomShapeInput, UpdateCustomShapeInput } from "../types/api-types";
+/**
+ * Validator for custom shape operations.
+ */
+export declare class CustomShapeDefinitionValidator {
+    /**
+     * Validates input for custom shape creation.
+     */
+    validateCreate(input: CreateCustomShapeInput): void;
+    /**
+     * Validates input for custom shape update.
+     */
+    validateUpdate(input: UpdateCustomShapeInput): void;
+    private _validateViewBox;
+    private _validateDimension;
+    private _validateDefaultProperties;
+}

package/src/lib/validators/custom-shape-definition-validator.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomShapeDefinitionValidator = void 0;
+const api_errors_1 = require("../errors/api-errors");
+/**
+ * Validator for custom shape operations.
+ */
+class CustomShapeDefinitionValidator {
+    /**
+     * Validates input for custom shape creation.
+     */
+    validateCreate(input) {
+        if (!input.name || typeof input.name !== "string") {
+            throw new api_errors_1.ValidationError("name is required", "name");
+        }
+        if (input.name.trim().length === 0) {
+            throw new api_errors_1.ValidationError("name cannot be empty", "name");
+        }
+        if (input.name.length > 100) {
+            throw new api_errors_1.ValidationError("name must be 100 characters or less", "name");
+        }
+        if (!input.svgPathData || typeof input.svgPathData !== "string") {
+            throw new api_errors_1.ValidationError("svgPathData is required", "svgPathData");
+        }
+        if (input.svgPathData.trim().length === 0) {
+            throw new api_errors_1.ValidationError("svgPathData cannot be empty", "svgPathData");
+        }
+        if (!input.viewBox) {
+            throw new api_errors_1.ValidationError("viewBox is required", "viewBox");
+        }
+        this._validateViewBox(input.viewBox);
+        if (input.description !== undefined && typeof input.description !== "string") {
+            throw new api_errors_1.ValidationError("description must be a string", "description");
+        }
+        if (input.icon !== undefined && typeof input.icon !== "string") {
+            throw new api_errors_1.ValidationError("icon must be a string", "icon");
+        }
+        if (input.category !== undefined && typeof input.category !== "string") {
+            throw new api_errors_1.ValidationError("category must be a string", "category");
+        }
+        this._validateDimension(input.defaultWidth, "defaultWidth");
+        this._validateDimension(input.defaultHeight, "defaultHeight");
+        if (input.aspectRatioLocked !== undefined && typeof input.aspectRatioLocked !== "boolean") {
+            throw new api_errors_1.ValidationError("aspectRatioLocked must be a boolean", "aspectRatioLocked");
+        }
+        if (input.defaultProperties !== undefined) {
+            this._validateDefaultProperties(input.defaultProperties);
+        }
+    }
+    /**
+     * Validates input for custom shape update.
+     */
+    validateUpdate(input) {
+        if (input.name !== undefined) {
+            if (typeof input.name !== "string") {
+                throw new api_errors_1.ValidationError("name must be a string", "name");
+            }
+            if (input.name.trim().length === 0) {
+                throw new api_errors_1.ValidationError("name cannot be empty", "name");
+            }
+            if (input.name.length > 100) {
+                throw new api_errors_1.ValidationError("name must be 100 characters or less", "name");
+            }
+        }
+        if (input.svgPathData !== undefined) {
+            if (typeof input.svgPathData !== "string") {
+                throw new api_errors_1.ValidationError("svgPathData must be a string", "svgPathData");
+            }
+            if (input.svgPathData.trim().length === 0) {
+                throw new api_errors_1.ValidationError("svgPathData cannot be empty", "svgPathData");
+            }
+        }
+        if (input.viewBox !== undefined) {
+            this._validateViewBox(input.viewBox);
+        }
+        if (input.description !== undefined && typeof input.description !== "string") {
+            throw new api_errors_1.ValidationError("description must be a string", "description");
+        }
+        if (input.icon !== undefined && typeof input.icon !== "string") {
+            throw new api_errors_1.ValidationError("icon must be a string", "icon");
+        }
+        if (input.category !== undefined && typeof input.category !== "string") {
+            throw new api_errors_1.ValidationError("category must be a string", "category");
+        }
+        this._validateDimension(input.defaultWidth, "defaultWidth");
+        this._validateDimension(input.defaultHeight, "defaultHeight");
+        if (input.aspectRatioLocked !== undefined && typeof input.aspectRatioLocked !== "boolean") {
+            throw new api_errors_1.ValidationError("aspectRatioLocked must be a boolean", "aspectRatioLocked");
+        }
+        if (input.defaultProperties !== undefined) {
+            this._validateDefaultProperties(input.defaultProperties);
+        }
+    }
+    _validateViewBox(viewBox) {
+        if (typeof viewBox.width !== "number" || viewBox.width <= 0) {
+            throw new api_errors_1.ValidationError("viewBox.width must be a positive number", "viewBox.width");
+        }
+        if (typeof viewBox.height !== "number" || viewBox.height <= 0) {
+            throw new api_errors_1.ValidationError("viewBox.height must be a positive number", "viewBox.height");
+        }
+        if (typeof viewBox.minX !== "number" || isNaN(viewBox.minX)) {
+            throw new api_errors_1.ValidationError("viewBox.minX must be a valid number", "viewBox.minX");
+        }
+        if (typeof viewBox.minY !== "number" || isNaN(viewBox.minY)) {
+            throw new api_errors_1.ValidationError("viewBox.minY must be a valid number", "viewBox.minY");
+        }
+    }
+    _validateDimension(value, field) {
+        if (value !== undefined) {
+            if (typeof value !== "number" || isNaN(value)) {
+                throw new api_errors_1.ValidationError(`${field} must be a valid number`, field);
+            }
+            if (value < 10 || value > 2000) {
+                throw new api_errors_1.ValidationError(`${field} must be between 10 and 2000`, field);
+            }
+        }
+    }
+    _validateDefaultProperties(props) {
+        if (props.fillColor !== undefined && typeof props.fillColor !== "string") {
+            throw new api_errors_1.ValidationError("defaultProperties.fillColor must be a string", "defaultProperties.fillColor");
+        }
+        if (props.strokeColor !== undefined && typeof props.strokeColor !== "string") {
+            throw new api_errors_1.ValidationError("defaultProperties.strokeColor must be a string", "defaultProperties.strokeColor");
+        }
+        if (props.strokeWidth !== undefined) {
+            if (typeof props.strokeWidth !== "number" || isNaN(props.strokeWidth)) {
+                throw new api_errors_1.ValidationError("defaultProperties.strokeWidth must be a valid number", "defaultProperties.strokeWidth");
+            }
+            if (props.strokeWidth < 0 || props.strokeWidth > 50) {
+                throw new api_errors_1.ValidationError("defaultProperties.strokeWidth must be between 0 and 50", "defaultProperties.strokeWidth");
+            }
+        }
+    }
+}
+exports.CustomShapeDefinitionValidator = CustomShapeDefinitionValidator;

package/src/lib/validators/element-type-validators/base-element-validator.d.ts

@@ -32,4 +32,8 @@ export declare abstract class BaseElementValidator {
      * Validates stroke width.
      */
     protected validateStrokeWidth(value: unknown, field: string): void;
+    /**
+     * Validates optional text label properties shared by basic shapes.
+     */
+    protected validateTextLabelProperties(input: Record<string, unknown>): void;
 }

package/src/lib/validators/element-type-validators/base-element-validator.js

@@ -96,5 +96,35 @@ class BaseElementValidator {
             throw new api_errors_1.ValidationError(`${field} must be non-negative`, field);
         }
     }
+    /**
+     * Validates optional text label properties shared by basic shapes.
+     */
+    validateTextLabelProperties(input) {
+        if (input["text"] !== undefined && typeof input["text"] !== "string") {
+            throw new api_errors_1.ValidationError("text must be a string", "text");
+        }
+        if (input["fontSize"] !== undefined) {
+            const fs = input["fontSize"];
+            if (typeof fs !== "number" || isNaN(fs)) {
+                throw new api_errors_1.ValidationError("fontSize must be a valid number", "fontSize");
+            }
+            if (fs < 1 || fs > 200) {
+                throw new api_errors_1.ValidationError("fontSize must be between 1 and 200", "fontSize");
+            }
+        }
+        this.validateColor(input["textColor"], "textColor");
+        if (input["textAlign"] !== undefined) {
+            const valid = ["left", "center", "right"];
+            if (!valid.includes(input["textAlign"])) {
+                throw new api_errors_1.ValidationError(`textAlign must be one of: ${valid.join(", ")}`, "textAlign");
+            }
+        }
+        if (input["verticalAlign"] !== undefined) {
+            const valid = ["top", "middle", "bottom"];
+            if (!valid.includes(input["verticalAlign"])) {
+                throw new api_errors_1.ValidationError(`verticalAlign must be one of: ${valid.join(", ")}`, "verticalAlign");
+            }
+        }
+    }
 }
 exports.BaseElementValidator = BaseElementValidator;

package/src/lib/validators/element-type-validators/basic-shape-validators.js

@@ -19,6 +19,8 @@ class BasicShapeValidator extends base_element_validator_1.BaseElementValidator
         this.validateColor(shapeInput.fillColor, "fillColor");
         this.validateColor(shapeInput.strokeColor, "strokeColor");
         this.validateStrokeWidth(shapeInput.strokeWidth, "strokeWidth");
+        // Validate text label properties
+        this.validateTextLabelProperties(shapeInput);
     }
 }
 /**

package/src/lib/validators/element-type-validators/bezier-curve-validator.d.ts

@@ -0,0 +1,12 @@
+import { IElementTypeValidator } from "../../interfaces/element-validator.interface";
+import { AnyElementInput } from "../../types/element-input-types";
+import { BaseElementValidator } from "./base-element-validator";
+/**
+ * Validator for bezier curve elements.
+ */
+export declare class BezierCurveValidator extends BaseElementValidator implements IElementTypeValidator {
+    readonly elementType = "bezier-curve";
+    validate(input: AnyElementInput): void;
+    private validateLineStyle;
+    private validateNumber;
+}

package/src/lib/validators/element-type-validators/bezier-curve-validator.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BezierCurveValidator = void 0;
+const api_errors_1 = require("../../errors/api-errors");
+const base_element_validator_1 = require("./base-element-validator");
+/**
+ * Validator for bezier curve elements.
+ */
+class BezierCurveValidator extends base_element_validator_1.BaseElementValidator {
+    elementType = "bezier-curve";
+    validate(input) {
+        if (input.type !== "bezier-curve") {
+            throw new api_errors_1.ValidationError(`Expected type "bezier-curve", got "${input.type}"`, "type");
+        }
+        const curveInput = input;
+        // Validate common properties
+        this.validateCommon(curveInput);
+        // Validate stroke properties
+        this.validateColor(curveInput.strokeColor, "strokeColor");
+        this.validateStrokeWidth(curveInput.strokeWidth, "strokeWidth");
+        this.validateLineStyle(curveInput.lineStyle);
+        // Validate control point offsets (must be numbers if provided)
+        this.validateNumber(curveInput.controlPoint1X, "controlPoint1X");
+        this.validateNumber(curveInput.controlPoint1Y, "controlPoint1Y");
+        this.validateNumber(curveInput.controlPoint2X, "controlPoint2X");
+        this.validateNumber(curveInput.controlPoint2Y, "controlPoint2Y");
+    }
+    validateLineStyle(value) {
+        if (value === undefined)
+            return;
+        if (typeof value !== "string") {
+            throw new api_errors_1.ValidationError("lineStyle must be a string", "lineStyle");
+        }
+        const validStyles = ["solid", "dashed", "dotted"];
+        if (!validStyles.includes(value)) {
+            throw new api_errors_1.ValidationError(`lineStyle must be one of: ${validStyles.join(", ")}`, "lineStyle");
+        }
+    }
+    validateNumber(value, field) {
+        if (value === undefined)
+            return;
+        if (typeof value !== "number" || isNaN(value)) {
+            throw new api_errors_1.ValidationError(`${field} must be a valid number`, field);
+        }
+    }
+}
+exports.BezierCurveValidator = BezierCurveValidator;

package/src/lib/validators/element-type-validators/block-arrow-validator.js

@@ -20,6 +20,8 @@ class BlockArrowValidator extends base_element_validator_1.BaseElementValidator
         this.validateColor(blockArrowInput.strokeColor, "strokeColor");
         this.validateStrokeWidth(blockArrowInput.strokeWidth, "strokeWidth");
         this.validateDirection(blockArrowInput.direction);
+        // Validate text label properties
+        this.validateTextLabelProperties(blockArrowInput);
     }
     validateDirection(value) {
         if (value === undefined)

package/src/lib/validators/element-type-validators/line-validator.d.ts

@@ -8,4 +8,5 @@ export declare class LineValidator extends BaseElementValidator implements IElem
     readonly elementType = "line";
     validate(input: AnyElementInput): void;
     private validateLineStyle;
+    private validateMarker;
 }

package/src/lib/validators/element-type-validators/line-validator.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineValidator = void 0;
 const api_errors_1 = require("../../errors/api-errors");
 const base_element_validator_1 = require("./base-element-validator");
+const VALID_LINE_STYLES = ["solid", "dashed", "dotted"];
+const VALID_MARKERS = ["none", "arrow", "diamond", "circle"];
 /**
  * Validator for line elements.
  */
@@ -19,16 +21,21 @@ class LineValidator extends base_element_validator_1.BaseElementValidator {
         this.validateColor(lineInput.strokeColor, "strokeColor");
         this.validateStrokeWidth(lineInput.strokeWidth, "strokeWidth");
         this.validateLineStyle(lineInput.lineStyle);
+        this.validateMarker(lineInput.startMarker, "startMarker");
+        this.validateMarker(lineInput.endMarker, "endMarker");
     }
     validateLineStyle(value) {
         if (value === undefined)
             return;
-        if (typeof value !== "string") {
-            throw new api_errors_1.ValidationError("lineStyle must be a string", "lineStyle");
+        if (!VALID_LINE_STYLES.includes(value)) {
+            throw new api_errors_1.ValidationError(`lineStyle must be one of: ${VALID_LINE_STYLES.join(", ")}`, "lineStyle");
         }
-        const validStyles = ["solid", "dashed", "dotted"];
-        if (!validStyles.includes(value)) {
-            throw new api_errors_1.ValidationError(`lineStyle must be one of: ${validStyles.join(", ")}`, "lineStyle");
+    }
+    validateMarker(value, field) {
+        if (value === undefined)
+            return;
+        if (!VALID_MARKERS.includes(value)) {
+            throw new api_errors_1.ValidationError(`${field} must be one of: ${VALID_MARKERS.join(", ")}`, field);
         }
     }
 }

package/src/lib/validators/element-type-validators/rectangle-validator.js

@@ -20,6 +20,8 @@ class RectangleValidator extends base_element_validator_1.BaseElementValidator {
         this.validateColor(rectangleInput.strokeColor, "strokeColor");
         this.validateStrokeWidth(rectangleInput.strokeWidth, "strokeWidth");
         this.validateCornerRadius(rectangleInput.cornerRadius);
+        // Validate text label properties
+        this.validateTextLabelProperties(rectangleInput);
     }
     validateCornerRadius(value) {
         if (value === undefined)

package/src/lib/validators/element-validator-registry.js

@@ -8,6 +8,7 @@ const connector_validator_1 = require("./element-type-validators/connector-valid
 const uml_validators_1 = require("./element-type-validators/uml-validators");
 const basic_shape_validators_1 = require("./element-type-validators/basic-shape-validators");
 const line_validator_1 = require("./element-type-validators/line-validator");
+const bezier_curve_validator_1 = require("./element-type-validators/bezier-curve-validator");
 const block_arrow_validator_1 = require("./element-type-validators/block-arrow-validator");
 const custom_shape_validator_1 = require("./element-type-validators/custom-shape-validator");
 /**
@@ -39,6 +40,7 @@ class ElementValidatorRegistry {
         this.register(new basic_shape_validators_1.HexagonValidator());
         this.register(new basic_shape_validators_1.EllipseValidator());
         this.register(new line_validator_1.LineValidator());
+        this.register(new bezier_curve_validator_1.BezierCurveValidator());
         this.register(new block_arrow_validator_1.BlockArrowValidator());
     }
     register(validator) {

package/src/lib/validators/template-validator.d.ts

@@ -1,4 +1,4 @@
-import { CreateTemplateInput } from "../types/api-types";
+import { CreateTemplateInput, UpdateTemplateInput } from "../types/api-types";
 /**
  * Validator for template operations.
  */
@@ -9,6 +9,12 @@ export declare class TemplateValidator {
      * @throws ValidationError if validation fails
      */
     validateCreate(input: CreateTemplateInput): void;
+    /**
+     * Validates input for template update.
+     * @param input The update input to validate
+     * @throws ValidationError if validation fails
+     */
+    validateUpdate(input: UpdateTemplateInput): void;
     /**
      * Validates canvas dimensions.
      */