@rogieking/figui3 3.13.0 → 3.14.0

package/components.css

@@ -1204,10 +1204,8 @@ fig-chit {
     box-shadow: inset 0 0 0 1px var(--figma-color-border-selected);
   }
 
+  &[size="medium"],
   &[size="large"] {
-    --size: 1.75rem;
-
-    /* Large size: swatch fills the whole area */
     input[type="color"] {
       padding: 0;
       width: var(--size);
@@ -1233,7 +1231,6 @@ fig-chit {
         inset 0 0 0 3px var(--figma-color-bg);
     }
 
-    /* Large gradient/image: also fill the area */
     &[data-type="gradient"]::after,
     &[data-type="image"]::after,
     &[data-type="gradient"]::before,
@@ -1244,6 +1241,14 @@ fig-chit {
     }
   }
 
+  &[size="medium"] {
+    --size: 1.5rem;
+  }
+
+  &[size="large"] {
+    --size: 2rem;
+  }
+
   &[disabled] {
     pointer-events: none;
   }
@@ -3174,14 +3179,12 @@ fig-input-gradient {
   }
   fig-chit {
     flex: 1 1 auto;
-    width: 100%;
-    min-width: 0;
+    width: 100% !important;
+    min-width: 0 !important;
     &::before,
     &::after {
-      width: auto;
-      height: auto;
+      width: 100% !important;
       place-self: stretch;
-      border-radius: var(--radius-large) !important;
     }
     &[data-type="gradient"]::after {
       width: calc(100% - 0.625rem);
@@ -3193,12 +3196,24 @@ fig-input-gradient {
 
   .fig-input-gradient-track {
     position: absolute;
-    inset: calc(var(--spacer-1) + 2px) var(--spacer-2-5);
+    display: flex;
+    align-items: center;
+    inset: 0;
     pointer-events: auto;
 
     fig-handle {
       pointer-events: auto;
       cursor: default;
+
+      &.dragging {
+        fig-color-tip {
+          display: none;
+        }
+      }
+
+      &:hover {
+        z-index: 5;
+      }
     }
   }
 }
@@ -4244,12 +4259,6 @@ fig-preview {
   }
 
   .fig-fill-picker-color-area fig-handle {
-    --width: 1rem;
-    --height: 1rem;
-    --border-radius: 50%;
-    --box-shadow:
-      inset 0 0 0 0.125rem var(--handle-color),
-      0px 0 0 0.5px rgba(0, 0, 0, 0.1), var(--elevation-100-canvas);
     z-index: 1;
   }
 
@@ -4743,9 +4752,8 @@ fig-choice {
 }
 
 fig-handle {
-  contain: strict;
-  --width: 0.75rem;
-  --height: 0.75rem;
+  --width: 0.875rem;
+  --height: 0.875rem;
   --fill: var(--figma-color-bg-brand);
   --border-radius: 50%;
   --ring-width: 1.25px;
@@ -4755,15 +4763,27 @@ fig-handle {
   --outline: none;
   --border: none;
 
-  display: inline-block;
+  display: inline-grid;
+  place-items: center;
   width: var(--width);
   height: var(--height);
-  background: var(--fill);
+  background: var(--handle-color);
   border-radius: var(--border-radius);
   box-shadow: var(--box-shadow);
   outline: var(--outline);
   border: var(--border);
 
+  &::before {
+    content: "";
+    color-scheme: light only;
+    width: calc(var(--width) - 4px);
+    height: calc(var(--height) - 4px);
+    background: var(--fill);
+    border-radius: var(--border-radius);
+    box-shadow: inset 0 0 0 1px var(--figma-color-bordertranslucent);
+    place-self: center;
+  }
+
   &[size="small"] {
     --width: 0.5625rem;
     --height: 0.5625rem;
@@ -4773,10 +4793,10 @@ fig-handle {
     position: absolute;
     touch-action: none;
   }
-
+  &:hover,
   &[selected]:not([selected="false"]) {
     outline: var(--ring-width) solid var(--figma-color-border-selected);
-    outline-offset: var(--ring-width);
+    outline-offset: 0;
   }
 
   &[disabled]:not([disabled="false"]),
@@ -4786,10 +4806,9 @@ fig-handle {
     cursor: default;
   }
 
-  &[type="color"] {
-    contain: layout style;
+  &[type="color"],
+  &[control] {
     overflow: visible;
-    position: relative;
 
     fig-color-tip {
       position: absolute;
@@ -4812,7 +4831,7 @@ fig-color-tip {
   place-items: center;
   overflow: visible;
   position: relative;
-  color: var(--text-primary);
+  color: var(--figma-color-text);
   color-scheme: light only;
   aspect-ratio: 1 / 1;
   flex-shrink: 0;
@@ -4825,6 +4844,11 @@ fig-color-tip {
     drop-shadow(0px 2.5px 6px rgba(0, 0, 0, 0.13))
     drop-shadow(0px 0px 0.5px rgba(0, 0, 0, 0.15));
 
+  &[control="add"],
+  &[control="remove"] {
+    cursor: pointer;
+  }
+
   fig-chit {
     input[type="color"] {
       background: transparent;

package/fig.js

@@ -659,7 +659,12 @@ class FigTooltip extends HTMLElement {
     };
   }
 
+  get #showPersisted() {
+    return this.hasAttribute("show") && this.getAttribute("show") !== "false";
+  }
+
   showDelayedPopup() {
+    if (this.#showPersisted) return;
     this.render();
     clearTimeout(this.timeout);
     const warm =
@@ -669,10 +674,12 @@ class FigTooltip extends HTMLElement {
   }
 
   showPopup() {
+    if (!this.popup) this.render();
+    this.popup.style.display = "block";
+    this.popup.style.visibility = "hidden";
     this.#repositionPopup();
     this.popup.style.opacity = "1";
     this.popup.style.visibility = "visible";
-    this.popup.style.display = "block";
     this.popup.style.pointerEvents = "all";
     this.popup.style.zIndex = figGetHighestZIndex() + 1;
 
@@ -725,6 +732,7 @@ class FigTooltip extends HTMLElement {
   }
 
   hidePopup() {
+    if (this.#showPersisted) return;
     clearTimeout(this.timeout);
     clearTimeout(this.#touchTimeout);
     this.#stopObserving();
@@ -824,7 +832,28 @@ class FigTooltip extends HTMLElement {
   }
 
   static get observedAttributes() {
-    return ["action", "delay", "open"];
+    return ["action", "delay", "open", "show", "text"];
+  }
+  get text() {
+    return this.getAttribute("text") ?? "";
+  }
+  set text(value) {
+    this.setAttribute("text", value);
+  }
+  #updateText(value) {
+    if (!this.popup) return;
+    const content = this.popup.firstElementChild ?? this.popup.firstChild;
+    if (!content) return;
+    content.innerText = value;
+    content.style.width = "";
+    const textNode = content.childNodes[0];
+    if (textNode) {
+      const range = document.createRange();
+      range.setStartBefore(textNode);
+      range.setEndAfter(textNode);
+      content.style.width = `${range.getBoundingClientRect().width}px`;
+    }
+    if (this.isOpen) this.#repositionPopup();
   }
   get open() {
     return this.hasAttribute("open") && this.getAttribute("open") === "true";
@@ -851,6 +880,17 @@ class FigTooltip extends HTMLElement {
         });
       }
     }
+    if (name === "show") {
+      const on = newValue !== null && newValue !== "false";
+      if (on) {
+        this.showPopup();
+      } else {
+        this.hidePopup();
+      }
+    }
+    if (name === "text") {
+      this.#updateText(newValue ?? "");
+    }
   }
 
   #hideOnChromeOpen(e) {
@@ -5651,8 +5691,9 @@ customElements.define("fig-input-fill", FigInputFill);
  * @fires change - When the gradient value is committed
  */
 class FigInputGradient extends HTMLElement {
-  #fillPicker;
+  #chit;
   #track;
+  #handleDragging = false;
   #colorObserver = null;
   #gradient = {
     type: "linear",
@@ -5670,14 +5711,46 @@ class FigInputGradient extends HTMLElement {
   }
 
   static get observedAttributes() {
-    return ["value", "disabled", "experimental", "picker-anchor"];
+    return ["value", "disabled"];
   }
 
   connectedCallback() {
     this.#parseValue();
     this.#render();
+    document.addEventListener("keydown", this.#onKeyDown);
+  }
+
+  disconnectedCallback() {
+    document.removeEventListener("keydown", this.#onKeyDown);
   }
 
+  #onKeyDown = (e) => {
+    if (e.key !== "Delete" && e.key !== "Backspace") return;
+    const active = document.activeElement;
+    if (
+      active &&
+      (active.tagName === "INPUT" ||
+        active.tagName === "TEXTAREA" ||
+        active.isContentEditable)
+    )
+      return;
+    if (this.#gradient.stops.length <= 2) return;
+    if (!this.#track) return;
+    const selected = this.#track.querySelector(
+      "fig-handle[selected]:not(.fig-input-gradient-ghost)",
+    );
+    if (!selected) return;
+    const idx = parseInt(selected.dataset.stopIndex, 10);
+    if (isNaN(idx) || !this.#gradient.stops[idx]) return;
+    e.preventDefault();
+    selected.removeAttribute("selected");
+    this.#gradient.stops.splice(idx, 1);
+    this.#syncHandles();
+    this.#syncChit();
+    this.#emitInput();
+    this.#emitChange();
+  };
+
   #parseValue() {
     const valueAttr = this.getAttribute("value");
     if (!valueAttr) return;
@@ -5701,19 +5774,12 @@ class FigInputGradient extends HTMLElement {
     }
   }
 
-  #buildFillPickerAttrs() {
-    const attrs = {};
-    const experimental = this.getAttribute("experimental");
-    if (experimental) attrs["experimental"] = experimental;
-    for (const { name, value } of this.attributes) {
-      if (name.startsWith("picker-") && name !== "picker-anchor") {
-        attrs[name.slice(7)] = value;
-      }
-    }
-    if (!attrs["dialog-position"]) attrs["dialog-position"] = "left";
-    return Object.entries(attrs)
-      .map(([k, v]) => `${k}="${v}"`)
-      .join(" ");
+  #buildGradientCSS() {
+    const sorted = [...this.#gradient.stops].sort(
+      (a, b) => a.position - b.position,
+    );
+    const stops = sorted.map((s) => `${s.color} ${s.position}%`).join(", ");
+    return `linear-gradient(${this.#gradient.angle}deg, ${stops})`;
   }
 
   #buildStopHandles() {
@@ -5721,23 +5787,19 @@ class FigInputGradient extends HTMLElement {
     return this.#gradient.stops
       .map(
         (stop, i) =>
-          `<fig-handle drag drag-axes="x" type="color" color="${stop.color}" value="${stop.position}% 50%" data-stop-index="${i}"${disabled ? " disabled" : ""}></fig-handle>`,
+          `<fig-tooltip action="manual" text="${Math.round(stop.position)}%"><fig-handle drag drag-axes="x" drag-surface=".fig-input-gradient-track" type="color" color="${stop.color}" value="${stop.position}% 50%" data-stop-index="${i}"${disabled ? " disabled" : ""}></fig-handle></fig-tooltip>`,
       )
       .join("");
   }
 
   #ghostHandle = null;
-  #ghostTooltip = null;
 
   #render() {
     const disabled = this.hasAttribute("disabled");
-    const fillPickerValue = JSON.stringify(this.value);
-    const fpAttrs = this.#buildFillPickerAttrs();
     this.innerHTML = `
-      <fig-fill-picker mode="gradient" ${fpAttrs} value='${fillPickerValue}' ${
-        disabled ? "disabled" : ""
-      }></fig-fill-picker>
+      <fig-chit size="medium" background="${this.#buildGradientCSS()}"${disabled ? " disabled" : ""}></fig-chit>
       <div class="fig-input-gradient-track">${this.#buildStopHandles()}</div>`;
+    this.#chit = this.querySelector("fig-chit");
     this.#track = this.querySelector(".fig-input-gradient-track");
     this.#setupGhostHandle();
     this.#setupEventListeners();
@@ -5765,9 +5827,6 @@ class FigInputGradient extends HTMLElement {
 
   #setupGhostHandle() {
     if (!this.#track || this.hasAttribute("disabled")) return;
-    const tooltip = document.createElement("fig-tooltip");
-    tooltip.setAttribute("text", "Add color stop");
-    tooltip.setAttribute("action", "manual");
 
     const ghost = document.createElement("fig-handle");
     ghost.classList.add("fig-input-gradient-ghost");
@@ -5777,34 +5836,39 @@ class FigInputGradient extends HTMLElement {
     ghost.style.pointerEvents = "none";
     ghost.style.opacity = "0";
     ghost.style.transition = "opacity 0.15s";
+    ghost.style.overflow = "visible";
 
-    tooltip.appendChild(ghost);
-    this.#track.appendChild(tooltip);
+    const tip = document.createElement("fig-color-tip");
+    tip.setAttribute("control", "add");
+    tip.style.position = "absolute";
+    tip.style.bottom = "calc(100% + 6px)";
+    tip.style.left = "50%";
+    tip.style.transform = "translateX(-50%)";
+    tip.style.zIndex = "10";
+    ghost.appendChild(tip);
+
+    this.#track.appendChild(ghost);
     this.#ghostHandle = ghost;
-    this.#ghostTooltip = tooltip;
 
     this.addEventListener("pointerenter", this.#onTrackEnter);
     this.addEventListener("pointermove", this.#onTrackMove);
     this.addEventListener("pointerleave", this.#onTrackLeave);
     this.addEventListener("click", this.#onTrackClick);
+    this.addEventListener("dblclick", this.#onTrackDblClick);
   }
 
   #showGhost() {
     if (!this.#ghostHandle) return;
-    this.#ghostHandle.style.opacity = "0.5";
-    if (this.#ghostTooltip) {
-      this.#ghostTooltip.render();
-      this.#ghostTooltip.showPopup();
-    }
+    this.#ghostHandle.style.opacity = "1";
   }
 
   #hideGhost() {
     if (!this.#ghostHandle) return;
     this.#ghostHandle.style.opacity = "0";
-    if (this.#ghostTooltip) this.#ghostTooltip.hidePopup();
   }
 
   #onTrackEnter = () => {
+    if (this.#handleDragging) return;
     this.#showGhost();
   };
 
@@ -5813,6 +5877,10 @@ class FigInputGradient extends HTMLElement {
   };
 
   #onTrackMove = (e) => {
+    if (this.#handleDragging) {
+      this.#hideGhost();
+      return;
+    }
     if (!this.#ghostHandle || !this.#track) return;
     if (e.target.closest("fig-handle:not(.fig-input-gradient-ghost)")) {
       this.#hideGhost();
@@ -5829,9 +5897,37 @@ class FigInputGradient extends HTMLElement {
     this.#showGhost();
   };
 
+  #distributeStops() {
+    const count = this.#gradient.stops.length;
+    if (count < 2) return;
+    for (let i = 0; i < count; i++) {
+      this.#gradient.stops[i].position = Math.round((i / (count - 1)) * 100);
+    }
+    this.#syncHandles();
+    this.#syncChit();
+    this.#emitInput();
+    this.#emitChange();
+    this.#track?.querySelectorAll("fig-handle[selected]").forEach((h) => {
+      h.removeAttribute("selected");
+    });
+  }
+
+  #onTrackDblClick = (e) => {
+    if (!this.#track) return;
+    if (!e.target.closest("fig-handle:not(.fig-input-gradient-ghost)")) return;
+    this.#distributeStops();
+  };
+
   #onTrackClick = (e) => {
     if (!this.#track) return;
-    if (e.target.closest("fig-handle:not(.fig-input-gradient-ghost)")) return;
+    if (this.#handleDragging) return;
+    if (e.target.closest("fig-handle:not(.fig-input-gradient-ghost)")) {
+      if (e.shiftKey) {
+        this.#distributeStops();
+        e.stopPropagation();
+      }
+      return;
+    }
     const trackRect = this.#track.getBoundingClientRect();
     const pct = Math.max(
       0,
@@ -5841,10 +5937,21 @@ class FigInputGradient extends HTMLElement {
     const color = this.#sampleGradientColor(pct);
     this.#gradient.stops.push({ position, color, opacity: 100 });
     this.#gradient.stops.sort((a, b) => a.position - b.position);
+    const newIndex = this.#gradient.stops.findIndex(
+      (s) => s.position === position && s.color === color,
+    );
     this.#syncHandles();
-    this.#syncFillPicker();
+    this.#syncChit();
     this.#emitInput();
     this.#emitChange();
+
+    requestAnimationFrame(() => {
+      const handles = this.#track.querySelectorAll(
+        "fig-handle:not(.fig-input-gradient-ghost)",
+      );
+      const newHandle = handles[newIndex];
+      if (newHandle) newHandle.click();
+    });
   };
 
   #syncHandles() {
@@ -5855,9 +5962,9 @@ class FigInputGradient extends HTMLElement {
     const stops = this.#gradient.stops;
 
     if (handles.length !== stops.length) {
-      const wrapper = this.#ghostTooltip;
+      const ghost = this.#ghostHandle;
       this.#track.innerHTML = this.#buildStopHandles();
-      if (wrapper) this.#track.appendChild(wrapper);
+      if (ghost) this.#track.appendChild(ghost);
       this.#reobserveHandleColors();
       return;
     }
@@ -5867,6 +5974,8 @@ class FigInputGradient extends HTMLElement {
       const stop = stops[i];
       h.setAttribute("value", `${stop.position}% 50%`);
       h.setAttribute("color", stop.color);
+      const tip = h.closest("fig-tooltip");
+      if (tip) tip.setAttribute("text", `${Math.round(stop.position)}%`);
     }
   }
 
@@ -5883,92 +5992,155 @@ class FigInputGradient extends HTMLElement {
       });
   }
 
-  #syncFillPicker() {
-    if (!this.#fillPicker) return;
-    this.#fillPicker.setAttribute("value", JSON.stringify(this.value));
+  #syncStopIndices() {
+    if (!this.#track) return;
+    const handles = this.#track.querySelectorAll(
+      "fig-handle:not(.fig-input-gradient-ghost)",
+    );
+    const stops = this.#gradient.stops;
+    const used = new Set();
+    handles.forEach((h) => {
+      const pos = Math.round(parseFloat(h.getAttribute("value")) || 0);
+      const color = (h.getAttribute("color") || "").toUpperCase();
+      let best = -1;
+      for (let i = 0; i < stops.length; i++) {
+        if (used.has(i)) continue;
+        if (
+          stops[i].position === pos &&
+          stops[i].color.toUpperCase() === color
+        ) {
+          best = i;
+          break;
+        }
+      }
+      if (best === -1) {
+        let minDist = Infinity;
+        for (let i = 0; i < stops.length; i++) {
+          if (used.has(i)) continue;
+          const d = Math.abs(stops[i].position - pos);
+          if (d < minDist) {
+            minDist = d;
+            best = i;
+          }
+        }
+      }
+      if (best !== -1) {
+        used.add(best);
+        h.dataset.stopIndex = best;
+      }
+    });
+  }
+
+  #syncChit() {
+    if (!this.#chit) return;
+    this.#chit.setAttribute("background", this.#buildGradientCSS());
   }
 
   #setupEventListeners() {
-    requestAnimationFrame(() => {
-      this.#fillPicker = this.querySelector("fig-fill-picker");
-      if (!this.#fillPicker) return;
+    if (!this.#track) return;
 
-      const anchor = this.getAttribute("picker-anchor");
-      if (!anchor || anchor === "self") {
-        this.#fillPicker.anchorElement = this;
+    this.#track.addEventListener("input", (e) => {
+      const handle = e.target.closest("fig-handle");
+      if (!handle) return;
+      e.stopPropagation();
+      if (!this.#handleDragging) handle.style.zIndex = "5";
+      this.#handleDragging = true;
+      const idx = parseInt(handle.dataset.stopIndex, 10);
+      if (isNaN(idx) || !this.#gradient.stops[idx]) return;
+      const px = e.detail?.px ?? 0;
+      const rawPosition = Math.round(px * 100);
+      let position = rawPosition;
+      const trackW = this.#track.getBoundingClientRect().width;
+      if (e.detail?.shiftKey) {
+        position = Math.round(position / 10) * 10;
       } else {
-        const el = document.querySelector(anchor);
-        if (el) this.#fillPicker.anchorElement = el;
+        const snapPct = trackW > 0 ? (5 / trackW) * 100 : 0;
+        for (let i = 0; i < this.#gradient.stops.length; i++) {
+          if (i === idx) continue;
+          if (
+            Math.abs(this.#gradient.stops[i].position - position) <= snapPct
+          ) {
+            position = this.#gradient.stops[i].position;
+            break;
+          }
+        }
+      }
+      this.#gradient.stops[idx].position = position;
+      if (position !== rawPosition) {
+        handle.style.left = `${(position / 100) * trackW - handle.offsetWidth / 2}px`;
       }
+      const tooltip = handle.closest("fig-tooltip");
+      if (tooltip) {
+        tooltip.text = `${Math.round(position)}%`;
+        if (!tooltip.hasAttribute("show")) tooltip.setAttribute("show", "true");
+      }
+      this.#syncChit();
+      this.#emitInput();
+    });
 
-      this.#fillPicker.addEventListener("input", (e) => {
-        e.stopPropagation();
-        const detail = e.detail;
-        if (detail?.gradient) {
-          this.#gradient = normalizeGradientConfig({
-            ...this.#gradient,
-            ...detail.gradient,
-          });
-          this.#syncHandles();
-          this.#emitInput();
+    this.#track.addEventListener("change", (e) => {
+      const handle = e.target.closest("fig-handle");
+      if (!handle) return;
+      e.stopPropagation();
+      handle.style.zIndex = "";
+      const tooltip = handle.closest("fig-tooltip");
+      if (tooltip) tooltip.removeAttribute("show");
+      const idx = parseInt(handle.dataset.stopIndex, 10);
+      if (isNaN(idx) || !this.#gradient.stops[idx]) return;
+      const px = e.detail?.px ?? 0;
+      let position = Math.round(px * 100);
+      const trackW = this.#track.getBoundingClientRect().width;
+      const snapPct = trackW > 0 ? (5 / trackW) * 100 : 0;
+      for (let i = 0; i < this.#gradient.stops.length; i++) {
+        if (i === idx) continue;
+        if (Math.abs(this.#gradient.stops[i].position - position) <= snapPct) {
+          position = this.#gradient.stops[i].position;
+          break;
         }
+      }
+      this.#gradient.stops[idx].position = position;
+      handle.style.left = `${(position / 100) * trackW - handle.offsetWidth / 2}px`;
+      this.#gradient.stops.sort((a, b) => a.position - b.position);
+      this.#syncStopIndices();
+      this.#syncChit();
+      this.#emitChange();
+      const swallow = (evt) => {
+        evt.stopPropagation();
+        evt.preventDefault();
+      };
+      this.#track.addEventListener("click", swallow, {
+        capture: true,
+        once: true,
       });
-
-      this.#fillPicker.addEventListener("change", (e) => {
-        e.stopPropagation();
-        this.#emitChange();
+      requestAnimationFrame(() => {
+        this.#handleDragging = false;
+        this.#track.removeEventListener("click", swallow, { capture: true });
       });
+    });
 
-      if (this.#track) {
-        this.#track.addEventListener("input", (e) => {
-          const handle = e.target.closest("fig-handle");
-          if (!handle) return;
-          e.stopPropagation();
-          const idx = parseInt(handle.dataset.stopIndex, 10);
-          if (isNaN(idx) || !this.#gradient.stops[idx]) return;
-          const px = e.detail?.px ?? 0;
-          this.#gradient.stops[idx].position = Math.round(px * 100);
-          this.#syncFillPicker();
+    this.#colorObserver = new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        if (m.attributeName !== "color") continue;
+        const handle = m.target;
+        if (handle.classList.contains("fig-input-gradient-ghost")) continue;
+        const idx = parseInt(handle.dataset.stopIndex, 10);
+        if (isNaN(idx) || !this.#gradient.stops[idx]) continue;
+        const newColor = handle.getAttribute("color");
+        if (newColor && newColor !== this.#gradient.stops[idx].color) {
+          this.#gradient.stops[idx].color = newColor;
+          this.#syncChit();
           this.#emitInput();
-        });
-
-        this.#track.addEventListener("change", (e) => {
-          const handle = e.target.closest("fig-handle");
-          if (!handle) return;
-          e.stopPropagation();
-          const idx = parseInt(handle.dataset.stopIndex, 10);
-          if (isNaN(idx) || !this.#gradient.stops[idx]) return;
-          const px = e.detail?.px ?? 0;
-          this.#gradient.stops[idx].position = Math.round(px * 100);
-          this.#syncFillPicker();
-          this.#emitChange();
-        });
-
-        this.#colorObserver = new MutationObserver((mutations) => {
-          for (const m of mutations) {
-            if (m.attributeName !== "color") continue;
-            const handle = m.target;
-            if (handle.classList.contains("fig-input-gradient-ghost")) continue;
-            const idx = parseInt(handle.dataset.stopIndex, 10);
-            if (isNaN(idx) || !this.#gradient.stops[idx]) continue;
-            const newColor = handle.getAttribute("color");
-            if (newColor && newColor !== this.#gradient.stops[idx].color) {
-              this.#gradient.stops[idx].color = newColor;
-              this.#syncFillPicker();
-              this.#emitInput();
-            }
-          }
-        });
-        this.#track
-          .querySelectorAll("fig-handle:not(.fig-input-gradient-ghost)")
-          .forEach((h) => {
-            this.#colorObserver.observe(h, {
-              attributes: true,
-              attributeFilter: ["color"],
-            });
-          });
+        }
       }
     });
+    this.#track
+      .querySelectorAll("fig-handle:not(.fig-input-gradient-ghost)")
+      .forEach((h) => {
+        this.#colorObserver.observe(h, {
+          attributes: true,
+          attributeFilter: ["color"],
+        });
+      });
   }
 
   #emitInput() {
@@ -6009,15 +6181,11 @@ class FigInputGradient extends HTMLElement {
     switch (name) {
       case "value":
         this.#parseValue();
-        if (this.#fillPicker) {
-          this.#syncFillPicker();
-        }
+        this.#syncChit();
         this.#syncHandles();
         break;
       case "disabled":
-      case "experimental":
-      case "picker-anchor":
-        if (this.#fillPicker) this.#render();
+        this.#render();
         break;
     }
   }
@@ -10292,6 +10460,7 @@ class FigFillPicker extends HTMLElement {
           drag
           drag-surface=".fig-fill-picker-color-area"
           drag-axes="x,y"
+          drag-snapping="modifier"
         ></fig-handle>
       </fig-preview>
       <div class="fig-fill-picker-sliders">
@@ -11879,7 +12048,11 @@ class FigColorTip extends HTMLElement {
   #boundHandleChange = this.#handlePickerChange.bind(this);
 
   static get observedAttributes() {
-    return ["value", "selected", "disabled", "alpha"];
+    return ["value", "selected", "disabled", "alpha", "control"];
+  }
+
+  get #controlMode() {
+    return this.getAttribute("control") || "color";
   }
 
   connectedCallback() {
@@ -11889,6 +12062,7 @@ class FigColorTip extends HTMLElement {
 
   disconnectedCallback() {
     this.#teardownListeners();
+    this.removeEventListener("click", this.#handleControlClick);
   }
 
   #teardownListeners() {
@@ -11913,6 +12087,17 @@ class FigColorTip extends HTMLElement {
   }
 
   #render() {
+    const mode = this.#controlMode;
+    if (mode === "add" || mode === "remove") {
+      const icon = mode === "add" ? "var(--icon-add)" : "var(--icon-minus)";
+      this.innerHTML = `<fig-button icon variant="ghost"><span class="fig-mask-icon" style="--icon: ${icon}"></span></fig-button>`;
+      this.#fillPicker = null;
+      this.#chit = null;
+      this.addEventListener("click", this.#handleControlClick);
+      return;
+    }
+    this.removeEventListener("click", this.#handleControlClick);
+
     const color = this.#normalizeColor(this.getAttribute("value"));
     const alphaAttr = this.#alphaEnabled ? "" : 'alpha="false"';
     this.innerHTML = `
@@ -11931,6 +12116,13 @@ class FigColorTip extends HTMLElement {
     });
   }
 
+  #handleControlClick = () => {
+    const mode = this.#controlMode;
+    this.dispatchEvent(
+      new CustomEvent(mode, { bubbles: true, composed: true }),
+    );
+  };
+
   #normalizeHex(hex) {
     if (!hex) return "#D9D9D9";
     const raw = hex.replace("#", "").trim();
@@ -12059,6 +12251,9 @@ class FigColorTip extends HTMLElement {
     if (!this.isConnected) return;
 
     switch (name) {
+      case "control":
+        this.#render();
+        break;
       case "value":
       case "selected":
       case "disabled":
@@ -12668,6 +12863,7 @@ class FigHandle extends HTMLElement {
     "drag-snapping",
     "value",
     "type",
+    "control",
   ];
 
   #isDragging = false;
@@ -12676,6 +12872,18 @@ class FigHandle extends HTMLElement {
   #applyingValue = false;
   #colorTip = null;
 
+  get #controlMode() {
+    return this.getAttribute("control") || null;
+  }
+
+  get #hasControlMode() {
+    return this.#controlMode === "add" || this.#controlMode === "remove";
+  }
+
+  get #isGhost() {
+    return this.classList.contains("fig-input-gradient-ghost");
+  }
+
   get #dragEnabled() {
     const v = this.getAttribute("drag");
     return v !== null && v !== "false";
@@ -12806,6 +13014,7 @@ class FigHandle extends HTMLElement {
     document.addEventListener("pointerdown", this.#handleDeselect);
     const initial = this.getAttribute("value");
     if (initial) this.#applyValue(initial);
+    if (this.#hasControlMode && !this.#isGhost) this.#showColorTip();
   }
 
   disconnectedCallback() {
@@ -12817,6 +13026,7 @@ class FigHandle extends HTMLElement {
 
   #handleSelect = (e) => {
     if (this.hasAttribute("disabled")) return;
+    if (this.#hasControlMode) return;
     if (this.#didDrag) {
       this.#didDrag = false;
       return;
@@ -12826,6 +13036,7 @@ class FigHandle extends HTMLElement {
   };
 
   #handleDeselect = (e) => {
+    if (this.#hasControlMode) return;
     if (this.contains(e.target)) return;
     if (this.#colorTip && e.target.closest?.("dialog, [popover]")) return;
     this.removeAttribute("selected");
@@ -12834,7 +13045,7 @@ class FigHandle extends HTMLElement {
 
   attributeChangedCallback(name, _old, value) {
     if (name === "color") {
-      if (!value || value === "false") {
+      if (!value || value === "false" || value === "true") {
         this.style.removeProperty("--fill");
       } else {
         this.style.setProperty("--fill", value);
@@ -12844,6 +13055,14 @@ class FigHandle extends HTMLElement {
     if (name === "value" && !this.#applyingValue && !this.#isDragging) {
       this.#applyValue(value);
     }
+    if (name === "control" && !this.#isGhost) {
+      if (this.#hasControlMode) {
+        this.#hideColorTip();
+        this.#showColorTip();
+      } else {
+        this.#hideColorTip();
+      }
+    }
   }
 
   #syncDrag() {
@@ -12920,28 +13139,21 @@ class FigHandle extends HTMLElement {
       }
     };
 
-    const isColorType = this.getAttribute("type") === "color";
-    if (!isColorType) {
-      clampAndApply(e.clientX, e.clientY, e.shiftKey);
-    }
-    this.style.cursor = "grabbing";
-    if (!isColorType) {
-      this.dispatchEvent(
-        new CustomEvent("input", {
-          bubbles: true,
-          detail: this.#positionDetail(containerRect),
-        }),
-      );
-    }
-
     const onMove = (e) => {
       if (!this.#isDragging) return;
+      if (!this.#didDrag) {
+        this.classList.add("dragging");
+        this.style.cursor = "grabbing";
+      }
       this.#didDrag = true;
       clampAndApply(e.clientX, e.clientY, e.shiftKey);
       this.dispatchEvent(
         new CustomEvent("input", {
           bubbles: true,
-          detail: this.#positionDetail(container.getBoundingClientRect()),
+          detail: {
+            ...this.#positionDetail(container.getBoundingClientRect()),
+            shiftKey: e.shiftKey,
+          },
         }),
       );
     };
@@ -12949,18 +13161,30 @@ class FigHandle extends HTMLElement {
     const onUp = (e) => {
       this.#isDragging = false;
       this.style.cursor = "";
+      this.classList.remove("dragging");
       window.removeEventListener("pointermove", onMove);
       window.removeEventListener("pointerup", onUp);
-      if (this.#didDrag || !isColorType) {
+      if (this.#didDrag) {
         clampAndApply(e.clientX, e.clientY, e.shiftKey);
+        this.#syncValueAttribute();
+        this.dispatchEvent(
+          new CustomEvent("change", {
+            bubbles: true,
+            detail: this.#positionDetail(container.getBoundingClientRect()),
+          }),
+        );
+        const swallowClick = (evt) => {
+          evt.stopPropagation();
+          evt.preventDefault();
+        };
+        this.addEventListener("click", swallowClick, {
+          capture: true,
+          once: true,
+        });
+      } else {
+        this.#syncValueAttribute();
       }
-      this.#syncValueAttribute();
-      this.dispatchEvent(
-        new CustomEvent("change", {
-          bubbles: true,
-          detail: this.#positionDetail(container.getBoundingClientRect()),
-        }),
-      );
+      this.#didDrag = false;
     };
 
     window.addEventListener("pointermove", onMove);
@@ -12970,12 +13194,17 @@ class FigHandle extends HTMLElement {
   #showColorTip() {
     if (this.#colorTip) return;
     const tip = document.createElement("fig-color-tip");
-    tip.setAttribute("value", this.getAttribute("color") || "#D9D9D9");
-    tip.setAttribute("selected", "");
-    tip.setAttribute("alpha", "true");
-    tip.addEventListener("pointerdown", (e) => e.stopPropagation());
+    if (this.#hasControlMode) {
+      tip.setAttribute("control", this.#controlMode);
+    } else {
+      tip.setAttribute("value", this.getAttribute("color") || "#D9D9D9");
+      tip.setAttribute("alpha", "true");
+      tip.setAttribute("selected", "");
+    }
     tip.addEventListener("input", this.#handleColorTipInput);
     tip.addEventListener("change", this.#handleColorTipChange);
+    tip.addEventListener("add", this.#handleColorTipControl);
+    tip.addEventListener("remove", this.#handleColorTipControl);
     this.appendChild(tip);
     this.#colorTip = tip;
   }
@@ -12984,6 +13213,8 @@ class FigHandle extends HTMLElement {
     if (!this.#colorTip) return;
     this.#colorTip.removeEventListener("input", this.#handleColorTipInput);
     this.#colorTip.removeEventListener("change", this.#handleColorTipChange);
+    this.#colorTip.removeEventListener("add", this.#handleColorTipControl);
+    this.#colorTip.removeEventListener("remove", this.#handleColorTipControl);
     this.#colorTip.remove();
     this.#colorTip = null;
   }
@@ -12998,6 +13229,13 @@ class FigHandle extends HTMLElement {
     if (e.detail?.color) this.setAttribute("color", e.detail.color);
   };
 
+  #handleColorTipControl = (e) => {
+    e.stopPropagation();
+    this.dispatchEvent(
+      new CustomEvent(e.type, { bubbles: true, composed: true }),
+    );
+  };
+
   #positionDetail(containerRect) {
     const hw = this.offsetWidth / 2;
     const hh = this.offsetHeight / 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogieking/figui3",
-  "version": "3.13.0",
+  "version": "3.14.0",
   "description": "A lightweight web components library for building Figma plugin and widget UIs with native look and feel",
   "author": "Rogie King",
   "license": "MIT",