@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/lib-svg.js

@@ -0,0 +1,1027 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+function asColor(value, fallback) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object" && "value" in value) {
+        return String(value.value ?? fallback);
+    }
+    return fallback;
+}
+function elementToString(el) {
+    const attrs = Object.entries(el.attributes ?? {})
+        .map(([k, v]) => `${k}="${String(v).replaceAll('"', "&quot;")}"`)
+        .join(" ");
+    const open = attrs ? `<${el.name} ${attrs}>` : `<${el.name}>`;
+    const children = (el.children ?? []).map(elementToString).join("");
+    const content = el.content ?? "";
+    return `${open}${content}${children}</${el.name}>`;
+}
+function svgDocument(content, width, height, viewBox) {
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${viewBox}">${content}</svg>`;
+}
+function normalizeContent(content) {
+    if (Array.isArray(content)) {
+        return content.map((c) => normalizeContent(c)).join("\n");
+    }
+    if (content && typeof content === "object" && "name" in content) {
+        return elementToString(content);
+    }
+    return String(content ?? "");
+}
+export class RectLibNode extends BaseNode {
+    static nodeType = "lib.svg.Rect";
+    static title = "Rectangle";
+    static description = "Generate SVG rectangle element with customizable position, size, and styling.\n    svg, shape, vector, rectangle\n\n    Use cases:\n    - Create rectangular shapes in SVG documents\n    - Design borders, frames, and backgrounds\n    - Build user interface components\n    - Create geometric patterns and layouts";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "rect",
+                attributes: {
+                    x: String(this.x ?? 0),
+                    y: String(this.y ?? 0),
+                    width: String(this.width ?? 100),
+                    height: String(this.height ?? 100),
+                    fill: asColor(this.fill, "#000000"),
+                    stroke: asColor(this.stroke, "none"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({ type: "int", default: 0, title: "X", description: "X coordinate" })
+], RectLibNode.prototype, "x", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Y", description: "Y coordinate" })
+], RectLibNode.prototype, "y", void 0);
+__decorate([
+    prop({ type: "int", default: 100, title: "Width", description: "Width" })
+], RectLibNode.prototype, "width", void 0);
+__decorate([
+    prop({ type: "int", default: 100, title: "Height", description: "Height" })
+], RectLibNode.prototype, "height", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Fill color"
+    })
+], RectLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "none"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], RectLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], RectLibNode.prototype, "stroke_width", void 0);
+export class CircleLibNode extends BaseNode {
+    static nodeType = "lib.svg.Circle";
+    static title = "Circle";
+    static description = "Generate SVG circle element with customizable position, radius, and styling.\n    svg, shape, vector, circle\n\n    Use cases:\n    - Create circular shapes and icons\n    - Design buttons, badges, and indicators\n    - Build data visualizations like pie charts\n    - Create decorative elements and patterns";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "circle",
+                attributes: {
+                    cx: String(this.cx ?? 0),
+                    cy: String(this.cy ?? 0),
+                    r: String(this.radius ?? 50),
+                    fill: asColor(this.fill, "#000000"),
+                    stroke: asColor(this.stroke, "none"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Cx",
+        description: "Center X coordinate"
+    })
+], CircleLibNode.prototype, "cx", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Cy",
+        description: "Center Y coordinate"
+    })
+], CircleLibNode.prototype, "cy", void 0);
+__decorate([
+    prop({ type: "int", default: 50, title: "Radius", description: "Radius" })
+], CircleLibNode.prototype, "radius", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Fill color"
+    })
+], CircleLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "none"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], CircleLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], CircleLibNode.prototype, "stroke_width", void 0);
+export class EllipseLibNode extends BaseNode {
+    static nodeType = "lib.svg.Ellipse";
+    static title = "Ellipse";
+    static description = "Generate SVG ellipse element with customizable position, radii, and styling.\n    svg, shape, vector, ellipse\n\n    Use cases:\n    - Create oval shapes and organic forms\n    - Design speech bubbles and callouts\n    - Build data visualization elements\n    - Create decorative patterns and borders";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "ellipse",
+                attributes: {
+                    cx: String(this.cx ?? 0),
+                    cy: String(this.cy ?? 0),
+                    rx: String(this.rx ?? 100),
+                    ry: String(this.ry ?? 50),
+                    fill: asColor(this.fill, "#000000"),
+                    stroke: asColor(this.stroke, "none"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Cx",
+        description: "Center X coordinate"
+    })
+], EllipseLibNode.prototype, "cx", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Cy",
+        description: "Center Y coordinate"
+    })
+], EllipseLibNode.prototype, "cy", void 0);
+__decorate([
+    prop({ type: "int", default: 100, title: "Rx", description: "X radius" })
+], EllipseLibNode.prototype, "rx", void 0);
+__decorate([
+    prop({ type: "int", default: 50, title: "Ry", description: "Y radius" })
+], EllipseLibNode.prototype, "ry", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Fill color"
+    })
+], EllipseLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "none"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], EllipseLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], EllipseLibNode.prototype, "stroke_width", void 0);
+export class LineLibNode extends BaseNode {
+    static nodeType = "lib.svg.Line";
+    static title = "Line";
+    static description = "Generate SVG line element with customizable endpoints and styling.\n    svg, shape, vector, line\n\n    Use cases:\n    - Draw straight lines and connectors\n    - Create dividers and separators\n    - Build diagrams and flowcharts\n    - Design grid patterns and borders";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "line",
+                attributes: {
+                    x1: String(this.x1 ?? 0),
+                    y1: String(this.y1 ?? 0),
+                    x2: String(this.x2 ?? 100),
+                    y2: String(this.y2 ?? 100),
+                    stroke: asColor(this.stroke, "#000000"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "X1",
+        description: "Start X coordinate"
+    })
+], LineLibNode.prototype, "x1", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Y1",
+        description: "Start Y coordinate"
+    })
+], LineLibNode.prototype, "y1", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 100,
+        title: "X2",
+        description: "End X coordinate"
+    })
+], LineLibNode.prototype, "x2", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 100,
+        title: "Y2",
+        description: "End Y coordinate"
+    })
+], LineLibNode.prototype, "y2", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], LineLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], LineLibNode.prototype, "stroke_width", void 0);
+export class PolygonLibNode extends BaseNode {
+    static nodeType = "lib.svg.Polygon";
+    static title = "Polygon";
+    static description = "Generate SVG polygon element with multiple vertices.\n    svg, shape, vector, polygon\n\n    Use cases:\n    - Create multi-sided shapes like triangles, pentagons, stars\n    - Build custom icons and symbols\n    - Design complex geometric patterns\n    - Create irregular shapes and forms";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "polygon",
+                attributes: {
+                    points: String(this.points ?? ""),
+                    fill: asColor(this.fill, "#000000"),
+                    stroke: asColor(this.stroke, "none"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Points",
+        description: "Points in format 'x1,y1 x2,y2 x3,y3...'"
+    })
+], PolygonLibNode.prototype, "points", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Fill color"
+    })
+], PolygonLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "none"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], PolygonLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], PolygonLibNode.prototype, "stroke_width", void 0);
+export class PathLibNode extends BaseNode {
+    static nodeType = "lib.svg.Path";
+    static title = "Path";
+    static description = "Generate SVG path element using path data commands.\n    svg, shape, vector, path\n\n    Use cases:\n    - Create complex curved and custom shapes\n    - Build logos and custom icons\n    - Design intricate patterns and illustrations\n    - Import path data from design tools";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "path",
+                attributes: {
+                    d: String(this.path_data ?? ""),
+                    fill: asColor(this.fill, "#000000"),
+                    stroke: asColor(this.stroke, "none"),
+                    "stroke-width": String(this.stroke_width ?? 1)
+                }
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path Data",
+        description: "SVG path data (d attribute)"
+    })
+], PathLibNode.prototype, "path_data", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Fill color"
+    })
+], PathLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "none"
+        },
+        title: "Stroke",
+        description: "Stroke color"
+    })
+], PathLibNode.prototype, "stroke", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Stroke Width",
+        description: "Stroke width"
+    })
+], PathLibNode.prototype, "stroke_width", void 0);
+export class TextLibNode extends BaseNode {
+    static nodeType = "lib.svg.Text";
+    static title = "Text";
+    static description = "Add text elements to SVG.\n    svg, text, typography\n\n    Use cases:\n    - Add labels to vector graphics\n    - Create text-based logos\n    - Generate dynamic text content in SVGs";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "text",
+                attributes: {
+                    x: String(this.x ?? 0),
+                    y: String(this.y ?? 0),
+                    "font-family": String(this.font_family ?? "Arial"),
+                    "font-size": String(this.font_size ?? 16),
+                    fill: asColor(this.fill, "#000000"),
+                    "text-anchor": String(this.text_anchor ?? "start")
+                },
+                content: String(this.text ?? "")
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Text",
+        description: "Text content"
+    })
+], TextLibNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "X", description: "X coordinate" })
+], TextLibNode.prototype, "x", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Y", description: "Y coordinate" })
+], TextLibNode.prototype, "y", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "Arial",
+        title: "Font Family",
+        description: "Font family"
+    })
+], TextLibNode.prototype, "font_family", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 16,
+        title: "Font Size",
+        description: "Font size"
+    })
+], TextLibNode.prototype, "font_size", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Fill",
+        description: "Text color"
+    })
+], TextLibNode.prototype, "fill", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "start",
+        title: "Text Anchor",
+        description: "Text anchor position",
+        values: ["start", "middle", "end"]
+    })
+], TextLibNode.prototype, "text_anchor", void 0);
+export class GaussianBlurLibNode extends BaseNode {
+    static nodeType = "lib.svg.GaussianBlur";
+    static title = "Gaussian Blur";
+    static description = "Apply Gaussian blur filter effect to SVG elements.\n    svg, filter, blur, effects\n\n    Use cases:\n    - Create soft focus and depth effects\n    - Add subtle shadows and glows\n    - Simulate motion blur\n    - Soften edges in graphics";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "filter",
+                attributes: { id: "filter_gaussian_blur" },
+                children: [
+                    {
+                        name: "feGaussianBlur",
+                        attributes: { stdDeviation: String(this.std_deviation ?? 3) }
+                    }
+                ]
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "float",
+        default: 3,
+        title: "Std Deviation",
+        description: "Standard deviation for blur"
+    })
+], GaussianBlurLibNode.prototype, "std_deviation", void 0);
+export class DropShadowLibNode extends BaseNode {
+    static nodeType = "lib.svg.DropShadow";
+    static title = "Drop Shadow";
+    static description = "Apply drop shadow filter effect to SVG elements for depth.\n    svg, filter, shadow, effects\n\n    Use cases:\n    - Add depth and elevation to elements\n    - Create realistic shadow effects\n    - Enhance visual hierarchy\n    - Improve element separation and readability";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        return {
+            output: {
+                name: "filter",
+                attributes: { id: "filter_drop_shadow" },
+                children: [
+                    {
+                        name: "feGaussianBlur",
+                        attributes: {
+                            in: "SourceAlpha",
+                            stdDeviation: String(this.std_deviation ?? 3)
+                        }
+                    },
+                    {
+                        name: "feOffset",
+                        attributes: { dx: String(this.dx ?? 2), dy: String(this.dy ?? 2) }
+                    },
+                    {
+                        name: "feFlood",
+                        attributes: { "flood-color": asColor(this.color, "#000000") }
+                    },
+                    {
+                        name: "feComposite",
+                        attributes: { operator: "in", in2: "SourceAlpha" }
+                    },
+                    {
+                        name: "feMerge",
+                        children: [
+                            { name: "feMergeNode" },
+                            { name: "feMergeNode", attributes: { in: "SourceGraphic" } }
+                        ]
+                    }
+                ]
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "float",
+        default: 3,
+        title: "Std Deviation",
+        description: "Standard deviation for blur"
+    })
+], DropShadowLibNode.prototype, "std_deviation", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 2,
+        title: "Dx",
+        description: "X offset for shadow"
+    })
+], DropShadowLibNode.prototype, "dx", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 2,
+        title: "Dy",
+        description: "Y offset for shadow"
+    })
+], DropShadowLibNode.prototype, "dy", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Color",
+        description: "Color for shadow"
+    })
+], DropShadowLibNode.prototype, "color", void 0);
+export class DocumentLibNode extends BaseNode {
+    static nodeType = "lib.svg.Document";
+    static title = "SVG Document";
+    static description = "Combine SVG elements into a complete SVG document.\n    svg, document, combine\n\n    Use cases:\n    - Combine multiple SVG elements into a single document\n    - Set document-level properties like viewBox and dimensions\n    - Export complete SVG documents";
+    static metadataOutputTypes = {
+        output: "svg"
+    };
+    async process() {
+        const content = normalizeContent(this.elements ?? []);
+        const width = Number(this.width ?? 800);
+        const height = Number(this.height ?? 600);
+        const viewBox = String(this.viewBox ?? "0 0 800 600");
+        const doc = svgDocument(content, width, height, viewBox);
+        return { output: { data: Buffer.from(doc, "utf-8").toString("base64") } };
+    }
+}
+__decorate([
+    prop({
+        type: "list[svg_element]",
+        default: [],
+        title: "Elements",
+        description: "List of SVG elements"
+    })
+], DocumentLibNode.prototype, "elements", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 800,
+        title: "Width",
+        description: "Document width",
+        min: 1,
+        max: 4096
+    })
+], DocumentLibNode.prototype, "width", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 600,
+        title: "Height",
+        description: "Document height",
+        min: 1,
+        max: 4096
+    })
+], DocumentLibNode.prototype, "height", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "0 0 800 600",
+        title: "Viewbox",
+        description: "SVG viewBox attribute"
+    })
+], DocumentLibNode.prototype, "viewBox", void 0);
+export class SVGToImageLibNode extends BaseNode {
+    static nodeType = "lib.svg.SVGToImage";
+    static title = "SVG to Image";
+    static description = "Create an SVG document and convert it to a raster image in one step.\n    svg, document, raster, convert\n\n    Use cases:\n    - Create and rasterize SVG documents in a single operation\n    - Generate image files from SVG elements\n    - Convert vector graphics to bitmap format with custom dimensions";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    async process() {
+        const sharp = (await import("sharp")).default;
+        const content = normalizeContent(this.elements ?? []);
+        const width = Number(this.width ?? 800);
+        const height = Number(this.height ?? 600);
+        const scale = Number(this.scale ?? 1);
+        const viewBox = String(this.viewBox ?? "0 0 800 600");
+        const doc = svgDocument(content, width, height, viewBox);
+        const svgBuffer = Buffer.from(doc, "utf-8");
+        const pngBuffer = await sharp(svgBuffer, { density: 72 * scale })
+            .resize(width * scale, height * scale)
+            .png()
+            .toBuffer();
+        return {
+            output: {
+                type: "image",
+                data: pngBuffer.toString("base64"),
+                mimeType: "image/png",
+                width: width * scale,
+                height: height * scale
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "list[svg_element]",
+        default: [],
+        title: "Elements",
+        description: "List of SVG elements"
+    })
+], SVGToImageLibNode.prototype, "elements", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 800,
+        title: "Width",
+        description: "Document width",
+        min: 1,
+        max: 4096
+    })
+], SVGToImageLibNode.prototype, "width", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 600,
+        title: "Height",
+        description: "Document height",
+        min: 1,
+        max: 4096
+    })
+], SVGToImageLibNode.prototype, "height", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "0 0 800 600",
+        title: "Viewbox",
+        description: "SVG viewBox attribute"
+    })
+], SVGToImageLibNode.prototype, "viewBox", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1,
+        title: "Scale",
+        description: "Scale factor for rasterization",
+        min: 1,
+        max: 10
+    })
+], SVGToImageLibNode.prototype, "scale", void 0);
+export class GradientLibNode extends BaseNode {
+    static nodeType = "lib.svg.Gradient";
+    static title = "Gradient";
+    static description = "Create linear or radial gradients for SVG elements.\n    svg, gradient, color\n\n    Use cases:\n    - Add smooth color transitions\n    - Create complex color effects\n    - Define reusable gradient definitions";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        const gradientType = String(this.gradient_type ?? "linearGradient");
+        const attrs = { id: `gradient_${gradientType}` };
+        if (gradientType === "linearGradient") {
+            attrs.x1 = `${String(this.x1 ?? 0)}%`;
+            attrs.y1 = `${String(this.y1 ?? 0)}%`;
+            attrs.x2 = `${String(this.x2 ?? 100)}%`;
+            attrs.y2 = `${String(this.y2 ?? 100)}%`;
+        }
+        else {
+            attrs.cx = `${String(this.x1 ?? 0)}%`;
+            attrs.cy = `${String(this.y1 ?? 0)}%`;
+            attrs.r = `${String(this.x2 ?? 100)}%`;
+        }
+        return {
+            output: {
+                name: gradientType,
+                attributes: attrs,
+                children: [
+                    {
+                        name: "stop",
+                        attributes: {
+                            offset: "0%",
+                            style: `stop-color:${asColor(this.color1, "#000000")};stop-opacity:1`
+                        }
+                    },
+                    {
+                        name: "stop",
+                        attributes: {
+                            offset: "100%",
+                            style: `stop-color:${asColor(this.color2, "#FFFFFF")};stop-opacity:1`
+                        }
+                    }
+                ]
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "enum",
+        default: "linearGradient",
+        title: "Gradient Type",
+        description: "Type of gradient",
+        values: ["linearGradient", "radialGradient"]
+    })
+], GradientLibNode.prototype, "gradient_type", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "X1",
+        description: "Start X position (linear) or center X (radial)"
+    })
+], GradientLibNode.prototype, "x1", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Y1",
+        description: "Start Y position (linear) or center Y (radial)"
+    })
+], GradientLibNode.prototype, "y1", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 100,
+        title: "X2",
+        description: "End X position (linear) or radius X (radial)"
+    })
+], GradientLibNode.prototype, "x2", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 100,
+        title: "Y2",
+        description: "End Y position (linear) or radius Y (radial)"
+    })
+], GradientLibNode.prototype, "y2", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#000000"
+        },
+        title: "Color1",
+        description: "Start color of gradient"
+    })
+], GradientLibNode.prototype, "color1", void 0);
+__decorate([
+    prop({
+        type: "color",
+        default: {
+            type: "color",
+            value: "#FFFFFF"
+        },
+        title: "Color2",
+        description: "End color of gradient"
+    })
+], GradientLibNode.prototype, "color2", void 0);
+export class TransformLibNode extends BaseNode {
+    static nodeType = "lib.svg.Transform";
+    static title = "Transform";
+    static description = "Apply transformations to SVG elements.\n    svg, transform, animation\n\n    Use cases:\n    - Rotate, scale, or translate elements\n    - Create complex transformations\n    - Prepare elements for animation";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        const content = { ...(this.content ?? {}) };
+        if (!content || typeof content !== "object" || !("name" in content)) {
+            return { output: { name: "g", attributes: {}, children: [] } };
+        }
+        const transforms = [];
+        const tx = Number(this.translate_x ?? 0);
+        const ty = Number(this.translate_y ?? 0);
+        const rotate = Number(this.rotate ?? 0);
+        const sx = Number(this.scale_x ?? 1);
+        const sy = Number(this.scale_y ?? 1);
+        if (tx !== 0 || ty !== 0)
+            transforms.push(`translate(${tx},${ty})`);
+        if (rotate !== 0)
+            transforms.push(`rotate(${rotate})`);
+        if (sx !== 1 || sy !== 1)
+            transforms.push(`scale(${sx},${sy})`);
+        if (transforms.length > 0) {
+            content.attributes = {
+                ...(content.attributes ?? {}),
+                transform: transforms.join(" ")
+            };
+        }
+        return { output: content };
+    }
+}
+__decorate([
+    prop({
+        type: "svg_element",
+        default: {
+            type: "svg_element",
+            name: "",
+            attributes: {},
+            content: null,
+            children: []
+        },
+        title: "Content",
+        description: "SVG element to transform"
+    })
+], TransformLibNode.prototype, "content", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Translate X",
+        description: "X translation"
+    })
+], TransformLibNode.prototype, "translate_x", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Translate Y",
+        description: "Y translation"
+    })
+], TransformLibNode.prototype, "translate_y", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 0,
+        title: "Rotate",
+        description: "Rotation angle in degrees"
+    })
+], TransformLibNode.prototype, "rotate", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Scale X",
+        description: "X scale factor"
+    })
+], TransformLibNode.prototype, "scale_x", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Scale Y",
+        description: "Y scale factor"
+    })
+], TransformLibNode.prototype, "scale_y", void 0);
+export class ClipPathLibNode extends BaseNode {
+    static nodeType = "lib.svg.ClipPath";
+    static title = "Clip Path";
+    static description = "Create clipping paths for SVG elements.\n    svg, clip, mask\n\n    Use cases:\n    - Mask parts of elements\n    - Create complex shapes through clipping\n    - Apply visual effects using masks";
+    static metadataOutputTypes = {
+        output: "svg_element"
+    };
+    async process() {
+        const clipContent = (this.clip_content ?? {});
+        const content = { ...(this.content ?? {}) };
+        if (!clipContent || !content || !clipContent.name || !content.name) {
+            return { output: { name: "g", attributes: {}, children: [] } };
+        }
+        const clipId = `clip_path_${Date.now()}`;
+        content.attributes = {
+            ...(content.attributes ?? {}),
+            "clip-path": `url(#${clipId})`
+        };
+        return {
+            output: {
+                name: "g",
+                children: [
+                    {
+                        name: "clipPath",
+                        attributes: { id: clipId },
+                        children: [clipContent]
+                    },
+                    content
+                ]
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "svg_element",
+        default: {
+            type: "svg_element",
+            name: "",
+            attributes: {},
+            content: null,
+            children: []
+        },
+        title: "Clip Content",
+        description: "SVG element to use as clip path"
+    })
+], ClipPathLibNode.prototype, "clip_content", void 0);
+__decorate([
+    prop({
+        type: "svg_element",
+        default: {
+            type: "svg_element",
+            name: "",
+            attributes: {},
+            content: null,
+            children: []
+        },
+        title: "Content",
+        description: "SVG element to clip"
+    })
+], ClipPathLibNode.prototype, "content", void 0);
+export const LIB_SVG_NODES = [
+    RectLibNode,
+    CircleLibNode,
+    EllipseLibNode,
+    LineLibNode,
+    PolygonLibNode,
+    PathLibNode,
+    TextLibNode,
+    GaussianBlurLibNode,
+    DropShadowLibNode,
+    DocumentLibNode,
+    SVGToImageLibNode,
+    GradientLibNode,
+    TransformLibNode,
+    ClipPathLibNode
+];
+//# sourceMappingURL=lib-svg.js.map