gaugeit.js 0.1.0 → 0.1.1

package/dist/gaugeit.css

@@ -115,7 +115,6 @@ gauge-it {
   --gaugeit-light-off: #3f2d12;
   --gaugeit-light-opacity: 1;
   pointer-events: none;
-  opacity: var(--gaugeit-light-opacity);
 }
 
 .gaugeit__light--red {
@@ -198,26 +197,31 @@ gauge-it {
   --gaugeit-light-off: #332617;
 }
 
-.gaugeit__light-emission {
+.gaugeit__light-emission,
+.gaugeit__light-glow-emission {
   pointer-events: none;
   transition: opacity 150ms ease;
 }
 
 .gaugeit__light-emission--off {
-  opacity: var(--gaugeit-light-opacity, 1);
+  opacity: 1;
 }
 
 .gaugeit__light-emission--on {
   opacity: 0;
 }
 
+.gaugeit__light-glow-emission {
+  opacity: 0;
+}
+
 .gaugeit__light-glow {
-  opacity: 0.76;
+  opacity: 1;
   transform-box: fill-box;
   transform-origin: center;
 }
 
-.gaugeit__light:not(.has-glow) .gaugeit__light-glow {
+.gaugeit__light:not(.has-glow) .gaugeit__light-glow-emission {
   display: none;
 }
 
@@ -235,18 +239,23 @@ gauge-it {
   transition: filter 150ms ease;
 }
 
-.gaugeit__light.is-on:not(.is-blinking) .gaugeit__light-emission--off {
-  opacity: 0;
+.gaugeit__light.is-on:not(.is-blinking) .gaugeit__light-emission--on {
+  opacity: var(--gaugeit-light-on-opacity, var(--gaugeit-light-opacity, 1));
 }
 
-.gaugeit__light.is-on:not(.is-blinking) .gaugeit__light-emission--on {
-  opacity: var(--gaugeit-light-opacity, 1);
+.gaugeit__light.is-on:not(.is-blinking) .gaugeit__light-glow-emission {
+  opacity: var(--gaugeit-light-glow-opacity, 0.15);
 }
 
 .gaugeit__light.is-on .gaugeit__light-bulb--on {
   filter: saturate(1.08) brightness(1.05);
 }
 
+.gaugeit__light.is-flickering .gaugeit__light-emission--on,
+.gaugeit__light.is-flickering .gaugeit__light-glow-emission {
+  transition: opacity 24ms linear;
+}
+
 .gaugeit__light.is-pulsing .gaugeit__light-glow {
   animation: gaugeit-light-pulse-glow var(--gaugeit-light-pulse-duration, 2600ms) ease-in-out infinite;
 }
@@ -259,8 +268,8 @@ gauge-it {
   animation: gaugeit-light-blink-on var(--gaugeit-light-blink-duration, 1000ms) step-end infinite;
 }
 
-.gaugeit__light.is-on.is-blinking .gaugeit__light-emission--off {
-  animation: gaugeit-light-blink-off var(--gaugeit-light-blink-duration, 1000ms) step-end infinite;
+.gaugeit__light.is-on.is-blinking .gaugeit__light-glow-emission {
+  animation: gaugeit-light-blink-glow var(--gaugeit-light-blink-duration, 1000ms) step-end infinite;
 }
 
 @keyframes gaugeit-light-pulse-glow {
@@ -274,27 +283,30 @@ gauge-it {
 }
 
 @keyframes gaugeit-light-blink-on {
-  0%, 48% { opacity: var(--gaugeit-light-opacity, 1); }
+  0%, 48% { opacity: var(--gaugeit-light-on-opacity, var(--gaugeit-light-opacity, 1)); }
   49%, 100% { opacity: 0; }
 }
 
-@keyframes gaugeit-light-blink-off {
-  0%, 48% { opacity: 0; }
-  49%, 100% { opacity: var(--gaugeit-light-opacity, 1); }
+@keyframes gaugeit-light-blink-glow {
+  0%, 48% { opacity: var(--gaugeit-light-glow-opacity, 0.15); }
+  49%, 100% { opacity: 0; }
 }
 
 @media (prefers-reduced-motion: reduce) {
-  .gaugeit__light.is-blinking .gaugeit__light-emission,
+  .gaugeit__light.is-blinking .gaugeit__light-emission--on,
+  .gaugeit__light.is-blinking .gaugeit__light-glow-emission,
+  .gaugeit__light.is-flickering .gaugeit__light-emission--on,
+  .gaugeit__light.is-flickering .gaugeit__light-glow-emission,
   .gaugeit__light.is-pulsing .gaugeit__light-glow,
   .gaugeit__light.is-pulsing .gaugeit__light-bulb--on {
     animation: none;
   }
 
-  .gaugeit__light.is-on.is-blinking .gaugeit__light-emission--off {
-    opacity: 0;
+  .gaugeit__light.is-on.is-blinking .gaugeit__light-emission--on {
+    opacity: var(--gaugeit-light-on-opacity, var(--gaugeit-light-opacity, 1));
   }
 
-  .gaugeit__light.is-on.is-blinking .gaugeit__light-emission--on {
-    opacity: var(--gaugeit-light-opacity, 1);
+  .gaugeit__light.is-on.is-blinking .gaugeit__light-glow-emission {
+    opacity: var(--gaugeit-light-glow-opacity, 0.15);
   }
 }

package/dist/gaugeit.d.ts

@@ -46,6 +46,10 @@ export interface GaugeLightOptions {
   x?: number;
   y?: number;
   radius?: number;
+  /** Glow-circle radius. Defaults to 20; null derives it from radius * 1.82. */
+  glowRadius?: number | null;
+  /** Glow blur from 0 (soft Gaussian glow) to 1 (completely sharp). */
+  glowSharpness?: number;
   color?: GaugeLightColor;
   customColor?: string;
   /** Cream-toned unlit lens color. */
@@ -54,7 +58,10 @@ export interface GaugeLightOptions {
   offEdgeColor?: string;
   bezelColor?: string;
   bezelHighlightColor?: string;
+  /** Illuminated-lens opacity; the unlit physical lamp and bezel remain visible. */
   opacity?: number;
+  /** Glow-only opacity; independent from the illuminated lens opacity. Defaults to 0.15. */
+  glowOpacity?: number;
   on?: boolean;
   glow?: boolean;
   /** Enables a very subtle steady-light breathing effect. */
@@ -62,6 +69,16 @@ export interface GaugeLightOptions {
   pulseInterval?: number;
   blink?: boolean;
   blinkInterval?: number;
+  /** Adds fast randomized brightness variation; compatible with pulse and blink. */
+  flicker?: boolean;
+  /** Maximum randomized light loss, from 0 (steady) to 1 (may switch fully off). Defaults to 0.1. */
+  flickerIntensity?: number;
+  /** Maximum relative glow-radius variation, from 0 to 1. Defaults to 0.1. */
+  flickerGlowRadius?: number;
+  /** Shortest delay between brightness changes in milliseconds. */
+  flickerMinInterval?: number;
+  /** Longest delay between brightness changes in milliseconds. */
+  flickerMaxInterval?: number;
   trigger?: {
     mode?: GaugeLightTriggerMode;
     /** Value stream used by threshold evaluation. Defaults to the requested target value. */

package/dist/gaugeit.esm.js

@@ -1,4 +1,4 @@
-/*! Gaugeit.js v0.1.0 | MIT License | https://github.com/kasperikoski/gaugeit.js#readme */
+/*! Gaugeit.js v0.1.1 | MIT License | https://github.com/kasperikoski/gaugeit.js#readme */
 
 // src/core/utils.js
 function isPlainObject(value) {
@@ -838,7 +838,13 @@ function includeLight(bounds, options) {
   if (!(light == null ? void 0 : light.visible)) return;
   const point = resolveLightPosition(light, options);
   const radius = Math.max(1, finiteNumber(light.radius, 8));
-  const halo = light.glow ? radius * 2.96 : radius;
+  const glowRadius = Math.max(0, finiteNumber(light.glowRadius, radius * 1.82));
+  const flickerGlowRadius = light.flicker ? Math.min(1, Math.max(0, finiteNumber(light.flickerGlowRadius, 0))) : 0;
+  const maximumGlowRadius = glowRadius * (1 + flickerGlowRadius);
+  const glowSharpness = Math.min(1, Math.max(0, finiteNumber(light.glowSharpness, 0)));
+  const maximumBlur = glowRadius > 0 ? Math.max(1.4, glowRadius * 0.38) : 0;
+  const glowBlur = maximumBlur * (1 - glowSharpness);
+  const halo = light.glow ? maximumGlowRadius + glowBlur * 3 + (maximumGlowRadius > 0 ? 1e-9 : 0) : radius;
   const bezel = radius + Math.max(1.5, radius * 0.18);
   const extent = Math.max(halo, bezel);
   includeRect(bounds, point.x - extent, point.y - extent, extent * 2, extent * 2);
@@ -1284,28 +1290,36 @@ var BASE_DEFAULTS = Object.freeze({
   },
   light: {
     visible: false,
-    x: 160,
+    x: 93,
     y: 110,
     radius: 8,
-    color: "amber",
+    glowRadius: 20,
+    glowSharpness: 0,
+    color: "red",
     customColor: "",
     offColor: "#f3ead6",
     offEdgeColor: "#817768",
     bezelColor: "#4b5563",
     bezelHighlightColor: "#f8fafc",
     opacity: 1,
+    glowOpacity: 0.15,
     on: false,
     glow: true,
-    pulse: true,
+    pulse: false,
     pulseInterval: 2600,
     blink: false,
     blinkInterval: 1e3,
+    flicker: true,
+    flickerIntensity: 0.1,
+    flickerGlowRadius: 0.1,
+    flickerMinInterval: 45,
+    flickerMaxInterval: 140,
     trigger: {
-      mode: "manual",
+      mode: "below",
       source: "target",
-      value: 0,
+      value: 15,
       min: 0,
-      max: 0
+      max: 15
     }
   },
   readout: {
@@ -1608,27 +1622,63 @@ function validateTape(tape) {
   tape.colorByZone = tape.colorByZone === true;
 }
 function validateLight(light) {
+  const defaults2 = BASE_DEFAULTS.light;
   light.visible = light.visible === true;
-  light.x = finiteNumber(light.x, 160);
-  light.y = finiteNumber(light.y, 110);
-  light.radius = Math.max(1, finiteNumber(light.radius, 8));
-  light.color = VALID_LIGHT_COLORS.has(light.color) ? light.color : "amber";
-  light.customColor = light.customColor === null || light.customColor === void 0 ? "" : String(light.customColor).trim();
-  light.offColor = normalizeColor(light.offColor, "#f3ead6");
-  light.offEdgeColor = normalizeColor(light.offEdgeColor, "#817768");
-  light.bezelColor = normalizeColor(light.bezelColor, "#4b5563");
-  light.bezelHighlightColor = normalizeColor(light.bezelHighlightColor, "#f8fafc");
-  light.opacity = Math.min(1, Math.max(0, finiteNumber(light.opacity, 1)));
+  light.x = finiteNumber(light.x, defaults2.x);
+  light.y = finiteNumber(light.y, defaults2.y);
+  light.radius = Math.max(1, finiteNumber(light.radius, defaults2.radius));
+  light.glowRadius = light.glowRadius === null || light.glowRadius === void 0 ? light.radius * 1.82 : Math.max(0, finiteNumber(light.glowRadius, defaults2.glowRadius));
+  light.glowSharpness = Math.min(
+    1,
+    Math.max(0, finiteNumber(light.glowSharpness, defaults2.glowSharpness))
+  );
+  light.color = VALID_LIGHT_COLORS.has(light.color) ? light.color : defaults2.color;
+  light.customColor = light.customColor === null || light.customColor === void 0 ? defaults2.customColor : String(light.customColor).trim();
+  light.offColor = normalizeColor(light.offColor, defaults2.offColor);
+  light.offEdgeColor = normalizeColor(light.offEdgeColor, defaults2.offEdgeColor);
+  light.bezelColor = normalizeColor(light.bezelColor, defaults2.bezelColor);
+  light.bezelHighlightColor = normalizeColor(
+    light.bezelHighlightColor,
+    defaults2.bezelHighlightColor
+  );
+  light.opacity = Math.min(1, Math.max(0, finiteNumber(light.opacity, defaults2.opacity)));
+  light.glowOpacity = Math.min(
+    1,
+    Math.max(0, finiteNumber(light.glowOpacity, defaults2.glowOpacity))
+  );
   light.on = light.on === true;
   light.glow = light.glow !== false;
-  light.pulse = light.pulse !== false;
-  light.pulseInterval = Math.max(400, finiteNumber(light.pulseInterval, 2600));
+  light.pulse = light.pulse === true;
+  light.pulseInterval = Math.max(400, finiteNumber(light.pulseInterval, defaults2.pulseInterval));
   light.blink = light.blink === true;
-  light.blinkInterval = Math.max(100, finiteNumber(light.blinkInterval, 1e3));
+  light.blinkInterval = Math.max(100, finiteNumber(light.blinkInterval, defaults2.blinkInterval));
+  light.flicker = light.flicker === true;
+  light.flickerIntensity = Math.min(
+    1,
+    Math.max(0, finiteNumber(light.flickerIntensity, defaults2.flickerIntensity))
+  );
+  light.flickerGlowRadius = Math.min(
+    1,
+    Math.max(0, finiteNumber(light.flickerGlowRadius, defaults2.flickerGlowRadius))
+  );
+  light.flickerMinInterval = Math.max(
+    16,
+    finiteNumber(light.flickerMinInterval, defaults2.flickerMinInterval)
+  );
+  light.flickerMaxInterval = Math.max(
+    16,
+    finiteNumber(light.flickerMaxInterval, defaults2.flickerMaxInterval)
+  );
+  if (light.flickerMaxInterval < light.flickerMinInterval) {
+    [light.flickerMinInterval, light.flickerMaxInterval] = [
+      light.flickerMaxInterval,
+      light.flickerMinInterval
+    ];
+  }
   light.trigger = isPlainObject(light.trigger) ? light.trigger : {};
-  light.trigger.mode = VALID_LIGHT_TRIGGER_MODES.has(light.trigger.mode) ? light.trigger.mode : "manual";
-  light.trigger.source = VALID_LIGHT_TRIGGER_SOURCES.has(light.trigger.source) ? light.trigger.source : "target";
-  light.trigger.value = finiteNumber(light.trigger.value, 0);
+  light.trigger.mode = VALID_LIGHT_TRIGGER_MODES.has(light.trigger.mode) ? light.trigger.mode : defaults2.trigger.mode;
+  light.trigger.source = VALID_LIGHT_TRIGGER_SOURCES.has(light.trigger.source) ? light.trigger.source : defaults2.trigger.source;
+  light.trigger.value = finiteNumber(light.trigger.value, defaults2.trigger.value);
   light.trigger.min = finiteNumber(light.trigger.min, light.trigger.value);
   light.trigger.max = finiteNumber(light.trigger.max, light.trigger.value);
   if (light.trigger.max < light.trigger.min) {
@@ -2749,17 +2799,17 @@ var lightLayer = {
     if (!(light == null ? void 0 : light.visible)) return null;
     const { x, y } = resolveLightPosition(light, options);
     const palette = resolvePalette(light);
-    const colorName = Object.prototype.hasOwnProperty.call(LIGHT_PALETTES, light.color) ? light.color : "amber";
+    const colorName = Object.prototype.hasOwnProperty.call(LIGHT_PALETTES, light.color) ? light.color : "red";
     const glowFilterId = `${renderer.id}-light-glow`;
     const onGradientId = `${renderer.id}-light-on`;
     const offGradientId = `${renderer.id}-light-off`;
     const bezelGradientId = `${renderer.id}-light-bezel`;
     const defs = svgElement("defs");
     defs.append(
-      createGlowFilter(glowFilterId, light.radius),
+      createGlowFilter(glowFilterId, light.glowRadius, light.glowSharpness),
       createBulbGradient(onGradientId, {
-        center: "#ffffff",
-        highlight: palette.highlight,
+        center: palette.highlight,
+        highlight: palette.core,
         middle: palette.core,
         edge: palette.rim
       }),
@@ -2782,6 +2832,8 @@ var lightLayer = {
     lamp.style.setProperty("--gaugeit-light-blink-duration", `${light.blinkInterval}ms`);
     lamp.style.setProperty("--gaugeit-light-pulse-duration", `${light.pulseInterval}ms`);
     lamp.style.setProperty("--gaugeit-light-opacity", String(light.opacity));
+    lamp.style.setProperty("--gaugeit-light-on-opacity", String(light.opacity));
+    lamp.style.setProperty("--gaugeit-light-glow-opacity", String(light.glowOpacity));
     const bezel = svgElement("circle", {
       class: "gaugeit__light-bezel",
       cx: 0,
@@ -2804,9 +2856,7 @@ var lightLayer = {
       radius: light.radius,
       gradientId: offGradientId,
       edgeColor: light.offEdgeColor,
-      glowColor: null,
-      glowFilterId: null,
-      sparkleOpacity: 0.58,
+      sparkleOpacity: 0.24,
       shadeOpacity: 0.14
     });
     const onVisual = createLampVisual({
@@ -2814,13 +2864,18 @@ var lightLayer = {
       radius: light.radius,
       gradientId: onGradientId,
       edgeColor: palette.rim,
-      glowColor: palette.glow,
-      glowFilterId,
-      sparkleOpacity: 0.72,
+      sparkleOpacity: 0.26,
       shadeOpacity: 0.1
     });
-    lamp.append(bezel, bezelHighlight, offVisual, onVisual);
+    const glowVisual = createGlowVisual({
+      radius: light.glowRadius,
+      color: palette.glow,
+      filterId: glowFilterId
+    });
+    lamp.append(glowVisual, bezel, bezelHighlight, offVisual, onVisual);
     group.append(lamp);
+    const glowElement = glowVisual.querySelector(".gaugeit__light-glow");
+    let flickerTimer = null;
     return {
       update(value, state = {}) {
         var _a;
@@ -2828,13 +2883,54 @@ var lightLayer = {
         const active = lightIsActive(light, sample);
         const blinking = active && light.blink;
         const pulsing = active && light.pulse && !blinking;
+        const flickering = active && light.flicker && (light.flickerIntensity > 0 || light.flickerGlowRadius > 0) && !prefersReducedMotion();
         lamp.classList.toggle("is-on", active);
         lamp.classList.toggle("is-blinking", blinking);
         lamp.classList.toggle("is-pulsing", pulsing);
+        lamp.classList.toggle("is-flickering", flickering);
         lamp.classList.toggle("has-glow", light.glow);
         lamp.setAttribute("data-gaugeit-light-state", active ? "on" : "off");
+        setFlickerRunning(flickering);
+      },
+      destroy() {
+        stopFlicker();
       }
     };
+    function setFlickerRunning(enabled) {
+      if (!enabled) {
+        stopFlicker();
+        return;
+      }
+      if (flickerTimer !== null) return;
+      updateFlicker();
+      scheduleFlicker();
+    }
+    function scheduleFlicker() {
+      const delay = randomBetween(light.flickerMinInterval, light.flickerMaxInterval);
+      flickerTimer = setTimeout(() => {
+        flickerTimer = null;
+        updateFlicker();
+        scheduleFlicker();
+      }, delay);
+    }
+    function updateFlicker() {
+      const lightLevel = 1 - Math.random() * light.flickerIntensity;
+      const onOpacity = light.opacity * lightLevel;
+      const glowOpacity = light.glowOpacity * lightLevel;
+      lamp.style.setProperty("--gaugeit-light-on-opacity", onOpacity.toFixed(3));
+      lamp.style.setProperty("--gaugeit-light-glow-opacity", glowOpacity.toFixed(3));
+      if (glowElement) {
+        const variation = randomBetween(-light.flickerGlowRadius, light.flickerGlowRadius);
+        glowElement.setAttribute("r", String(light.glowRadius * (1 + variation)));
+      }
+    }
+    function stopFlicker() {
+      if (flickerTimer !== null) clearTimeout(flickerTimer);
+      flickerTimer = null;
+      lamp.style.setProperty("--gaugeit-light-on-opacity", String(light.opacity));
+      lamp.style.setProperty("--gaugeit-light-glow-opacity", String(light.glowOpacity));
+      if (glowElement) glowElement.setAttribute("r", String(light.glowRadius));
+    }
   }
 };
 function createLampVisual({
@@ -2842,8 +2938,6 @@ function createLampVisual({
   radius,
   gradientId,
   edgeColor,
-  glowColor,
-  glowFilterId,
   sparkleOpacity,
   shadeOpacity
 }) {
@@ -2851,16 +2945,6 @@ function createLampVisual({
     class: `gaugeit__light-emission gaugeit__light-emission--${state}`,
     "data-gaugeit-light-visual": state
   });
-  if (glowColor && glowFilterId) {
-    visual.append(svgElement("circle", {
-      class: "gaugeit__light-glow",
-      cx: 0,
-      cy: 0,
-      r: radius * 1.82,
-      fill: glowColor,
-      filter: `url(#${glowFilterId})`
-    }));
-  }
   visual.append(
     svgElement("circle", {
       class: `gaugeit__light-bulb gaugeit__light-bulb--${state}`,
@@ -2889,18 +2973,33 @@ function createLampVisual({
   );
   return visual;
 }
+function createGlowVisual({ radius, color, filterId }) {
+  const visual = svgElement("g", {
+    class: "gaugeit__light-glow-emission",
+    "data-gaugeit-light-visual": "glow"
+  });
+  visual.append(svgElement("circle", {
+    class: "gaugeit__light-glow",
+    cx: 0,
+    cy: 0,
+    r: radius,
+    fill: color,
+    filter: `url(#${filterId})`
+  }));
+  return visual;
+}
 function resolvePalette(light) {
-  const named = LIGHT_PALETTES[light.color] || LIGHT_PALETTES.amber;
+  const named = LIGHT_PALETTES[light.color] || LIGHT_PALETTES.red;
   const custom = String(light.customColor || "").trim();
   if (!custom) return named;
   return {
     core: custom,
-    highlight: "#ffffff",
+    highlight: custom,
     glow: custom,
     rim: custom
   };
 }
-function createGlowFilter(id, radius) {
+function createGlowFilter(id, glowRadius, sharpness) {
   const filter = svgElement("filter", {
     id,
     x: "-120%",
@@ -2908,11 +3007,18 @@ function createGlowFilter(id, radius) {
     width: "340%",
     height: "340%"
   });
+  const maximumBlur = Math.max(1.4, glowRadius * 0.38);
   filter.append(svgElement("feGaussianBlur", {
-    stdDeviation: Math.max(1.4, radius * 0.38)
+    stdDeviation: maximumBlur * (1 - sharpness)
   }));
   return filter;
 }
+function randomBetween(min, max) {
+  return min + Math.random() * (max - min);
+}
+function prefersReducedMotion() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
 function createBulbGradient(id, colors) {
   const gradient = svgElement("radialGradient", {
     id,
@@ -3000,13 +3106,6 @@ var arcGaugeType = {
       width: 8,
       cap: { radius: 7, stackOrder: "above" }
     },
-    light: {
-      visible: false,
-      x: 160,
-      y: 142,
-      radius: 7,
-      color: "amber"
-    },
     readout: {
       title: { visible: false, x: "auto", y: 35 },
       value: { visible: false, x: 160, y: 130, fontSize: 30 },
@@ -3095,13 +3194,6 @@ var classicGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 112,
-      y: 112,
-      radius: 8,
-      color: "amber"
-    },
     readout: {
       title: {
         visible: true,
@@ -3193,13 +3285,6 @@ var lineScaleGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 160,
-      y: 151,
-      radius: 7,
-      color: "amber"
-    },
     readout: {
       title: { visible: false, x: "auto", y: 140 },
       value: { visible: false, x: 160, y: 220, fontSize: 33 },
@@ -3286,16 +3371,6 @@ var heritageRoundGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 108,
-      y: 110,
-      radius: 10,
-      color: "amber",
-      blink: false,
-      blinkInterval: 1e3,
-      trigger: { mode: "below", source: "target", value: 15, min: 0, max: 15 }
-    },
     readout: {
       title: {
         visible: true,
@@ -3826,13 +3901,6 @@ var classicLinearDefaults = {
       strokeWidth: 1.2
     }
   },
-  light: {
-    visible: false,
-    x: 72,
-    y: 60,
-    radius: 8,
-    color: "amber"
-  },
   readout: {
     title: {
       visible: true,
@@ -4067,13 +4135,6 @@ var centerZeroGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 112,
-      y: 205,
-      radius: 8,
-      color: "amber"
-    },
     readout: {
       title: {
         visible: true,
@@ -4423,13 +4484,6 @@ var rollingTapeGaugeType = {
       { min: 20, max: 80, color: "transparent" },
       { min: 80, max: 100, color: "#15803d" }
     ],
-    light: {
-      visible: false,
-      x: 72,
-      y: 46,
-      radius: 8,
-      color: "amber"
-    },
     readout: {
       title: {
         visible: true,
@@ -4644,7 +4698,7 @@ var geometry = Object.freeze({
   resolveLightPosition
 });
 var types = builtInTypes;
-var VERSION = "0.1.0";
+var VERSION = "0.1.1";
 var Gaugeit = Object.freeze({
   VERSION,
   Gauge,