@dannote/figma-use 0.1.0

package/packages/plugin/dist/main.js

@@ -0,0 +1,996 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __async = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+
+  // src/main.ts
+  console.log("[Figma Bridge] Plugin main loaded at", (/* @__PURE__ */ new Date()).toISOString());
+  figma.showUI(__html__, { width: 300, height: 200 });
+  figma.ui.onmessage = (msg) => __async(null, null, function* () {
+    if (msg.type !== "command") return;
+    try {
+      yield figma.loadAllPagesAsync();
+      const result = yield handleCommand(msg.command, msg.args);
+      figma.ui.postMessage({ type: "result", id: msg.id, result });
+    } catch (error) {
+      figma.ui.postMessage({ type: "result", id: msg.id, error: String(error) });
+    }
+  });
+  function handleCommand(command, args) {
+    return __async(this, null, function* () {
+      switch (command) {
+        // ==================== READ ====================
+        case "get-selection":
+          return figma.currentPage.selection.map(serializeNode);
+        case "get-node-info": {
+          const { id } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          return node ? serializeNode(node) : null;
+        }
+        case "get-all-components": {
+          const components = [];
+          figma.root.findAll((node) => {
+            if (node.type === "COMPONENT" || node.type === "COMPONENT_SET") {
+              components.push(serializeNode(node));
+            }
+            return false;
+          });
+          return components;
+        }
+        case "get-pages":
+          return figma.root.children.map((page) => ({ id: page.id, name: page.name }));
+        case "create-page": {
+          const { name } = args;
+          const page = figma.createPage();
+          page.name = name;
+          return { id: page.id, name: page.name };
+        }
+        case "set-current-page": {
+          const { id } = args;
+          const page = yield figma.getNodeByIdAsync(id);
+          if (!page || page.type !== "PAGE") throw new Error("Page not found");
+          yield figma.setCurrentPageAsync(page);
+          return { id: page.id, name: page.name };
+        }
+        case "get-local-styles": {
+          const { type } = args || {};
+          const result = {};
+          if (!type || type === "all" || type === "paint") {
+            const styles = yield figma.getLocalPaintStylesAsync();
+            if (styles.length > 0) {
+              result.paintStyles = styles.map((s) => ({
+                id: s.id,
+                name: s.name,
+                paints: s.paints.map(serializePaint)
+              }));
+            }
+          }
+          if (!type || type === "all" || type === "text") {
+            const styles = yield figma.getLocalTextStylesAsync();
+            if (styles.length > 0) {
+              result.textStyles = styles.map((s) => ({
+                id: s.id,
+                name: s.name,
+                fontSize: s.fontSize,
+                fontFamily: s.fontName.family,
+                fontStyle: s.fontName.style
+              }));
+            }
+          }
+          if (!type || type === "all" || type === "effect") {
+            const styles = yield figma.getLocalEffectStylesAsync();
+            if (styles.length > 0) {
+              result.effectStyles = styles.map((s) => ({
+                id: s.id,
+                name: s.name,
+                effects: s.effects.map((e) => ({ type: e.type, radius: e.radius }))
+              }));
+            }
+          }
+          if (!type || type === "all" || type === "grid") {
+            const styles = yield figma.getLocalGridStylesAsync();
+            if (styles.length > 0) {
+              result.gridStyles = styles.map((s) => ({
+                id: s.id,
+                name: s.name,
+                grids: s.layoutGrids.length
+              }));
+            }
+          }
+          return result;
+        }
+        case "get-viewport":
+          return {
+            center: figma.viewport.center,
+            zoom: figma.viewport.zoom,
+            bounds: figma.viewport.bounds
+          };
+        // ==================== CREATE SHAPES ====================
+        case "create-rectangle": {
+          const { x, y, width, height, name, parentId, fill, stroke, strokeWeight, radius, opacity } = args;
+          const rect = figma.createRectangle();
+          rect.x = x;
+          rect.y = y;
+          rect.resize(width, height);
+          if (name) rect.name = name;
+          if (fill) rect.fills = [{ type: "SOLID", color: hexToRgb(fill) }];
+          if (stroke) rect.strokes = [{ type: "SOLID", color: hexToRgb(stroke) }];
+          if (strokeWeight !== void 0) rect.strokeWeight = strokeWeight;
+          if (radius !== void 0) rect.cornerRadius = radius;
+          if (opacity !== void 0) rect.opacity = opacity;
+          yield appendToParent(rect, parentId);
+          return serializeNode(rect);
+        }
+        case "create-ellipse": {
+          const { x, y, width, height, name, parentId, fill, stroke, strokeWeight, opacity } = args;
+          const ellipse = figma.createEllipse();
+          ellipse.x = x;
+          ellipse.y = y;
+          ellipse.resize(width, height);
+          if (name) ellipse.name = name;
+          if (fill) ellipse.fills = [{ type: "SOLID", color: hexToRgb(fill) }];
+          if (stroke) ellipse.strokes = [{ type: "SOLID", color: hexToRgb(stroke) }];
+          if (strokeWeight !== void 0) ellipse.strokeWeight = strokeWeight;
+          if (opacity !== void 0) ellipse.opacity = opacity;
+          yield appendToParent(ellipse, parentId);
+          return serializeNode(ellipse);
+        }
+        case "create-line": {
+          const { x, y, length, rotation, name, parentId } = args;
+          const line = figma.createLine();
+          line.x = x;
+          line.y = y;
+          line.resize(length, 0);
+          if (rotation) line.rotation = rotation;
+          if (name) line.name = name;
+          yield appendToParent(line, parentId);
+          return serializeNode(line);
+        }
+        case "create-polygon": {
+          const { x, y, size, sides, name, parentId } = args;
+          const polygon = figma.createPolygon();
+          polygon.x = x;
+          polygon.y = y;
+          polygon.resize(size, size);
+          if (sides) polygon.pointCount = sides;
+          if (name) polygon.name = name;
+          yield appendToParent(polygon, parentId);
+          return serializeNode(polygon);
+        }
+        case "create-star": {
+          const { x, y, size, points, innerRadius, name, parentId } = args;
+          const star = figma.createStar();
+          star.x = x;
+          star.y = y;
+          star.resize(size, size);
+          if (points) star.pointCount = points;
+          if (innerRadius !== void 0) star.innerRadius = innerRadius;
+          if (name) star.name = name;
+          yield appendToParent(star, parentId);
+          return serializeNode(star);
+        }
+        case "create-vector": {
+          const { x, y, path, name, parentId } = args;
+          const frame = figma.createNodeFromSvg(`<svg><path d="${path}"/></svg>`);
+          frame.x = x;
+          frame.y = y;
+          if (name) frame.name = name;
+          yield appendToParent(frame, parentId);
+          return serializeNode(frame);
+        }
+        // ==================== CREATE CONTAINERS ====================
+        case "create-frame": {
+          const { x, y, width, height, name, parentId, fill, stroke, strokeWeight, radius, opacity, layoutMode, itemSpacing, padding } = args;
+          const frame = figma.createFrame();
+          frame.x = x;
+          frame.y = y;
+          frame.resize(width, height);
+          if (name) frame.name = name;
+          if (fill) frame.fills = [{ type: "SOLID", color: hexToRgb(fill) }];
+          if (stroke) frame.strokes = [{ type: "SOLID", color: hexToRgb(stroke) }];
+          if (strokeWeight !== void 0) frame.strokeWeight = strokeWeight;
+          if (radius !== void 0) frame.cornerRadius = radius;
+          if (opacity !== void 0) frame.opacity = opacity;
+          if (layoutMode && layoutMode !== "NONE") {
+            frame.layoutMode = layoutMode;
+            if (itemSpacing !== void 0) frame.itemSpacing = itemSpacing;
+            if (padding) {
+              frame.paddingTop = padding.top;
+              frame.paddingRight = padding.right;
+              frame.paddingBottom = padding.bottom;
+              frame.paddingLeft = padding.left;
+            }
+          }
+          yield appendToParent(frame, parentId);
+          return serializeNode(frame);
+        }
+        case "create-section": {
+          const { x, y, width, height, name } = args;
+          const section = figma.createSection();
+          section.x = x;
+          section.y = y;
+          section.resizeWithoutConstraints(width, height);
+          if (name) section.name = name;
+          return serializeNode(section);
+        }
+        case "create-slice": {
+          const { x, y, width, height, name } = args;
+          const slice = figma.createSlice();
+          slice.x = x;
+          slice.y = y;
+          slice.resize(width, height);
+          if (name) slice.name = name;
+          return serializeNode(slice);
+        }
+        // ==================== CREATE OTHER ====================
+        case "create-text": {
+          const { x, y, text, fontSize, fontFamily, fontStyle, fill, opacity, name, parentId } = args;
+          const textNode = figma.createText();
+          const family = fontFamily || "Inter";
+          const style = fontStyle || "Regular";
+          yield figma.loadFontAsync({ family, style });
+          textNode.x = x;
+          textNode.y = y;
+          textNode.fontName = { family, style };
+          textNode.characters = text;
+          if (fontSize) textNode.fontSize = fontSize;
+          if (fill) textNode.fills = [{ type: "SOLID", color: hexToRgb(fill) }];
+          if (opacity !== void 0) textNode.opacity = opacity;
+          if (name) textNode.name = name;
+          yield appendToParent(textNode, parentId);
+          return serializeNode(textNode);
+        }
+        case "create-instance": {
+          const { componentId, x, y, name, parentId } = args;
+          const component = yield figma.getNodeByIdAsync(componentId);
+          if (!component || component.type !== "COMPONENT") throw new Error("Component not found");
+          const instance = component.createInstance();
+          if (x !== void 0) instance.x = x;
+          if (y !== void 0) instance.y = y;
+          if (name) instance.name = name;
+          yield appendToParent(instance, parentId);
+          return serializeNode(instance);
+        }
+        case "create-component": {
+          const { name, parentId } = args;
+          const component = figma.createComponent();
+          component.name = name;
+          yield appendToParent(component, parentId);
+          return serializeNode(component);
+        }
+        case "clone-node": {
+          const { id } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("clone" in node)) throw new Error("Node not found");
+          const clone = node.clone();
+          return serializeNode(clone);
+        }
+        // ==================== CREATE STYLES ====================
+        case "create-paint-style": {
+          const { name, color } = args;
+          const style = figma.createPaintStyle();
+          style.name = name;
+          style.paints = [{ type: "SOLID", color: hexToRgb(color) }];
+          return { id: style.id, name: style.name, key: style.key };
+        }
+        case "create-text-style": {
+          const { name, fontFamily, fontStyle, fontSize } = args;
+          const style = figma.createTextStyle();
+          style.name = name;
+          yield figma.loadFontAsync({ family: fontFamily || "Inter", style: fontStyle || "Regular" });
+          style.fontName = { family: fontFamily || "Inter", style: fontStyle || "Regular" };
+          if (fontSize) style.fontSize = fontSize;
+          return { id: style.id, name: style.name, key: style.key };
+        }
+        case "create-effect-style": {
+          const { name, type, radius, color, offsetX, offsetY } = args;
+          const style = figma.createEffectStyle();
+          style.name = name;
+          const rgba = color ? hexToRgba(color) : { r: 0, g: 0, b: 0, a: 0.25 };
+          if (type === "DROP_SHADOW" || type === "INNER_SHADOW") {
+            style.effects = [{
+              type,
+              color: rgba,
+              offset: { x: offsetX || 0, y: offsetY || 4 },
+              radius: radius || 10,
+              spread: 0,
+              visible: true,
+              blendMode: "NORMAL"
+            }];
+          } else if (type === "BLUR" || type === "BACKGROUND_BLUR") {
+            style.effects = [{
+              type,
+              radius: radius || 10,
+              visible: true
+            }];
+          }
+          return { id: style.id, name: style.name, key: style.key };
+        }
+        // ==================== UPDATE POSITION/SIZE ====================
+        case "move-node": {
+          const { id, x, y } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          node.x = x;
+          node.y = y;
+          return serializeNode(node);
+        }
+        case "resize-node": {
+          const { id, width, height } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("resize" in node)) throw new Error("Node not found");
+          node.resize(width, height);
+          return serializeNode(node);
+        }
+        // ==================== UPDATE APPEARANCE ====================
+        case "set-fill-color": {
+          const { id, color } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("fills" in node)) throw new Error("Node not found");
+          node.fills = [{ type: "SOLID", color: hexToRgb(color) }];
+          return serializeNode(node);
+        }
+        case "set-stroke-color": {
+          const { id, color } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("strokes" in node)) throw new Error("Node not found");
+          node.strokes = [{ type: "SOLID", color: hexToRgb(color) }];
+          return serializeNode(node);
+        }
+        case "set-corner-radius": {
+          const { id, cornerRadius, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("cornerRadius" in node)) throw new Error("Node not found");
+          node.cornerRadius = cornerRadius;
+          if (topLeftRadius !== void 0) node.topLeftRadius = topLeftRadius;
+          if (topRightRadius !== void 0) node.topRightRadius = topRightRadius;
+          if (bottomLeftRadius !== void 0) node.bottomLeftRadius = bottomLeftRadius;
+          if (bottomRightRadius !== void 0) node.bottomRightRadius = bottomRightRadius;
+          return serializeNode(node);
+        }
+        case "set-opacity": {
+          const { id, opacity } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("opacity" in node)) throw new Error("Node not found");
+          node.opacity = opacity;
+          return serializeNode(node);
+        }
+        case "set-image-fill": {
+          const { id, url, scaleMode } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("fills" in node)) throw new Error("Node not found");
+          const image = yield figma.createImageAsync(url);
+          node.fills = [{
+            type: "IMAGE",
+            imageHash: image.hash,
+            scaleMode: scaleMode || "FILL"
+          }];
+          return serializeNode(node);
+        }
+        // ==================== UPDATE PROPERTIES ====================
+        case "rename-node": {
+          const { id, name } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          node.name = name;
+          return serializeNode(node);
+        }
+        case "set-visible": {
+          const { id, visible } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          node.visible = visible;
+          return serializeNode(node);
+        }
+        case "set-locked": {
+          const { id, locked } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          node.locked = locked;
+          return serializeNode(node);
+        }
+        case "set-effect": {
+          const { id, type, color, offsetX, offsetY, radius, spread } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("effects" in node)) throw new Error("Node not found");
+          const rgba = color ? hexToRgba(color) : { r: 0, g: 0, b: 0, a: 0.25 };
+          if (type === "DROP_SHADOW" || type === "INNER_SHADOW") {
+            node.effects = [{
+              type,
+              color: rgba,
+              offset: { x: offsetX != null ? offsetX : 0, y: offsetY != null ? offsetY : 4 },
+              radius: radius != null ? radius : 8,
+              spread: spread != null ? spread : 0,
+              visible: true,
+              blendMode: "NORMAL"
+            }];
+          } else if (type === "BLUR") {
+            node.effects = [{
+              type: "LAYER_BLUR",
+              radius: radius != null ? radius : 8,
+              visible: true
+            }];
+          }
+          return serializeNode(node);
+        }
+        case "set-text": {
+          const { id, text } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || node.type !== "TEXT") throw new Error("Text node not found");
+          const fontName = node.fontName;
+          yield figma.loadFontAsync(fontName);
+          node.characters = text;
+          return serializeNode(node);
+        }
+        case "import-svg": {
+          const { svg, x, y, name, parentId } = args;
+          const node = figma.createNodeFromSvg(svg);
+          if (x !== void 0) node.x = x;
+          if (y !== void 0) node.y = y;
+          if (name) node.name = name;
+          yield appendToParent(node, parentId);
+          return serializeNode(node);
+        }
+        case "set-font": {
+          const { id, fontFamily, fontStyle, fontSize } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || node.type !== "TEXT") throw new Error("Text node not found");
+          const currentFont = node.fontName;
+          const family = fontFamily || currentFont.family;
+          const style = fontStyle || currentFont.style;
+          yield figma.loadFontAsync({ family, style });
+          node.fontName = { family, style };
+          if (fontSize !== void 0) node.fontSize = fontSize;
+          return serializeNode(node);
+        }
+        case "get-children": {
+          const { id, depth } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          if (!("children" in node)) return [];
+          const maxDepth = depth || 1;
+          const serializeWithDepth = (n, d) => {
+            const base = serializeNode(n);
+            if (d < maxDepth && "children" in n) {
+              base.children = n.children.map((c) => serializeWithDepth(c, d + 1));
+            }
+            return base;
+          };
+          return node.children.map((c) => serializeWithDepth(c, 1));
+        }
+        case "find-by-name": {
+          const { name, type, exact } = args;
+          const results = [];
+          figma.currentPage.findAll((n) => {
+            const nameMatch = exact ? n.name === name : n.name.toLowerCase().includes(name.toLowerCase());
+            const typeMatch = !type || n.type === type;
+            if (nameMatch && typeMatch) results.push(serializeNode(n));
+            return false;
+          });
+          return results;
+        }
+        case "select-nodes": {
+          const { ids } = args;
+          const nodes = yield Promise.all(ids.map((id) => figma.getNodeByIdAsync(id)));
+          const validNodes = nodes.filter((n) => n !== null && "id" in n);
+          figma.currentPage.selection = validNodes;
+          return { selected: validNodes.length };
+        }
+        case "set-constraints": {
+          const { id, horizontal, vertical } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("constraints" in node)) throw new Error("Node not found");
+          node.constraints = {
+            horizontal: horizontal || node.constraints.horizontal,
+            vertical: vertical || node.constraints.vertical
+          };
+          return serializeNode(node);
+        }
+        case "set-blend-mode": {
+          const { id, mode } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("blendMode" in node)) throw new Error("Node not found");
+          node.blendMode = mode;
+          return serializeNode(node);
+        }
+        case "set-auto-layout": {
+          const { id, mode, wrap, itemSpacing, counterSpacing, padding, primaryAlign, counterAlign, sizingH, sizingV } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("layoutMode" in node)) throw new Error("Frame not found");
+          if (mode) node.layoutMode = mode;
+          if (wrap !== void 0) node.layoutWrap = wrap ? "WRAP" : "NO_WRAP";
+          if (itemSpacing !== void 0) node.itemSpacing = itemSpacing;
+          if (counterSpacing !== void 0) node.counterAxisSpacing = counterSpacing;
+          if (padding) {
+            node.paddingTop = padding.top;
+            node.paddingRight = padding.right;
+            node.paddingBottom = padding.bottom;
+            node.paddingLeft = padding.left;
+          }
+          if (primaryAlign) node.primaryAxisAlignItems = primaryAlign;
+          if (counterAlign) node.counterAxisAlignItems = counterAlign;
+          if (sizingH) node.layoutSizingHorizontal = sizingH;
+          if (sizingV) node.layoutSizingVertical = sizingV;
+          return serializeNode(node);
+        }
+        case "set-layout-child": {
+          const { id, horizontalSizing, verticalSizing, positioning, x, y } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          if (horizontalSizing && "layoutSizingHorizontal" in node) {
+            node.layoutSizingHorizontal = horizontalSizing;
+          }
+          if (verticalSizing && "layoutSizingVertical" in node) {
+            node.layoutSizingVertical = verticalSizing;
+          }
+          if (positioning && "layoutPositioning" in node) {
+            node.layoutPositioning = positioning;
+          }
+          if (positioning === "ABSOLUTE") {
+            if (x !== void 0) node.x = x;
+            if (y !== void 0) node.y = y;
+          }
+          return serializeNode(node);
+        }
+        case "set-text-properties": {
+          const { id, lineHeight, letterSpacing, textAlign, verticalAlign, autoResize, maxLines, paragraphSpacing, paragraphIndent } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || node.type !== "TEXT") throw new Error("Text node not found");
+          const fontName = node.fontName;
+          yield figma.loadFontAsync(fontName);
+          if (lineHeight !== void 0) {
+            node.lineHeight = lineHeight === "auto" ? { unit: "AUTO" } : { unit: "PIXELS", value: lineHeight };
+          }
+          if (letterSpacing !== void 0) {
+            node.letterSpacing = { unit: "PIXELS", value: letterSpacing };
+          }
+          if (textAlign) node.textAlignHorizontal = textAlign;
+          if (verticalAlign) node.textAlignVertical = verticalAlign;
+          if (autoResize) node.textAutoResize = autoResize;
+          if (maxLines !== void 0) node.maxLines = maxLines;
+          if (paragraphSpacing !== void 0) node.paragraphSpacing = paragraphSpacing;
+          if (paragraphIndent !== void 0) node.paragraphIndent = paragraphIndent;
+          return serializeNode(node);
+        }
+        case "set-min-max": {
+          const { id, minWidth, maxWidth, minHeight, maxHeight } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          if (minWidth !== void 0 && "minWidth" in node) node.minWidth = minWidth;
+          if (maxWidth !== void 0 && "maxWidth" in node) node.maxWidth = maxWidth;
+          if (minHeight !== void 0 && "minHeight" in node) node.minHeight = minHeight;
+          if (maxHeight !== void 0 && "maxHeight" in node) node.maxHeight = maxHeight;
+          return serializeNode(node);
+        }
+        case "set-rotation": {
+          const { id, angle } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          node.rotation = angle;
+          return serializeNode(node);
+        }
+        case "set-stroke-align": {
+          const { id, align } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("strokeAlign" in node)) throw new Error("Node not found");
+          node.strokeAlign = align;
+          return serializeNode(node);
+        }
+        // ==================== UPDATE STRUCTURE ====================
+        case "set-layout": {
+          const {
+            id,
+            mode,
+            wrap,
+            clip,
+            itemSpacing,
+            primaryAxisAlignItems,
+            counterAxisAlignItems,
+            paddingLeft,
+            paddingRight,
+            paddingTop,
+            paddingBottom,
+            layoutSizingVertical,
+            layoutSizingHorizontal
+          } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("layoutMode" in node)) throw new Error("Node not found");
+          node.layoutMode = mode;
+          if (wrap !== void 0) node.layoutWrap = wrap ? "WRAP" : "NO_WRAP";
+          if (clip !== void 0) node.clipsContent = clip;
+          if (itemSpacing !== void 0) node.itemSpacing = itemSpacing;
+          if (primaryAxisAlignItems) node.primaryAxisAlignItems = primaryAxisAlignItems;
+          if (counterAxisAlignItems) node.counterAxisAlignItems = counterAxisAlignItems;
+          if (paddingLeft !== void 0) node.paddingLeft = paddingLeft;
+          if (paddingRight !== void 0) node.paddingRight = paddingRight;
+          if (paddingTop !== void 0) node.paddingTop = paddingTop;
+          if (paddingBottom !== void 0) node.paddingBottom = paddingBottom;
+          if (layoutSizingVertical) node.layoutSizingVertical = layoutSizingVertical;
+          if (layoutSizingHorizontal) node.layoutSizingHorizontal = layoutSizingHorizontal;
+          return serializeNode(node);
+        }
+        case "set-parent-id": {
+          const { id, parentId } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          const parent = yield figma.getNodeByIdAsync(parentId);
+          if (!node || !parent) throw new Error("Node or parent not found");
+          parent.appendChild(node);
+          return serializeNode(node);
+        }
+        case "group-nodes": {
+          const { ids, name } = args;
+          const nodes = yield Promise.all(ids.map((id) => figma.getNodeByIdAsync(id)));
+          const validNodes = nodes.filter((n) => n !== null && "parent" in n);
+          if (validNodes.length === 0) throw new Error("No valid nodes found");
+          const parent = validNodes[0].parent;
+          if (!parent || !("children" in parent)) throw new Error("Invalid parent");
+          const group = figma.group(validNodes, parent);
+          if (name) group.name = name;
+          return serializeNode(group);
+        }
+        case "ungroup-node": {
+          const { id } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || node.type !== "GROUP") throw new Error("Not a group node");
+          const children = figma.ungroup(node);
+          return children.map(serializeNode);
+        }
+        case "flatten-nodes": {
+          const { ids } = args;
+          const nodes = yield Promise.all(ids.map((id) => figma.getNodeByIdAsync(id)));
+          const validNodes = nodes.filter((n) => n !== null && "parent" in n);
+          if (validNodes.length === 0) throw new Error("No valid nodes found");
+          const vector = figma.flatten(validNodes);
+          return serializeNode(vector);
+        }
+        // ==================== BOOLEAN OPERATIONS ====================
+        case "boolean-operation": {
+          const { ids, operation } = args;
+          const nodes = yield Promise.all(ids.map((id) => figma.getNodeByIdAsync(id)));
+          const validNodes = nodes.filter((n) => n !== null && "parent" in n);
+          if (validNodes.length < 2) throw new Error("Need at least 2 nodes");
+          const parent = validNodes[0].parent;
+          if (!parent || !("children" in parent)) throw new Error("Invalid parent");
+          let result;
+          switch (operation) {
+            case "UNION":
+              result = figma.union(validNodes, parent);
+              break;
+            case "SUBTRACT":
+              result = figma.subtract(validNodes, parent);
+              break;
+            case "INTERSECT":
+              result = figma.intersect(validNodes, parent);
+              break;
+            case "EXCLUDE":
+              result = figma.exclude(validNodes, parent);
+              break;
+          }
+          return serializeNode(result);
+        }
+        // ==================== INSTANCE/COMPONENT ====================
+        case "set-instance-properties": {
+          const { instanceId, properties } = args;
+          const instance = yield figma.getNodeByIdAsync(instanceId);
+          if (!instance || instance.type !== "INSTANCE") throw new Error("Instance not found");
+          instance.setProperties(properties);
+          return serializeNode(instance);
+        }
+        case "set-node-component-property-references": {
+          const { id, componentPropertyReferences } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("componentPropertyReferences" in node)) throw new Error("Node not found");
+          for (const [key, value] of Object.entries(componentPropertyReferences)) {
+            node.componentPropertyReferences = __spreadProps(__spreadValues({}, node.componentPropertyReferences), { [key]: value });
+          }
+          return serializeNode(node);
+        }
+        case "add-component-property": {
+          const { componentId, name, type, defaultValue } = args;
+          const component = yield figma.getNodeByIdAsync(componentId);
+          if (!component || component.type !== "COMPONENT" && component.type !== "COMPONENT_SET") {
+            throw new Error("Component not found");
+          }
+          let parsedDefault = defaultValue;
+          if (type === "BOOLEAN") parsedDefault = defaultValue === "true" || defaultValue === true;
+          component.addComponentProperty(name, type, parsedDefault);
+          return serializeNode(component);
+        }
+        case "edit-component-property": {
+          const { componentId, name, defaultValue, preferredValues } = args;
+          const component = yield figma.getNodeByIdAsync(componentId);
+          if (!component || component.type !== "COMPONENT" && component.type !== "COMPONENT_SET") {
+            throw new Error("Component not found");
+          }
+          const props = component.componentPropertyDefinitions;
+          const propKey = Object.keys(props).find((k) => k === name || k.startsWith(name + "#"));
+          if (!propKey) throw new Error("Property not found");
+          const propDef = props[propKey];
+          let parsedDefault = defaultValue;
+          if (propDef.type === "BOOLEAN") parsedDefault = defaultValue === "true" || defaultValue === true;
+          component.editComponentProperty(propKey, {
+            name,
+            defaultValue: parsedDefault,
+            preferredValues: preferredValues == null ? void 0 : preferredValues.map((v) => ({ type: "COMPONENT", key: v }))
+          });
+          return serializeNode(component);
+        }
+        case "delete-component-property": {
+          const { componentId, name } = args;
+          const component = yield figma.getNodeByIdAsync(componentId);
+          if (!component || component.type !== "COMPONENT" && component.type !== "COMPONENT_SET") {
+            throw new Error("Component not found");
+          }
+          const props = component.componentPropertyDefinitions;
+          const propKey = Object.keys(props).find((k) => k === name || k.startsWith(name + "#"));
+          if (!propKey) throw new Error("Property not found");
+          component.deleteComponentProperty(propKey);
+          return serializeNode(component);
+        }
+        // ==================== VIEWPORT ====================
+        case "set-viewport": {
+          const { x, y, zoom } = args;
+          if (x !== void 0 && y !== void 0) {
+            figma.viewport.center = { x, y };
+          }
+          if (zoom !== void 0) {
+            figma.viewport.zoom = zoom;
+          }
+          return { center: figma.viewport.center, zoom: figma.viewport.zoom };
+        }
+        case "zoom-to-fit": {
+          const { ids } = args;
+          let nodes;
+          if (ids && ids.length > 0) {
+            const fetched = yield Promise.all(ids.map((id) => figma.getNodeByIdAsync(id)));
+            nodes = fetched.filter((n) => n !== null && "absoluteBoundingBox" in n);
+          } else {
+            nodes = figma.currentPage.selection;
+          }
+          if (nodes.length > 0) {
+            figma.viewport.scrollAndZoomIntoView(nodes);
+          }
+          return { center: figma.viewport.center, zoom: figma.viewport.zoom };
+        }
+        // ==================== EXPORT ====================
+        case "export-node": {
+          const { id, format, scale } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          const bytes = yield node.exportAsync(__spreadValues({
+            format
+          }, format !== "SVG" && format !== "PDF" ? { scale: scale || 1 } : {}));
+          return {
+            data: figma.base64Encode(bytes),
+            filename: `${node.name}.${format.toLowerCase()}`
+          };
+        }
+        case "screenshot": {
+          const { scale } = args;
+          const bounds = figma.viewport.bounds;
+          const frame = figma.createFrame();
+          frame.name = "__screenshot_temp__";
+          frame.x = bounds.x;
+          frame.y = bounds.y;
+          frame.resize(bounds.width, bounds.height);
+          frame.fills = [];
+          frame.clipsContent = true;
+          for (const node of figma.currentPage.children) {
+            if (node.id === frame.id) continue;
+            if (!node.visible) continue;
+            if ("absoluteBoundingBox" in node && node.absoluteBoundingBox) {
+              const nb = node.absoluteBoundingBox;
+              if (nb.x + nb.width > bounds.x && nb.x < bounds.x + bounds.width && nb.y + nb.height > bounds.y && nb.y < bounds.y + bounds.height) {
+                const clone = node.clone();
+                clone.x = node.x - bounds.x;
+                clone.y = node.y - bounds.y;
+                frame.appendChild(clone);
+              }
+            }
+          }
+          const bytes = yield frame.exportAsync({ format: "PNG", scale: scale || 1 });
+          frame.remove();
+          return { data: figma.base64Encode(bytes) };
+        }
+        case "export-selection": {
+          const { format, scale, padding } = args;
+          const selection = figma.currentPage.selection;
+          if (selection.length === 0) throw new Error("No selection");
+          if (selection.length === 1 && !padding) {
+            const bytes2 = yield selection[0].exportAsync(__spreadValues({
+              format: format || "PNG"
+            }, format !== "SVG" && format !== "PDF" ? { scale: scale || 2 } : {}));
+            return { data: figma.base64Encode(bytes2) };
+          }
+          let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+          for (const node of selection) {
+            if ("absoluteBoundingBox" in node && node.absoluteBoundingBox) {
+              const b = node.absoluteBoundingBox;
+              minX = Math.min(minX, b.x);
+              minY = Math.min(minY, b.y);
+              maxX = Math.max(maxX, b.x + b.width);
+              maxY = Math.max(maxY, b.y + b.height);
+            }
+          }
+          const pad = padding || 0;
+          const frame = figma.createFrame();
+          frame.name = "__export_temp__";
+          frame.x = minX - pad;
+          frame.y = minY - pad;
+          frame.resize(maxX - minX + pad * 2, maxY - minY + pad * 2);
+          frame.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
+          frame.clipsContent = true;
+          for (const node of selection) {
+            const clone = node.clone();
+            clone.x = node.x - frame.x;
+            clone.y = node.y - frame.y;
+            frame.appendChild(clone);
+          }
+          const bytes = yield frame.exportAsync(__spreadValues({
+            format: format || "PNG"
+          }, format !== "SVG" && format !== "PDF" ? { scale: scale || 2 } : {}));
+          frame.remove();
+          return { data: figma.base64Encode(bytes) };
+        }
+        // ==================== DELETE ====================
+        case "delete-node": {
+          const { id } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node || !("remove" in node)) throw new Error("Node not found");
+          node.remove();
+          return { deleted: true };
+        }
+        default:
+          throw new Error(`Unknown command: ${command}`);
+      }
+    });
+  }
+  function appendToParent(node, parentId) {
+    return __async(this, null, function* () {
+      if (parentId) {
+        const parent = yield figma.getNodeByIdAsync(parentId);
+        if (parent && "appendChild" in parent) {
+          parent.appendChild(node);
+          return;
+        }
+      }
+      figma.currentPage.appendChild(node);
+    });
+  }
+  function serializeNode(node) {
+    const base = {
+      id: node.id,
+      name: node.name,
+      type: node.type
+    };
+    if ("x" in node) base.x = Math.round(node.x);
+    if ("y" in node) base.y = Math.round(node.y);
+    if ("width" in node) base.width = Math.round(node.width);
+    if ("height" in node) base.height = Math.round(node.height);
+    if ("opacity" in node && node.opacity !== 1) base.opacity = node.opacity;
+    if ("visible" in node && !node.visible) base.visible = false;
+    if ("locked" in node && node.locked) base.locked = true;
+    if ("fills" in node && Array.isArray(node.fills) && node.fills.length > 0) {
+      base.fills = node.fills.map(serializePaint);
+    }
+    if ("strokes" in node && Array.isArray(node.strokes) && node.strokes.length > 0) {
+      base.strokes = node.strokes.map(serializePaint);
+    }
+    if ("strokeWeight" in node && typeof node.strokeWeight === "number" && node.strokeWeight > 0) {
+      base.strokeWeight = node.strokeWeight;
+    }
+    if ("componentPropertyDefinitions" in node) {
+      base.componentPropertyDefinitions = node.componentPropertyDefinitions;
+    }
+    if ("componentProperties" in node) {
+      base.componentProperties = node.componentProperties;
+    }
+    if ("layoutMode" in node && node.layoutMode !== "NONE") {
+      base.layoutMode = node.layoutMode;
+      if ("itemSpacing" in node) base.itemSpacing = node.itemSpacing;
+      if ("paddingLeft" in node && (node.paddingLeft || node.paddingRight || node.paddingTop || node.paddingBottom)) {
+        base.padding = { left: node.paddingLeft, right: node.paddingRight, top: node.paddingTop, bottom: node.paddingBottom };
+      }
+    }
+    if (node.type === "TEXT") {
+      const textNode = node;
+      base.characters = textNode.characters;
+      if (typeof textNode.fontSize === "number") base.fontSize = textNode.fontSize;
+    }
+    if ("children" in node) {
+      base.childCount = node.children.length;
+    }
+    return base;
+  }
+  function serializePaint(paint) {
+    if (paint.type === "SOLID") {
+      const result = {
+        type: "SOLID",
+        color: rgbToHex(paint.color)
+      };
+      if (paint.opacity !== void 0 && paint.opacity !== 1) result.opacity = paint.opacity;
+      return result;
+    }
+    if (paint.type === "IMAGE") {
+      return { type: "IMAGE", imageHash: paint.imageHash, scaleMode: paint.scaleMode };
+    }
+    if (paint.type === "GRADIENT_LINEAR" || paint.type === "GRADIENT_RADIAL" || paint.type === "GRADIENT_ANGULAR" || paint.type === "GRADIENT_DIAMOND") {
+      return {
+        type: paint.type,
+        stops: paint.gradientStops.map((s) => ({ color: rgbToHex(s.color), position: s.position }))
+      };
+    }
+    return { type: paint.type };
+  }
+  function rgbToHex(color) {
+    const r = Math.round(color.r * 255).toString(16).padStart(2, "0");
+    const g = Math.round(color.g * 255).toString(16).padStart(2, "0");
+    const b = Math.round(color.b * 255).toString(16).padStart(2, "0");
+    return `#${r}${g}${b}`.toUpperCase();
+  }
+  function expandHex(hex) {
+    const clean = hex.replace("#", "");
+    if (clean.length === 3) {
+      return clean[0] + clean[0] + clean[1] + clean[1] + clean[2] + clean[2];
+    }
+    if (clean.length === 4) {
+      return clean[0] + clean[0] + clean[1] + clean[1] + clean[2] + clean[2] + clean[3] + clean[3];
+    }
+    return clean;
+  }
+  function hexToRgb(hex) {
+    const clean = expandHex(hex);
+    return {
+      r: parseInt(clean.slice(0, 2), 16) / 255,
+      g: parseInt(clean.slice(2, 4), 16) / 255,
+      b: parseInt(clean.slice(4, 6), 16) / 255
+    };
+  }
+  function hexToRgba(hex) {
+    const clean = expandHex(hex);
+    const hasAlpha = clean.length === 8;
+    return {
+      r: parseInt(clean.slice(0, 2), 16) / 255,
+      g: parseInt(clean.slice(2, 4), 16) / 255,
+      b: parseInt(clean.slice(4, 6), 16) / 255,
+      a: hasAlpha ? parseInt(clean.slice(6, 8), 16) / 255 : 1
+    };
+  }
+})();