gaugeit.js 0.1.0 → 0.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 Gaugeit.js is a lightweight, dependency-free, extensible analog gauge library built with native SVG, JavaScript, and a small optional CSS file.
 
-The first release includes eight gauge types:
+Gaugeit.js includes eight gauge types:
 
 - `arc`: a clean semicircular gauge with configurable colored or transparent sectors;
 - `classic`: a framed, white, old-style instrument meter;
@@ -15,10 +15,7 @@ The first release includes eight gauge types:
 
 The runtime has no image, jQuery, canvas, or framework dependency. It can be used from a classic `<script>` tag, an ES module, a custom element, React, Twig, Blade, or another server-rendered application.
 
-> **Current release:** `0.1.0`
->
-> Source code, prebuilt distributions, documentation, examples, and package
-> metadata are maintained in this repository.
+> **Current release:** `0.1.1`
 
 ## Why SVG
 
@@ -97,7 +94,7 @@ The standalone and separate-file builds are generated from the same canonical
 ## npm installation
 
 ```bash
-npm install gaugeit.js@0.1.0
+npm install gaugeit.js@0.1.1
 ```
 
 ```js
@@ -126,10 +123,10 @@ Use exact versions in production. CDN consumers need no installation or compilat
 ```html
 <link
   rel="stylesheet"
-  href="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.0/dist/gaugeit.min.css"
+  href="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.1/dist/gaugeit.min.css"
 >
 <script
-  src="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.0/dist/gaugeit.umd.min.js"
+  src="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.1/dist/gaugeit.umd.min.js"
 ></script>
 ```
 
@@ -137,7 +134,7 @@ Use exact versions in production. CDN consumers need no installation or compilat
 
 ```html
 <script
-  src="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.0/dist/gaugeit.standalone.min.js"
+  src="https://cdn.jsdelivr.net/npm/gaugeit.js@0.1.1/dist/gaugeit.standalone.min.js"
 ></script>
 ```
 
@@ -146,15 +143,15 @@ Use exact versions in production. CDN consumers need no installation or compilat
 ```html
 <link
   rel="stylesheet"
-  href="https://unpkg.com/gaugeit.js@0.1.0/dist/gaugeit.min.css"
+  href="https://unpkg.com/gaugeit.js@0.1.1/dist/gaugeit.min.css"
 >
 <script
-  src="https://unpkg.com/gaugeit.js@0.1.0/dist/gaugeit.umd.min.js"
+  src="https://unpkg.com/gaugeit.js@0.1.1/dist/gaugeit.umd.min.js"
 ></script>
 ```
 
 The UNPKG one-file equivalent is
-`https://unpkg.com/gaugeit.js@0.1.0/dist/gaugeit.standalone.min.js`.
+`https://unpkg.com/gaugeit.js@0.1.1/dist/gaugeit.standalone.min.js`.
 
 ## Built-in gauge gallery
 
@@ -466,14 +463,22 @@ createGauge('#fuel', {
   value: 12,
   light: {
     visible: true,
-    x: 108,
+    x: 93,
     y: 110,
-    radius: 10,
-    color: 'amber',
+    radius: 8,
+    glowRadius: 20,
+    glowSharpness: 0,
+    glowOpacity: 0.15,
+    color: 'red',
     offColor: '#f3ead6',
-    pulse: true,
-    blink: true,
+    pulse: false,
+    blink: false,
     blinkInterval: 1000,
+    flicker: true,
+    flickerIntensity: 0.1,
+    flickerGlowRadius: 0.1,
+    flickerMinInterval: 45,
+    flickerMaxInterval: 140,
     trigger: { mode: 'below', source: 'target', value: 15 }
   }
 });
@@ -483,18 +488,39 @@ Built-in palettes are `red`, `green`, `blue`, `amber`, `yellow`, `orange`,
 `white`, `halogen`, `cyan`, and `brown`. Use `customColor` for an application-specific
 active color. The unlit lamp deliberately uses a softly diffused cream lens rather than
 a black bulb; `offColor`, `offEdgeColor`, `bezelColor`, and `bezelHighlightColor` can
-customize that hardware appearance. `pulse` adds a deliberately subtle steady-light
+customize that hardware appearance. `radius` controls the physical lamp while
+`glowRadius` controls the halo independently and defaults to `20`. Set it to `null` to
+derive the halo radius from `radius * 1.82`. `glowSharpness` controls the halo blur:
+`0` uses a soft Gaussian glow, while `1` removes blur for a completely sharp
+edge. Intermediate values reduce the blur continuously. `glowOpacity` controls only the
+halo and defaults to `0.15`, independently from the illuminated lens `opacity`.
+The halo is painted below the opaque lamp hardware, so it becomes visible beyond the
+lamp edges instead of covering the lens. `pulse` adds a deliberately subtle steady-light
 breathing effect. `blink` alternates the complete illuminated and unlit lens states, so
 the dark half-cycle looks exactly like the normal switched-off lamp rather than a faded
-transparent bulb. Trigger modes are `manual`, `below`, `above`, and `between`. The trigger source
+transparent bulb. Blink takes precedence if both blink and pulse are enabled.
+`flicker` adds rapid random changes to the amount of emitted light. `flickerIntensity`
+sets the maximum random loss from full light: `0` is steady and `1` may momentarily
+reach the real unlit-lens appearance. It never darkens the lit lens toward black.
+`flickerGlowRadius` independently varies the halo radius by a relative plus/minus amount:
+with `glowRadius: 20`, the default `0.1` produces radii between 18 and 22.
+Each change waits a random duration between `flickerMinInterval` and
+`flickerMaxInterval`. Flicker is independent and may be combined with
+either pulse or blink. Flicker is enabled by default, but has no visual effect while the
+lamp is hidden or inactive. Trigger modes are `manual`, `below`, `above`, and `between`. The trigger source
 defaults to `target`, so a low-value lamp does not flash merely because a startup
 animation begins at the minimum. Use `displayed` to follow the animated readout value
 or `pointer` to include visual jitter. For linear gauges, `light.y` follows the same
 positive-up coordinate convention as the linear axis.
 
+`opacity` controls only the illuminated lens layered over an always-opaque unlit lens.
+The physical lamp and bezel therefore remain fully visible even at `opacity: 0`;
+`glowOpacity` remains the separate control for the halo.
+
 Custom types can opt in with `Gaugeit.layers.light`; all built-in types already include
-the layer and provide a sensible type-specific fallback position while keeping
-`light.visible` false.
+the layer and use the same shared light defaults. The lamp remains disabled until
+`light.visible` is true. The interactive `example.html` explicitly enables blink and
+disables flicker for its heritage-round demonstration.
 
 ## Intrinsic dimensions and host sizing
 
@@ -875,13 +901,11 @@ Gaugeit.js/
 
 ## Release metadata
 
-Version `0.1.0` uses the npm package name `gaugeit.js`, Composer package name
-`kasperi/gaugeit-js`, and source repository
-`https://github.com/kasperikoski/gaugeit.js`. Author metadata identifies Kasperi Koski.
+Version: `0.1.1`. npm package: `gaugeit.js`. Composer package:
+`kasperi/gaugeit-js`. Repository: `https://github.com/kasperikoski/gaugeit.js`.
 
-The build and CI workflows validate release artifacts but never publish, tag, or create
-remote releases automatically. Publishing to GitHub, npm, and Packagist remains an
-explicit maintainer action.
+Build and CI workflows validate release artifacts. Publishing to GitHub, npm, and
+Packagist is a manual maintainer action.
 
 ## Contributing and security
 

package/SECURITY.md

@@ -5,8 +5,8 @@
 Security updates are provided for the latest published Gaugeit.js release.
 
 | Version | Supported |
-| --- | --- |
-| 0.1.x | Yes |
+| ------- | --------- |
+| 0.1.x   | Yes       |
 
 ## Reporting a vulnerability
 

package/dist/gaugeit.cjs

@@ -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 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -867,7 +867,13 @@ function includeLight(bounds, options) {
   if (!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);
@@ -1313,28 +1319,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: {
@@ -1637,27 +1651,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) {
@@ -2775,17 +2825,17 @@ var lightLayer = {
     if (!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
       }),
@@ -2808,6 +2858,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,
@@ -2830,9 +2882,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({
@@ -2840,26 +2890,72 @@ 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 = {}) {
         const sample = resolveTriggerSample(light.trigger?.source, value, state);
         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({
@@ -2867,8 +2963,6 @@ function createLampVisual({
   radius,
   gradientId,
   edgeColor,
-  glowColor,
-  glowFilterId,
   sparkleOpacity,
   shadeOpacity
 }) {
@@ -2876,16 +2970,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}`,
@@ -2914,18 +2998,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%",
@@ -2933,11 +3032,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,
@@ -3025,13 +3131,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 },
@@ -3120,13 +3219,6 @@ var classicGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 112,
-      y: 112,
-      radius: 8,
-      color: "amber"
-    },
     readout: {
       title: {
         visible: true,
@@ -3218,13 +3310,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 },
@@ -3311,16 +3396,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,
@@ -3849,13 +3924,6 @@ var classicLinearDefaults = {
       strokeWidth: 1.2
     }
   },
-  light: {
-    visible: false,
-    x: 72,
-    y: 60,
-    radius: 8,
-    color: "amber"
-  },
   readout: {
     title: {
       visible: true,
@@ -4088,13 +4156,6 @@ var centerZeroGaugeType = {
         strokeWidth: 2
       }
     },
-    light: {
-      visible: false,
-      x: 112,
-      y: 205,
-      radius: 8,
-      color: "amber"
-    },
     readout: {
       title: {
         visible: true,
@@ -4444,13 +4505,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,
@@ -4665,7 +4719,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,