@d3plus/color 3.0.16 → 3.1.1

package/types/src/legible.d.ts

@@ -0,0 +1,5 @@
+/**
+    Darkens a color so that it will appear legible on a white background.
+    @param c A valid CSS color string.
+*/
+export default function (c: string): string;

package/types/src/lighter.d.ts

@@ -0,0 +1,6 @@
+/**
+    Similar to d3.color.brighter, except that this also reduces saturation so that colors don't appear neon.
+    @param c A valid CSS color string.
+    @param i Strength of the lightening effect, from 0 to 1.
+*/
+export default function (c: string, i?: number): string;

package/types/src/subtract.d.ts

@@ -0,0 +1,8 @@
+/**
+    Subtracts one color from another.
+    @param c1 The base color, a valid CSS color string.
+    @param c2 The color to remove from the base color, also a valid CSS color string.
+    @param o1 Value from 0 to 1 of the first color's opacity.
+    @param o2 Value from 0 to 1 of the first color's opacity.
+*/
+export default function (c1: string, c2: string, o1?: number, o2?: number): string;

package/umd/d3plus-color.full.js

@@ -1,113 +1,9 @@
 /*
-  @d3plus/color v3.0.16
+  @d3plus/color v3.1.0
   Color functions that extent the ability of d3-color.
   Copyright (c) 2026 D3plus - https://d3plus.org
   @license MIT
 */
-
-(function (factory) {
-  typeof define === 'function' && define.amd ? define(factory) :
-  factory();
-})((function () { 'use strict';
-
-  if (typeof window !== "undefined") {
-    (function () {
-      try {
-        if (typeof SVGElement === 'undefined' || Boolean(SVGElement.prototype.innerHTML)) {
-          return;
-        }
-      } catch (e) {
-          return;
-      }
-
-      function serializeNode (node) {
-        switch (node.nodeType) {
-          case 1:
-            return serializeElementNode(node);
-          case 3:
-            return serializeTextNode(node);
-          case 8:
-            return serializeCommentNode(node);
-        }
-      }
-
-      function serializeTextNode (node) {
-          return node.textContent.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-      }
-
-      function serializeCommentNode (node) {
-          return '<!--' + node.nodeValue + '-->'
-      }
-
-      function serializeElementNode (node) {
-          var output = '';
-
-          output += '<' + node.tagName;
-
-          if (node.hasAttributes()) {
-              [].forEach.call(node.attributes, function(attrNode) {
-                  output += ' ' + attrNode.name + '="' + attrNode.value + '"';
-              });
-          }
-
-          output += '>';
-
-          if (node.hasChildNodes()) {
-              [].forEach.call(node.childNodes, function(childNode) {
-                  output += serializeNode(childNode);
-              });
-          }
-
-          output += '</' + node.tagName + '>';
-
-          return output;
-      }
-
-      Object.defineProperty(SVGElement.prototype, 'innerHTML', {
-        get: function () {
-          var output = '';
-
-          [].forEach.call(this.childNodes, function(childNode) {
-              output += serializeNode(childNode);
-          });
-
-          return output;
-        },
-        set: function (markup) {
-          while (this.firstChild) {
-            this.removeChild(this.firstChild);
-          }
-
-          try {
-            var dXML = new DOMParser();
-            dXML.async = false;
-
-            var sXML = '<svg xmlns=\'http://www.w3.org/2000/svg\' xmlns:xlink=\'http://www.w3.org/1999/xlink\'>' + markup + '</svg>';
-            var svgDocElement = dXML.parseFromString(sXML, 'text/xml').documentElement;
-
-            [].forEach.call(svgDocElement.childNodes, function(childNode) {
-                this.appendChild(this.ownerDocument.importNode(childNode, true));
-            }.bind(this));
-          } catch (e) {
-              throw new Error('Error parsing markup string');
-          }
-        }
-      });
-
-      Object.defineProperty(SVGElement.prototype, 'innerSVG', {
-        get: function () {
-          return this.innerHTML;
-        },
-        set: function (markup) {
-          this.innerHTML = markup;
-        }
-      });
-
-    })();
-  }
-
-}));
-
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define('@d3plus/color', ['exports'], factory) :
@@ -455,24 +351,20 @@
   }
 
   /**
-      @function colorAdd
-      @desc Adds two colors together.
-      @param {String} c1 The first color, a valid CSS color string.
-      @param {String} c2 The second color, also a valid CSS color string.
-      @param {String} [o1 = 1] Value from 0 to 1 of the first color's opacity.
-      @param {String} [o2 = 1] Value from 0 to 1 of the first color's opacity.
-      @returns {String}
+      Adds two colors together.
+      @param c1 The first color, a valid CSS color string.
+      @param c2 The second color, also a valid CSS color string.
+      @param o1 Value from 0 to 1 of the first color's opacity.
+      @param o2 Value from 0 to 1 of the first color's opacity.
   */ function add(c1, c2, o1 = 1, o2 = 1) {
-      c1 = hsl(c1);
-      c2 = hsl(c2);
-      let d = Math.abs(c2.h * o2 - c1.h * o1);
+      const hsl1 = hsl(c1);
+      const hsl2 = hsl(c2);
+      let d = Math.abs(hsl2.h * o2 - hsl1.h * o1);
       if (d > 180) d -= 360;
-      let h = (Math.min(c1.h, c2.h) + d / 2) % 360;
-      const l = c1.l + (c2.l * o2 - c1.l * o1) / 2, s = c1.s + (c2.s * o2 - c1.s * o1) / 2;
-      // a = o1 + (o2 - o1) / 2;
+      let h = (Math.min(hsl1.h, hsl2.h) + d / 2) % 360;
+      const l = hsl1.l + (hsl2.l * o2 - hsl1.l * o1) / 2, s = hsl1.s + (hsl2.s * o2 - hsl1.s * o1) / 2;
       if (h < 0) h += 360;
       return hsl(`hsl(${h},${s * 100}%,${l * 100}%)`).toString();
-  // return hsl(`hsl(${h},${s * 100}%,${l * 100}%,${a})`).toString();
   }
 
   class InternMap extends Map {
@@ -760,9 +652,27 @@
 
   const { theme: openColor } = pkg;
   /**
-      @namespace {Object} colorDefaults
-      @desc A set of default color values used when assigning colors based on data.
-  */ const defaults = {
+   * A set of default color values used when assigning colors based on data.
+   *
+   * @defaultValue
+   * ```
+   * {
+   *   dark: "#495057",
+   *   light: "#f8f9fa",
+   *   missing: "#ced4da",
+   *   off: "#c92a2a",
+   *   on: "#2b8a3e",
+   *   scale: d3.scaleOrdinal().range([
+   *     "#364fc7", "#fab005", "#c92a2a",
+   *     "#2b8a3e", "#fd7e14", "#862e9c",
+   *     "#15aabf", "#e64980", "#82c91e",
+   *     "#74c0fc", "#faa2c1", "#c0eb75",
+   *     "#b197fc", "#c5f6fa", "#ffe8cc",
+   *     "#d3f9d8", "#f3d9fa", "#ffe3e3"
+   *   ])
+   * }
+   * ```
+   */ const defaults = {
       dark: openColor.colors.gray[700],
       light: openColor.colors.gray[50],
       missing: openColor.colors.gray[400],
@@ -789,89 +699,74 @@
           openColor.colors.red[100]
       ])
   };
-  /**
-      Returns a color based on a key, whether it is present in a user supplied object or in the default object.
-      @returns {String}
-      @private
-  */ function getColor(k, u = {}) {
-      return k in u ? u[k] : k in defaults ? defaults[k] : defaults.missing;
-  }
 
   /**
-      @function colorAssign
-      @desc Assigns a color to a value using a predefined set of defaults.
-      @param {String} c A valid CSS color string.
-      @param {Object} [u = defaults] An object containing overrides of the default colors.
-      @returns {String}
+      Assigns a color to a value using a predefined set of defaults.
+      @param c A valid CSS color string.
+      @param u An object containing overrides of the default colors.
   */ function assign(c, u = {}) {
       // If the value is null or undefined, set to grey.
       if ([
           null,
-          void 0
-      ].indexOf(c) >= 0) return getColor("missing", u);
-      else if (c === true) return getColor("on", u);
-      else if (c === false) return getColor("off", u);
-      const p = color(c);
-      // If the value is not a valid color string, use the color scale.
-      if (!p) return getColor("scale", u)(c);
-      return c.toString();
+          undefined
+      ].indexOf(c) >= 0) return u["missing"] || defaults["missing"];
+      else if (c === true) return u["on"] || defaults["on"];
+      else if (c === false) return u["off"] || defaults["off"];
+      else {
+          const p = color(c);
+          // If the value is not a valid color string, use the color scale.
+          if (!p) return (u["scale"] || defaults["scale"])(c);
+          return c;
+      }
   }
 
   /**
-      @function colorContrast
-      @desc A set of default color values used when assigning colors based on data.
-      @param {String} c A valid CSS color string.
-      @param {Object} [u = defaults] An object containing overrides of the default colors.
-      @returns {String}
+      A set of default color values used when assigning colors based on data.
+      @param c A valid CSS color string.
+      @param u An object containing overrides of the default colors.
   */ function contrast(c, u = {}) {
-      c = rgb(c);
-      const yiq = (c.r * 299 + c.g * 587 + c.b * 114) / 1000;
-      return yiq >= 128 ? getColor("dark", u) : getColor("light", u);
+      const rgbColor = rgb(c);
+      const yiq = (rgbColor.r * 299 + rgbColor.g * 587 + rgbColor.b * 114) / 1000;
+      return yiq >= 128 ? u["dark"] || defaults["dark"] : u["light"] || defaults["light"];
   }
 
   /**
-      @function colorLegible
-      @desc Darkens a color so that it will appear legible on a white background.
-      @param {String} c A valid CSS color string.
-      @returns {String}
+      Darkens a color so that it will appear legible on a white background.
+      @param c A valid CSS color string.
   */ function legible(c) {
-      c = hsl(c);
-      if (c.l > 0.45) {
-          if (c.s > 0.8) c.s = 0.8;
-          c.l = 0.45;
+      const hslColor = hsl(c);
+      if (hslColor.l > 0.45) {
+          if (hslColor.s > 0.8) hslColor.s = 0.8;
+          hslColor.l = 0.45;
       }
-      return c.toString();
+      return hslColor.toString();
   }
 
   /**
-      @function colorLighter
-      @desc Similar to d3.color.brighter, except that this also reduces saturation so that colors don't appear neon.
-      @param {String} c A valid CSS color string.
-      @param {String} [i = 0.5] A value from 0 to 1 dictating the strength of the function.
-      @returns {String}
+      Similar to d3.color.brighter, except that this also reduces saturation so that colors don't appear neon.
+      @param c A valid CSS color string.
+      @param i Strength of the lightening effect, from 0 to 1.
   */ function lighter(c, i = 0.5) {
-      c = hsl(c);
-      i *= 1 - c.l;
-      c.l += i;
-      c.s -= i;
-      return c.toString();
+      const hslColor = hsl(c);
+      i *= 1 - hslColor.l;
+      hslColor.l += i;
+      hslColor.s -= i;
+      return hslColor.toString();
   }
 
   /**
-      @function colorSubtract
-      @desc Subtracts one color from another.
-      @param {String} c1 The base color, a valid CSS color string.
-      @param {String} c2 The color to remove from the base color, also a valid CSS color string.
-      @param {String} [o1 = 1] Value from 0 to 1 of the first color's opacity.
-      @param {String} [o2 = 1] Value from 0 to 1 of the first color's opacity.
-      @returns {String}
+      Subtracts one color from another.
+      @param c1 The base color, a valid CSS color string.
+      @param c2 The color to remove from the base color, also a valid CSS color string.
+      @param o1 Value from 0 to 1 of the first color's opacity.
+      @param o2 Value from 0 to 1 of the first color's opacity.
   */ function subtract(c1, c2, o1 = 1, o2 = 1) {
-      c1 = hsl(c1);
-      c2 = hsl(c2);
-      let d = c2.h * o2 - c1.h * o1;
+      const hsl1 = hsl(c1);
+      const hsl2 = hsl(c2);
+      let d = hsl2.h * o2 - hsl1.h * o1;
       if (Math.abs(d) > 180) d -= 360;
-      let h = (c1.h - d) % 360;
-      const l = c1.l - (c2.l * o2 - c1.l * o1) / 2, s = c1.s - (c2.s * o2 - c1.s * o1) / 2;
+      let h = (hsl1.h - d) % 360;
+      const l = hsl1.l - (hsl2.l * o2 - hsl1.l * o1) / 2, s = hsl1.s - (hsl2.s * o2 - hsl1.s * o1) / 2;
       // a = o1 - (o2 - o1) / 2;
       if (h < 0) h += 360;
       return hsl(`hsl(${h},${s * 100}%,${l * 100}%)`).toString();