@wz927/codedesign 0.2.16 → 0.2.18

package/figma-plugin/dist/code.js

@@ -144,7 +144,7 @@ async function loadFontFor(props) {
 }
 // ─── Ops ─────────────────────────────────────────────────────────────────
 async function handle(req) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const p = (_a = req.params) !== null && _a !== void 0 ? _a : {};
     switch (req.op) {
         case 'getCurrentPage':
@@ -248,12 +248,34 @@ async function handle(req) {
             if ('resize' in n && (typeof patch.width === 'number' || typeof patch.height === 'number')) {
                 n.resize((_d = patch.width) !== null && _d !== void 0 ? _d : n.width, (_e = patch.height) !== null && _e !== void 0 ? _e : n.height);
             }
-            for (const k of ['x', 'y', 'cornerRadius', 'opacity', 'rotation', 'visible', 'name', 'itemSpacing',
+            for (const k of ['x', 'y', 'opacity', 'rotation', 'visible', 'name', 'itemSpacing',
                 'paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom', 'strokeWeight', 'layoutMode',
                 'primaryAxisAlignItems', 'counterAxisAlignItems', 'clipsContent', 'textAlignHorizontal', 'fontSize']) {
                 if (patch[k] !== undefined)
                     n[k] = patch[k];
             }
+            // cornerRadius: number → uniform; [tl,tr,br,bl] → per-corner
+            if (patch.cornerRadius !== undefined) {
+                const cr = patch.cornerRadius;
+                if (typeof cr === 'number') {
+                    n.cornerRadius = cr;
+                }
+                else if (Array.isArray(cr) && cr.length === 4) {
+                    n.topLeftRadius = cr[0];
+                    n.topRightRadius = cr[1];
+                    n.bottomRightRadius = cr[2];
+                    n.bottomLeftRadius = cr[3];
+                }
+            }
+            // Also support explicit per-corner keys
+            if (patch.topLeftRadius !== undefined)
+                n.topLeftRadius = patch.topLeftRadius;
+            if (patch.topRightRadius !== undefined)
+                n.topRightRadius = patch.topRightRadius;
+            if (patch.bottomRightRadius !== undefined)
+                n.bottomRightRadius = patch.bottomRightRadius;
+            if (patch.bottomLeftRadius !== undefined)
+                n.bottomLeftRadius = patch.bottomLeftRadius;
             if (patch.fills)
                 n.fills = patch.fills.map(toPaint);
             if (patch.strokes)
@@ -321,7 +343,14 @@ async function handle(req) {
             }));
         case 'createInstance': {
             const all = figma.root.findAllWithCriteria({ types: ['COMPONENT'] });
-            const comp = all.find((c) => c.key === p.componentKey || c.id === p.componentKey);
+            let comp = all.find((c) => c.key === p.componentKey || c.id === p.componentKey);
+            // If not found locally, try to import from a team library by component key.
+            if (!comp && p.componentKey) {
+                try {
+                    comp = await figma.importComponentByKeyAsync(p.componentKey);
+                }
+                catch { /* not in library either; throw below */ }
+            }
             if (!comp)
                 throw new Error('Component not found: ' + p.componentKey);
             const inst = comp.createInstance();
@@ -330,8 +359,68 @@ async function handle(req) {
                 inst.x = p.x;
             if (typeof p.y === 'number')
                 inst.y = p.y;
+            if (typeof p.width === 'number' && typeof p.height === 'number')
+                inst.resize(p.width, p.height);
             return nodeSummary(inst);
         }
+        case 'createVector': {
+            // Draw an icon/shape using SVG path data.
+            // params: { parentId?, vectorPaths: [{windingRule, data}], fills, strokes, strokeWeight, x, y, width, height, name }
+            const vec = figma.createVector();
+            getParent(p.parentId).appendChild(vec);
+            if (p.vectorPaths)
+                vec.vectorPaths = p.vectorPaths;
+            if (p.fills)
+                vec.fills = p.fills.map(toPaint);
+            if (p.strokes)
+                vec.strokes = p.strokes.map(toPaint);
+            if (typeof p.strokeWeight === 'number')
+                vec.strokeWeight = p.strokeWeight;
+            if (typeof p.x === 'number')
+                vec.x = p.x;
+            if (typeof p.y === 'number')
+                vec.y = p.y;
+            if (typeof p.width === 'number' && typeof p.height === 'number')
+                vec.resize(p.width, p.height);
+            if (typeof p.name === 'string')
+                vec.name = p.name;
+            return nodeSummary(vec);
+        }
+        case 'createLine': {
+            // A simple line / divider.
+            // params: { parentId?, x, y, length, vertical?, strokeWeight, color:{r,g,b}, name }
+            const line = figma.createLine();
+            getParent(p.parentId).appendChild(line);
+            if (typeof p.x === 'number')
+                line.x = p.x;
+            if (typeof p.y === 'number')
+                line.y = p.y;
+            const len = (_g = p.length) !== null && _g !== void 0 ? _g : 100;
+            line.resize(p.vertical ? 0 : len, p.vertical ? len : 0);
+            if (p.color)
+                line.strokes = [{ type: 'SOLID', color: p.color, opacity: (_h = p.color.a) !== null && _h !== void 0 ? _h : 1 }];
+            if (typeof p.strokeWeight === 'number')
+                line.strokeWeight = p.strokeWeight;
+            if (typeof p.name === 'string')
+                line.name = p.name;
+            return nodeSummary(line);
+        }
+        case 'applyStyle': {
+            // Apply a local Figma style (paint/text/effect) to a node by style id.
+            // params: { id, fillStyleId?, strokeStyleId?, textStyleId?, effectStyleId? }
+            const n = figma.getNodeById(p.id);
+            if (!n)
+                throw new Error('Not found: ' + p.id);
+            if (p.fillStyleId !== undefined)
+                n.fillStyleId = p.fillStyleId;
+            if (p.strokeStyleId !== undefined)
+                n.strokeStyleId = p.strokeStyleId;
+            if (p.textStyleId !== undefined)
+                n.textStyleId = p.textStyleId;
+            if (p.effectStyleId !== undefined)
+                n.effectStyleId = p.effectStyleId;
+            return nodeSummary(n);
+        }
         case 'viewport': {
             const n = figma.getNodeById(p.id);
             if (!n)
@@ -345,10 +434,10 @@ async function handle(req) {
             const n = figma.getNodeById(p.id);
             if (!n || !('exportAsync' in n))
                 throw new Error('Node not exportable');
-            const format = ((_g = p.format) !== null && _g !== void 0 ? _g : 'PNG').toUpperCase();
+            const format = ((_j = p.format) !== null && _j !== void 0 ? _j : 'PNG').toUpperCase();
             const settings = { format };
             if (format === 'PNG' || format === 'JPG')
-                settings.constraint = { type: 'SCALE', value: (_h = p.scale) !== null && _h !== void 0 ? _h : 2 };
+                settings.constraint = { type: 'SCALE', value: (_k = p.scale) !== null && _k !== void 0 ? _k : 2 };
             const bytes = await n.exportAsync(settings);
             const b64 = figma.base64Encode(bytes);
             return { bytesBase64: b64, format };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wz927/codedesign",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Terminal AI agent for designers — drive Figma through natural-language conversation.",
   "type": "module",
   "bin": {