@5even7/dlc-ui 0.2.0 → 0.2.2

package/dist/color.cjs

@@ -405,9 +405,212 @@ var DEFAULTS = {
     renderer: 'auto',
     respectReducedMotion: true}};
 
-function hexToRgb01(hex) {
-  var normalized = hex.replace('#', '');
-  var value = Number.parseInt(normalized, 16);
+/**
+ * Color helpers. `normalizeColor` converts any supported CSS color
+ * (hex / named / rgb() / rgba()) into a 6-digit hex string, so renderers can
+ * keep working with #rrggbb only. rgba() alpha is intentionally dropped:
+ * the WebGL shader has no per-color alpha channel, and the component is
+ * opaque by design — use component-level `opacity` for transparency.
+ */
+
+var NAMED_COLORS = {
+  aliceblue: '#f0f8ff',
+  antiquewhite: '#faebd7',
+  aqua: '#00ffff',
+  aquamarine: '#7fffd4',
+  azure: '#f0ffff',
+  beige: '#f5f5dc',
+  bisque: '#ffe4c4',
+  black: '#000000',
+  blanchedalmond: '#ffebcd',
+  blue: '#0000ff',
+  blueviolet: '#8a2be2',
+  brown: '#a52a2a',
+  burlywood: '#deb887',
+  cadetblue: '#5f9ea0',
+  chartreuse: '#7fff00',
+  chocolate: '#d2691e',
+  coral: '#ff7f50',
+  cornflowerblue: '#6495ed',
+  cornsilk: '#fff8dc',
+  crimson: '#dc143c',
+  cyan: '#00ffff',
+  darkblue: '#00008b',
+  darkcyan: '#008b8b',
+  darkgoldenrod: '#b8860b',
+  darkgray: '#a9a9a9',
+  darkgreen: '#006400',
+  darkgrey: '#a9a9a9',
+  darkkhaki: '#bdb76b',
+  darkmagenta: '#8b008b',
+  darkolivegreen: '#556b2f',
+  darkorange: '#ff8c00',
+  darkorchid: '#9932cc',
+  darkred: '#8b0000',
+  darksalmon: '#e9967a',
+  darkseagreen: '#8fbc8f',
+  darkslateblue: '#483d8b',
+  darkslategray: '#2f4f4f',
+  darkslategrey: '#2f4f4f',
+  darkturquoise: '#00ced1',
+  darkviolet: '#9400d3',
+  deeppink: '#ff1493',
+  deepskyblue: '#00bfff',
+  dimgray: '#696969',
+  dimgrey: '#696969',
+  dodgerblue: '#1e90ff',
+  firebrick: '#b22222',
+  floralwhite: '#fffaf0',
+  forestgreen: '#228b22',
+  fuchsia: '#ff00ff',
+  gainsboro: '#dcdcdc',
+  ghostwhite: '#f8f8ff',
+  gold: '#ffd700',
+  goldenrod: '#daa520',
+  gray: '#808080',
+  green: '#008000',
+  greenyellow: '#adff2f',
+  grey: '#808080',
+  honeydew: '#f0fff0',
+  hotpink: '#ff69b4',
+  indianred: '#cd5c5c',
+  indigo: '#4b0082',
+  ivory: '#fffff0',
+  khaki: '#f0e68c',
+  lavender: '#e6e6fa',
+  lavenderblush: '#fff0f5',
+  lawngreen: '#7cfc00',
+  lemonchiffon: '#fffacd',
+  lightblue: '#add8e6',
+  lightcoral: '#f08080',
+  lightcyan: '#e0ffff',
+  lightgoldenrodyellow: '#fafad2',
+  lightgray: '#d3d3d3',
+  lightgreen: '#90ee90',
+  lightgrey: '#d3d3d3',
+  lightpink: '#ffb6c1',
+  lightsalmon: '#ffa07a',
+  lightseagreen: '#20b2aa',
+  lightskyblue: '#87cefa',
+  lightslategray: '#778899',
+  lightslategrey: '#778899',
+  lightsteelblue: '#b0c4de',
+  lightyellow: '#ffffe0',
+  lime: '#00ff00',
+  limegreen: '#32cd32',
+  linen: '#faf0e6',
+  magenta: '#ff00ff',
+  maroon: '#800000',
+  mediumaquamarine: '#66cdaa',
+  mediumblue: '#0000cd',
+  mediumorchid: '#ba55d3',
+  mediumpurple: '#9370db',
+  mediumseagreen: '#3cb371',
+  mediumslateblue: '#7b68ee',
+  mediumspringgreen: '#00fa9a',
+  mediumturquoise: '#48d1cc',
+  mediumvioletred: '#c71585',
+  midnightblue: '#191970',
+  mintcream: '#f5fffa',
+  mistyrose: '#ffe4e1',
+  moccasin: '#ffe4b5',
+  navajowhite: '#ffdead',
+  navy: '#000080',
+  oldlace: '#fdf5e6',
+  olive: '#808000',
+  olivedrab: '#6b8e23',
+  orange: '#ffa500',
+  orangered: '#ff4500',
+  orchid: '#da70d6',
+  palegoldenrod: '#eee8aa',
+  palegreen: '#98fb98',
+  paleturquoise: '#afeeee',
+  palevioletred: '#db7093',
+  papayawhip: '#ffefd5',
+  peachpuff: '#ffdab9',
+  peru: '#cd853f',
+  pink: '#ffc0cb',
+  plum: '#dda0dd',
+  powderblue: '#b0e0e6',
+  purple: '#800080',
+  rebeccapurple: '#663399',
+  red: '#ff0000',
+  rosybrown: '#bc8f8f',
+  royalblue: '#4169e1',
+  saddlebrown: '#8b4513',
+  salmon: '#fa8072',
+  sandybrown: '#f4a460',
+  seagreen: '#2e8b57',
+  seashell: '#fff5ee',
+  sienna: '#a0522d',
+  silver: '#c0c0c0',
+  skyblue: '#87ceeb',
+  slateblue: '#6a5acd',
+  slategray: '#708090',
+  slategrey: '#708090',
+  snow: '#fffafa',
+  springgreen: '#00ff7f',
+  steelblue: '#4682b4',
+  tan: '#d2b48c',
+  teal: '#008080',
+  thistle: '#d8bfd8',
+  tomato: '#ff6347',
+  turquoise: '#40e0d0',
+  violet: '#ee82ee',
+  wheat: '#f5deb3',
+  white: '#ffffff',
+  whitesmoke: '#f5f5f5',
+  yellow: '#ffff00',
+  yellowgreen: '#9acd32'
+};
+function clampChannel(value) {
+  return Math.min(255, Math.max(0, Math.round(value)));
+}
+function normalizeRgbArgs(args) {
+  var parts = args.split(/[,\s/]+/).filter(Boolean);
+  if (parts.length < 3) return null;
+  var to255 = function to255(value) {
+    if (typeof value !== 'string' || !value) return null;
+    if (value.endsWith('%')) return clampChannel(parseFloat(value) / 100 * 255);
+    var number = Number(value);
+    return Number.isFinite(number) ? clampChannel(number) : null;
+  };
+  var red = to255(parts[0]);
+  var green = to255(parts[1]);
+  var blue = to255(parts[2]);
+  if (red === null || green === null || blue === null) return null;
+  return "#".concat([red, green, blue].map(function (n) {
+    return n.toString(16).padStart(2, '0');
+  }).join(''));
+}
+
+/**
+ * Convert any supported CSS color into `#rrggbb`. Returns null when the
+ * value cannot be parsed. Supports: #rgb / #rrggbb (case-insensitive),
+ * CSS named colors, rgb() / rgba() with comma or modern space syntax,
+ * including percentages. Alpha in rgba() is ignored.
+ */
+function normalizeColor(value) {
+  if (typeof value !== 'string') return null;
+  var input = value.trim();
+  if (!input) return null;
+  var lower = input.toLowerCase();
+  if (NAMED_COLORS[lower]) return NAMED_COLORS[lower];
+  if (/^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(input)) {
+    var hex = input.slice(1).toLowerCase();
+    if (hex.length === 3) return "#".concat(hex.split('').map(function (c) {
+      return c + c;
+    }).join(''));
+    return "#".concat(hex);
+  }
+  var match = input.match(/^rgba?\((.*)\)$/i);
+  if (match) return normalizeRgbArgs(match[1]);
+  return null;
+}
+function hexToRgb01(color) {
+  var hex = normalizeColor(color);
+  if (!hex) return [0, 0, 0];
+  var value = Number.parseInt(hex.slice(1), 16);
   return [(value >> 16 & 255) / 255, (value >> 8 & 255) / 255, (value & 255) / 255];
 }
 
@@ -485,6 +688,26 @@ var CosmicRenderer = /*#__PURE__*/function () {
       this.options.dprCap = cap;
       this.resize();
     }
+  }, {
+    key: "setMouseColor",
+    value: function setMouseColor(enabled) {
+      this.options.mouseColor = enabled !== false;
+      if (this.options.mouseColor) {
+        if (this.onPointerMove) return this;
+        _assertClassBrand(_CosmicRenderer_brand, this, _bindEvents).call(this);
+        return this;
+      }
+      if (this.onPointerMove) {
+        var target = this.eventTarget;
+        target.removeEventListener('pointermove', this.onPointerMove);
+        target.removeEventListener('pointerdown', this.onPointerMove);
+        target.removeEventListener('pointerleave', this.onPointerLeave);
+        this.onPointerMove = null;
+        this.onPointerLeave = null;
+      }
+      this.motionTarget = 0;
+      return this;
+    }
   }, {
     key: "randomize",
     value: function randomize() {
@@ -633,6 +856,8 @@ var FallbackRenderer = /*#__PURE__*/function () {
       var _this$canvas = this.canvas,
         width = _this$canvas.width,
         height = _this$canvas.height;
+      var t = time * (this.preset.speed || 1);
+      var phase = (this.preset.seed || 0) * 0.7;
       var gradient = ctx.createLinearGradient(0, 0, width, height);
       gradient.addColorStop(0, this.preset.colors[0]);
       gradient.addColorStop(0.38, this.preset.colors[1]);
@@ -642,8 +867,8 @@ var FallbackRenderer = /*#__PURE__*/function () {
       ctx.fillRect(0, 0, width, height);
       ctx.globalCompositeOperation = 'screen';
       for (var index = 0; index < 6; index += 1) {
-        var x = (0.5 + 0.45 * Math.sin(time * 0.32 + index * 1.7)) * width;
-        var y = (0.5 + 0.4 * Math.cos(time * 0.25 + index)) * height;
+        var x = (0.5 + 0.45 * Math.sin(t * 0.32 + index * 1.7 + phase)) * width;
+        var y = (0.5 + 0.4 * Math.cos(t * 0.25 + index + phase)) * height;
         var radius = Math.max(width, height) * (0.08 + index % 3 * 0.04);
         var glow = ctx.createRadialGradient(x, y, 0, x, y, radius);
         glow.addColorStop(0, rgb(this.preset.colors[(index + 1) % 4], 0.24));
@@ -667,7 +892,12 @@ var FallbackRenderer = /*#__PURE__*/function () {
     }
   }, {
     key: "randomize",
-    value: function randomize() {}
+    value: function randomize() {
+      if (this.preset) this.preset.seed = Math.random() * 100;
+    }
+  }, {
+    key: "setMouseColor",
+    value: function setMouseColor() {}
   }, {
     key: "dispose",
     value: function dispose() {}
@@ -778,6 +1008,22 @@ function createVisibilityGuard(element) {
   };
 }
 
+/**
+ * Run a callback asynchronously, right after the current task and before the
+ * next paint. Used for mount-time events (ready / error) so listeners that
+ * are attached after create() still receive them. Falls back for legacy
+ * browsers that lack queueMicrotask / Promise.
+ */
+function nextTick(fn) {
+  if (typeof queueMicrotask === 'function') {
+    queueMicrotask(fn);
+  } else if (typeof Promise !== 'undefined' && typeof Promise.resolve === 'function') {
+    Promise.resolve().then(fn);
+  } else {
+    setTimeout(fn, 0);
+  }
+}
+
 function prefersReducedMotion() {
   return typeof matchMedia !== 'undefined' && matchMedia('(prefers-reduced-motion: reduce)').matches;
 }
@@ -810,6 +1056,10 @@ function createColorBackground(host) {
     opacity: 1,
     fallbackColor: true
   }, preset, options);
+  var normalizedColors = merged.colors.map(normalizeColor);
+  if (normalizedColors.every(Boolean)) preset.colors = normalizedColors;
+  preset.seed = merged.seed;
+  preset.speed = merged.speed;
   var computed = getComputedStyle(host);
   if (computed.position === 'static' || computed.position === '') {
     host.style.position = 'relative';
@@ -830,6 +1080,16 @@ function createColorBackground(host) {
   host.appendChild(layer);
   var emitter = createEmitter();
   var paused = merged.respectReducedMotion && prefersReducedMotion();
+  var disposed = false;
+  var dirty = {
+    preset: false,
+    seed: false,
+    speed: false,
+    colors: false,
+    opacity: false,
+    fallbackColor: false,
+    mouseColor: false
+  };
   var renderer;
   var useWebgl = merged.renderer !== 'canvas2d';
   if (useWebgl) {
@@ -841,8 +1101,11 @@ function createColorBackground(host) {
       });
     } catch (error) {
       renderer = new FallbackRenderer(canvas, merged);
-      emitter.emit('error', {
-        message: String(error && error.message ? error.message : error)
+      nextTick(function () {
+        if (disposed) return;
+        emitter.emit('error', {
+          message: String(error && error.message ? error.message : error)
+        });
       });
     }
   } else {
@@ -860,8 +1123,11 @@ function createColorBackground(host) {
   }, function () {
     return paused;
   });
-  emitter.emit('ready', {
-    preset: _objectSpread2({}, preset)
+  nextTick(function () {
+    if (disposed) return;
+    emitter.emit('ready', {
+      preset: _objectSpread2({}, preset)
+    });
   });
   return {
     element: host,
@@ -872,24 +1138,59 @@ function createColorBackground(host) {
     off: emitter.off,
     setPreset: function setPreset(ref) {
       var next = getPreset('capsule', ref);
+      dirty.preset = true;
       Object.assign(preset, next);
-      renderer.setPreset(next);
+      var nextColors = preset.colors.map(normalizeColor);
+      if (nextColors.every(Boolean)) preset.colors = nextColors;
+      renderer.setPreset(_objectSpread2({}, preset));
       renderer.resize();
       syncLayerVars();
       emitter.emit('presetchange', {
-        preset: _objectSpread2({}, next)
+        preset: _objectSpread2({}, preset)
       });
       return this;
     },
     setColors: function setColors(colors) {
-      if (!Array.isArray(colors) || colors.length !== 4) return this;
-      preset.colors = colors;
+      var next = Array.isArray(colors) ? colors.map(normalizeColor) : [];
+      if (next.length !== 4 || next.some(function (color) {
+        return !color;
+      })) return this;
+      dirty.colors = true;
+      preset.colors = next;
       renderer.setPreset(_objectSpread2(_objectSpread2({}, preset), {}, {
-        colors: colors
+        colors: next
       }));
       syncLayerVars();
       return this;
     },
+    setSeed: function setSeed(seed) {
+      var value = Number(seed);
+      if (!Number.isFinite(value)) return this;
+      dirty.seed = true;
+      preset.seed = value;
+      renderer.setPreset(_objectSpread2({}, preset));
+      return this;
+    },
+    setSpeed: function setSpeed(speed) {
+      var value = Number(speed);
+      if (!Number.isFinite(value)) return this;
+      dirty.speed = true;
+      preset.speed = value;
+      renderer.setPreset(_objectSpread2({}, preset));
+      return this;
+    },
+    setFallbackColor: function setFallbackColor(value) {
+      dirty.fallbackColor = true;
+      merged.fallbackColor = value;
+      syncLayerVars();
+      return this;
+    },
+    setMouseColor: function setMouseColor(value) {
+      dirty.mouseColor = true;
+      merged.mouseColor = value !== false;
+      if (typeof renderer.setMouseColor === 'function') renderer.setMouseColor(merged.mouseColor);
+      return this;
+    },
     setQuality: function setQuality(quality) {
       merged.quality = quality;
       if (typeof renderer.setDprCap === 'function') renderer.setDprCap(dprCapFor(quality));
@@ -898,12 +1199,13 @@ function createColorBackground(host) {
     setOpacity: function setOpacity(value) {
       var opacity = Number(value);
       if (!Number.isFinite(opacity)) return this;
+      dirty.opacity = true;
       merged.opacity = Math.min(1, Math.max(0, opacity));
       layer.style.setProperty('--dlc-color-opacity', String(merged.opacity));
       return this;
     },
     randomize: function randomize() {
-      renderer.randomize();
+      this.setSeed(Math.random() * 100);
       return this;
     },
     pause: function pause() {
@@ -915,12 +1217,17 @@ function createColorBackground(host) {
       return this;
     },
     dispose: function dispose() {
+      disposed = true;
       unsubscribe();
       visibility.dispose();
       if (resizeObserver) resizeObserver.disconnect();else window.removeEventListener('resize', renderer.resize);
       renderer.dispose();
       layer.remove();
-    }
+    },
+    opacity: merged.opacity,
+    fallbackColor: merged.fallbackColor,
+    mouseColor: merged.mouseColor,
+    dirty: dirty
   };
 }