@d3plus/data 3.0.12 → 3.0.13

package/umd/d3plus-data.full.js

@@ -1,5 +1,5 @@
 /*
-  @d3plus/data v3.0.12
+  @d3plus/data v3.0.13
   JavaScript data loading, manipulation, and analysis functions.
   Copyright (c) 2025 D3plus - https://d3plus.org
   @license MIT
@@ -117,380 +117,7 @@
     @function isData
     @desc Returns true/false whether the argument provided to the function should be loaded using an internal XHR request. Valid data can either be a string URL or an Object with "url" and "headers" keys.
     @param {*} dataItem The value to be tested
-  */ var isData = ((dataItem)=>typeof dataItem === "string" || typeof dataItem === "object" && dataItem.url && dataItem.headers);
-
-  var prefix = "$";
-  function Map() {}
-  Map.prototype = map.prototype = {
-      constructor: Map,
-      has: function(key) {
-          return prefix + key in this;
-      },
-      get: function(key) {
-          return this[prefix + key];
-      },
-      set: function(key, value) {
-          this[prefix + key] = value;
-          return this;
-      },
-      remove: function(key) {
-          var property = prefix + key;
-          return property in this && delete this[property];
-      },
-      clear: function() {
-          for(var property in this)if (property[0] === prefix) delete this[property];
-      },
-      keys: function() {
-          var keys = [];
-          for(var property in this)if (property[0] === prefix) keys.push(property.slice(1));
-          return keys;
-      },
-      values: function() {
-          var values = [];
-          for(var property in this)if (property[0] === prefix) values.push(this[property]);
-          return values;
-      },
-      entries: function() {
-          var entries = [];
-          for(var property in this)if (property[0] === prefix) entries.push({
-              key: property.slice(1),
-              value: this[property]
-          });
-          return entries;
-      },
-      size: function() {
-          var size = 0;
-          for(var property in this)if (property[0] === prefix) ++size;
-          return size;
-      },
-      empty: function() {
-          for(var property in this)if (property[0] === prefix) return false;
-          return true;
-      },
-      each: function(f) {
-          for(var property in this)if (property[0] === prefix) f(this[property], property.slice(1), this);
-      }
-  };
-  function map(object, f) {
-      var map = new Map;
-      // Copy constructor.
-      if (object instanceof Map) object.each(function(value, key) {
-          map.set(key, value);
-      });
-      else if (Array.isArray(object)) {
-          var i = -1, n = object.length, o;
-          if (f == null) while(++i < n)map.set(i, object[i]);
-          else while(++i < n)map.set(f(o = object[i], i, object), o);
-      } else if (object) for(var key in object)map.set(key, object[key]);
-      return map;
-  }
-
-  function nest$1() {
-      var keys = [], sortKeys = [], sortValues, rollup, nest;
-      function apply(array, depth, createResult, setResult) {
-          if (depth >= keys.length) {
-              if (sortValues != null) array.sort(sortValues);
-              return rollup != null ? rollup(array) : array;
-          }
-          var i = -1, n = array.length, key = keys[depth++], keyValue, value, valuesByKey = map(), values, result = createResult();
-          while(++i < n){
-              if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) {
-                  values.push(value);
-              } else {
-                  valuesByKey.set(keyValue, [
-                      value
-                  ]);
-              }
-          }
-          valuesByKey.each(function(values, key) {
-              setResult(result, key, apply(values, depth, createResult, setResult));
-          });
-          return result;
-      }
-      function entries(map, depth) {
-          if (++depth > keys.length) return map;
-          var array, sortKey = sortKeys[depth - 1];
-          if (rollup != null && depth >= keys.length) array = map.entries();
-          else array = [], map.each(function(v, k) {
-              array.push({
-                  key: k,
-                  values: entries(v, depth)
-              });
-          });
-          return sortKey != null ? array.sort(function(a, b) {
-              return sortKey(a.key, b.key);
-          }) : array;
-      }
-      return nest = {
-          object: function(array) {
-              return apply(array, 0, createObject, setObject);
-          },
-          map: function(array) {
-              return apply(array, 0, createMap, setMap);
-          },
-          entries: function(array) {
-              return entries(apply(array, 0, createMap, setMap), 0);
-          },
-          key: function(d) {
-              keys.push(d);
-              return nest;
-          },
-          sortKeys: function(order) {
-              sortKeys[keys.length - 1] = order;
-              return nest;
-          },
-          sortValues: function(order) {
-              sortValues = order;
-              return nest;
-          },
-          rollup: function(f) {
-              rollup = f;
-              return nest;
-          }
-      };
-  }
-  function createObject() {
-      return {};
-  }
-  function setObject(object, key, value) {
-      object[key] = value;
-  }
-  function createMap() {
-      return map();
-  }
-  function setMap(map, key, value) {
-      map.set(key, value);
-  }
-
-  function Set() {}
-  var proto = map.prototype;
-  Set.prototype = {
-      constructor: Set,
-      has: proto.has,
-      add: function(value) {
-          value += "";
-          this[prefix + value] = value;
-          return this;
-      },
-      remove: proto.remove,
-      clear: proto.clear,
-      values: proto.keys,
-      size: proto.size,
-      empty: proto.empty,
-      each: proto.each
-  };
-
-  var noop = {
-      value: function() {}
-  };
-  function dispatch() {
-      for(var i = 0, n = arguments.length, _ = {}, t; i < n; ++i){
-          if (!(t = arguments[i] + "") || t in _ || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
-          _[t] = [];
-      }
-      return new Dispatch(_);
-  }
-  function Dispatch(_) {
-      this._ = _;
-  }
-  function parseTypenames(typenames, types) {
-      return typenames.trim().split(/^|\s+/).map(function(t) {
-          var name = "", i = t.indexOf(".");
-          if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
-          if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
-          return {
-              type: t,
-              name: name
-          };
-      });
-  }
-  Dispatch.prototype = dispatch.prototype = {
-      constructor: Dispatch,
-      on: function(typename, callback) {
-          var _ = this._, T = parseTypenames(typename + "", _), t, i = -1, n = T.length;
-          // If no callback was specified, return the callback of the given type and name.
-          if (arguments.length < 2) {
-              while(++i < n)if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
-              return;
-          }
-          // If a type was specified, set the callback for the given type and name.
-          // Otherwise, if a null callback was specified, remove callbacks of the given name.
-          if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
-          while(++i < n){
-              if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
-              else if (callback == null) for(t in _)_[t] = set(_[t], typename.name, null);
-          }
-          return this;
-      },
-      copy: function() {
-          var copy = {}, _ = this._;
-          for(var t in _)copy[t] = _[t].slice();
-          return new Dispatch(copy);
-      },
-      call: function(type, that) {
-          if ((n = arguments.length - 2) > 0) for(var args = new Array(n), i = 0, n, t; i < n; ++i)args[i] = arguments[i + 2];
-          if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
-          for(t = this._[type], i = 0, n = t.length; i < n; ++i)t[i].value.apply(that, args);
-      },
-      apply: function(type, that, args) {
-          if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
-          for(var t = this._[type], i = 0, n = t.length; i < n; ++i)t[i].value.apply(that, args);
-      }
-  };
-  function get(type, name) {
-      for(var i = 0, n = type.length, c; i < n; ++i){
-          if ((c = type[i]).name === name) {
-              return c.value;
-          }
-      }
-  }
-  function set(type, name, callback) {
-      for(var i = 0, n = type.length; i < n; ++i){
-          if (type[i].name === name) {
-              type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
-              break;
-          }
-      }
-      if (callback != null) type.push({
-          name: name,
-          value: callback
-      });
-      return type;
-  }
-
-  function request(url, callback) {
-      var request, event = dispatch("beforesend", "progress", "load", "error"), mimeType, headers = map(), xhr = new XMLHttpRequest, user = null, password = null, response, responseType, timeout = 0;
-      // If IE does not support CORS, use XDomainRequest.
-      if (typeof XDomainRequest !== "undefined" && !("withCredentials" in xhr) && /^(http(s)?:)?\/\//.test(url)) xhr = new XDomainRequest;
-      "onload" in xhr ? xhr.onload = xhr.onerror = xhr.ontimeout = respond : xhr.onreadystatechange = function(o) {
-          xhr.readyState > 3 && respond(o);
-      };
-      function respond(o) {
-          var status = xhr.status, result;
-          if (!status && hasResponse(xhr) || status >= 200 && status < 300 || status === 304) {
-              if (response) {
-                  try {
-                      result = response.call(request, xhr);
-                  } catch (e) {
-                      event.call("error", request, e);
-                      return;
-                  }
-              } else {
-                  result = xhr;
-              }
-              event.call("load", request, result);
-          } else {
-              event.call("error", request, o);
-          }
-      }
-      xhr.onprogress = function(e) {
-          event.call("progress", request, e);
-      };
-      request = {
-          header: function(name, value) {
-              name = (name + "").toLowerCase();
-              if (arguments.length < 2) return headers.get(name);
-              if (value == null) headers.remove(name);
-              else headers.set(name, value + "");
-              return request;
-          },
-          // If mimeType is non-null and no Accept header is set, a default is used.
-          mimeType: function(value) {
-              if (!arguments.length) return mimeType;
-              mimeType = value == null ? null : value + "";
-              return request;
-          },
-          // Specifies what type the response value should take;
-          // for instance, arraybuffer, blob, document, or text.
-          responseType: function(value) {
-              if (!arguments.length) return responseType;
-              responseType = value;
-              return request;
-          },
-          timeout: function(value) {
-              if (!arguments.length) return timeout;
-              timeout = +value;
-              return request;
-          },
-          user: function(value) {
-              return arguments.length < 1 ? user : (user = value == null ? null : value + "", request);
-          },
-          password: function(value) {
-              return arguments.length < 1 ? password : (password = value == null ? null : value + "", request);
-          },
-          // Specify how to convert the response content to a specific type;
-          // changes the callback value on "load" events.
-          response: function(value) {
-              response = value;
-              return request;
-          },
-          // Alias for send("GET", …).
-          get: function(data, callback) {
-              return request.send("GET", data, callback);
-          },
-          // Alias for send("POST", …).
-          post: function(data, callback) {
-              return request.send("POST", data, callback);
-          },
-          // If callback is non-null, it will be used for error and load events.
-          send: function(method, data, callback) {
-              xhr.open(method, url, true, user, password);
-              if (mimeType != null && !headers.has("accept")) headers.set("accept", mimeType + ",*/*");
-              if (xhr.setRequestHeader) headers.each(function(value, name) {
-                  xhr.setRequestHeader(name, value);
-              });
-              if (mimeType != null && xhr.overrideMimeType) xhr.overrideMimeType(mimeType);
-              if (responseType != null) xhr.responseType = responseType;
-              if (timeout > 0) xhr.timeout = timeout;
-              if (callback == null && typeof data === "function") callback = data, data = null;
-              if (callback != null && callback.length === 1) callback = fixCallback(callback);
-              if (callback != null) request.on("error", callback).on("load", function(xhr) {
-                  callback(null, xhr);
-              });
-              event.call("beforesend", request, xhr);
-              xhr.send(data == null ? null : data);
-              return request;
-          },
-          abort: function() {
-              xhr.abort();
-              return request;
-          },
-          on: function() {
-              var value = event.on.apply(event, arguments);
-              return value === event ? request : value;
-          }
-      };
-      return request;
-  }
-  function fixCallback(callback) {
-      return function(error, xhr) {
-          callback(error == null ? xhr : null);
-      };
-  }
-  function hasResponse(xhr) {
-      var type = xhr.responseType;
-      return type && type !== "text" ? xhr.response // null on error
-       : xhr.responseText; // "" on error
-  }
-
-  function type(defaultMimeType, response) {
-      return function(url, callback) {
-          var r = request(url).mimeType(defaultMimeType).response(response);
-          if (callback != null) {
-              if (typeof callback !== "function") throw new Error("invalid callback: " + callback);
-              return r.get(callback);
-          }
-          return r;
-      };
-  }
-
-  var json = type("application/json", function(xhr) {
-      return JSON.parse(xhr.responseText);
-  });
-
-  var text = type("text/plain", function(xhr) {
-      return xhr.responseText;
-  });
+  */ var isData = ((dataItem)=>typeof dataItem === "string" || typeof dataItem === "object" && dataItem.url);
 
   var EOL = {}, EOF = {}, QUOTE = 34, NEWLINE = 10, RETURN = 13;
   function objectConverter(columns) {
@@ -527,7 +154,7 @@
       var hours = date.getUTCHours(), minutes = date.getUTCMinutes(), seconds = date.getUTCSeconds(), milliseconds = date.getUTCMilliseconds();
       return isNaN(date) ? "Invalid Date" : formatYear(date.getUTCFullYear()) + "-" + pad(date.getUTCMonth() + 1, 2) + "-" + pad(date.getUTCDate(), 2) + (milliseconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "." + pad(milliseconds, 3) + "Z" : seconds ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + ":" + pad(seconds, 2) + "Z" : minutes || hours ? "T" + pad(hours, 2) + ":" + pad(minutes, 2) + "Z" : "");
   }
-  function dsv$1(delimiter) {
+  function dsvFormat(delimiter) {
       var reFormat = new RegExp("[\"" + delimiter + "\n\r]"), DELIMITER = delimiter.charCodeAt(0);
       function parse(text, f) {
           var convert, columns, rows = parseRows(text, function(row, i) {
@@ -614,32 +241,39 @@
       };
   }
 
-  var csv$1 = dsv$1(",");
+  var csv$1 = dsvFormat(",");
   var csvParse = csv$1.parse;
 
-  var tsv$1 = dsv$1("\t");
+  var tsv$1 = dsvFormat("\t");
   var tsvParse = tsv$1.parse;
 
-  function dsv(defaultMimeType, parse) {
-      return function(url, row, callback) {
-          if (arguments.length < 3) callback = row, row = null;
-          var r = request(url).mimeType(defaultMimeType);
-          r.row = function(_) {
-              return arguments.length ? r.response(responseOf(parse, row = _)) : row;
-          };
-          r.row(row);
-          return callback ? r.get(callback) : r;
-      };
+  function responseText(response) {
+      if (!response.ok) throw new Error(response.status + " " + response.statusText);
+      return response.text();
   }
-  function responseOf(parse, row) {
-      return function(request) {
-          return parse(request.responseText, row);
-      };
+  function text(input, init) {
+      return fetch(input, init).then(responseText);
   }
 
-  var csv = dsv("text/csv", csvParse);
+  function dsvParse(parse) {
+      return function(input, init, row) {
+          if (arguments.length === 2 && typeof init === "function") row = init, init = undefined;
+          return text(input, init).then(function(response) {
+              return parse(response, row);
+          });
+      };
+  }
+  var csv = dsvParse(csvParse);
+  var tsv = dsvParse(tsvParse);
 
-  var tsv = dsv("text/tab-separated-values", tsvParse);
+  function responseJson(response) {
+      if (!response.ok) throw new Error(response.status + " " + response.statusText);
+      if (response.status === 204 || response.status === 205) return;
+      return response.json();
+  }
+  function json(input, init) {
+      return fetch(input, init).then(responseJson);
+  }
 
   /**
       @function isObject
@@ -696,22 +330,21 @@
     @param {String} [key] The key in the `this` context to save the resulting data to.
     @param {Function} [callback] A function that is called when the final data is loaded. It is passed 2 variables, any error present and the data loaded.
   */ function load(path, formatter, key, callback) {
-      let parser;
-      const getParser = (path)=>{
+      const fetchData = (path, init = {})=>{
           const ext = path.slice(path.length - 4);
           switch(ext){
               case ".csv":
-                  return csv;
+                  return csv(path, init);
               case ".tsv":
-                  return tsv;
+                  return tsv(path, init);
               case ".txt":
-                  return text;
+                  return text(path, init);
               default:
-                  return json;
+                  return json(path, init);
           }
       };
-      const validateData = (err, parser, data)=>{
-          if (parser !== json && !err && data && data instanceof Array) {
+      const validateData = (data)=>{
+          if (data && data instanceof Array) {
               data.forEach((d)=>{
                   for(const k in d){
                       if (!isNaN(d[k])) d[k] = parseFloat(d[k]);
@@ -725,7 +358,6 @@
           return data;
       };
       const loadedLength = (loadedArray)=>loadedArray.reduce((prev, current)=>current ? prev + 1 : prev, 0);
-      const getPathIndex = (url, array)=>array.indexOf(url);
       // If path param is a not an Array then convert path to a 1 element Array to re-use logic
       if (!(path instanceof Array)) path = [
           path
@@ -745,23 +377,16 @@
       // Load all urls an combine them with data arrays
       const alreadyLoaded = loadedLength(loaded);
       toLoad.forEach((dataItem)=>{
-          let headers = {}, url = dataItem;
-          if (typeof dataItem === "object") {
+          let url = dataItem, init = {};
+          if (typeof dataItem === "object" && dataItem.url) {
               url = dataItem.url;
-              headers = dataItem.headers;
-          }
-          parser = getParser(url);
-          const request = parser(url);
-          for(const key in headers){
-              if (({}).hasOwnProperty.call(headers, key)) {
-                  request.header(key, headers[key]);
-              }
+              init = dataItem;
           }
-          request.get((err, data)=>{
-              data = err ? [] : data;
-              if (data && !(data instanceof Array) && data.data && data.headers) data = fold(data);
-              data = validateData(err, parser, data);
-              loaded[getPathIndex(url, path)] = data;
+          fetchData(url, init).then((data)=>{
+              if (!(data instanceof Array) && data.data && data.headers) data = fold(data);
+              data = validateData(data);
+              loaded[path.findIndex((d)=>JSON.stringify(d) == JSON.stringify(dataItem))] = data;
+              // All urls loaded
               if (loadedLength(loaded) - alreadyLoaded === toLoad.length) {
                   // Format data
                   data = loadedLength(loaded) === 1 ? loaded[0] : loaded;
@@ -777,8 +402,11 @@
                       data = concat(loaded, "data");
                   }
                   if (key && `_${key}` in this) this[`_${key}`] = data;
-                  if (callback) callback(err, data);
+                  if (callback) callback(undefined, data);
               }
+          }).catch((err)=>{
+              console.log(err);
+              if (callback) callback(err, undefined);
           });
       });
       // If there is no data to Load response is immediately
@@ -811,15 +439,15 @@
     @param {Function} [data] An optional data formatter/callback
     @param {String} data The internal Viz method to be modified
   */ function addToQueue(_, f, key) {
-      if (!(_ instanceof Array)) _ = [
+      const paths = _ instanceof Array ? _ : [
           _
       ];
-      const needToLoad = _.find(isData);
+      const needToLoad = paths.find(isData);
       if (needToLoad) {
           const prev = this._queue.find((q)=>q[3] === key);
           const d = [
               load.bind(this),
-              _,
+              paths,
               f,
               key
           ];
@@ -913,6 +541,167 @@
       return newObject;
   }
 
+  var prefix = "$";
+  function Map() {}
+  Map.prototype = map.prototype = {
+      constructor: Map,
+      has: function(key) {
+          return prefix + key in this;
+      },
+      get: function(key) {
+          return this[prefix + key];
+      },
+      set: function(key, value) {
+          this[prefix + key] = value;
+          return this;
+      },
+      remove: function(key) {
+          var property = prefix + key;
+          return property in this && delete this[property];
+      },
+      clear: function() {
+          for(var property in this)if (property[0] === prefix) delete this[property];
+      },
+      keys: function() {
+          var keys = [];
+          for(var property in this)if (property[0] === prefix) keys.push(property.slice(1));
+          return keys;
+      },
+      values: function() {
+          var values = [];
+          for(var property in this)if (property[0] === prefix) values.push(this[property]);
+          return values;
+      },
+      entries: function() {
+          var entries = [];
+          for(var property in this)if (property[0] === prefix) entries.push({
+              key: property.slice(1),
+              value: this[property]
+          });
+          return entries;
+      },
+      size: function() {
+          var size = 0;
+          for(var property in this)if (property[0] === prefix) ++size;
+          return size;
+      },
+      empty: function() {
+          for(var property in this)if (property[0] === prefix) return false;
+          return true;
+      },
+      each: function(f) {
+          for(var property in this)if (property[0] === prefix) f(this[property], property.slice(1), this);
+      }
+  };
+  function map(object, f) {
+      var map = new Map;
+      // Copy constructor.
+      if (object instanceof Map) object.each(function(value, key) {
+          map.set(key, value);
+      });
+      else if (Array.isArray(object)) {
+          var i = -1, n = object.length, o;
+          if (f == null) while(++i < n)map.set(i, object[i]);
+          else while(++i < n)map.set(f(o = object[i], i, object), o);
+      } else if (object) for(var key in object)map.set(key, object[key]);
+      return map;
+  }
+
+  function nest$1() {
+      var keys = [], sortKeys = [], sortValues, rollup, nest;
+      function apply(array, depth, createResult, setResult) {
+          if (depth >= keys.length) {
+              if (sortValues != null) array.sort(sortValues);
+              return rollup != null ? rollup(array) : array;
+          }
+          var i = -1, n = array.length, key = keys[depth++], keyValue, value, valuesByKey = map(), values, result = createResult();
+          while(++i < n){
+              if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) {
+                  values.push(value);
+              } else {
+                  valuesByKey.set(keyValue, [
+                      value
+                  ]);
+              }
+          }
+          valuesByKey.each(function(values, key) {
+              setResult(result, key, apply(values, depth, createResult, setResult));
+          });
+          return result;
+      }
+      function entries(map, depth) {
+          if (++depth > keys.length) return map;
+          var array, sortKey = sortKeys[depth - 1];
+          if (rollup != null && depth >= keys.length) array = map.entries();
+          else array = [], map.each(function(v, k) {
+              array.push({
+                  key: k,
+                  values: entries(v, depth)
+              });
+          });
+          return sortKey != null ? array.sort(function(a, b) {
+              return sortKey(a.key, b.key);
+          }) : array;
+      }
+      return nest = {
+          object: function(array) {
+              return apply(array, 0, createObject, setObject);
+          },
+          map: function(array) {
+              return apply(array, 0, createMap, setMap);
+          },
+          entries: function(array) {
+              return entries(apply(array, 0, createMap, setMap), 0);
+          },
+          key: function(d) {
+              keys.push(d);
+              return nest;
+          },
+          sortKeys: function(order) {
+              sortKeys[keys.length - 1] = order;
+              return nest;
+          },
+          sortValues: function(order) {
+              sortValues = order;
+              return nest;
+          },
+          rollup: function(f) {
+              rollup = f;
+              return nest;
+          }
+      };
+  }
+  function createObject() {
+      return {};
+  }
+  function setObject(object, key, value) {
+      object[key] = value;
+  }
+  function createMap() {
+      return map();
+  }
+  function setMap(map, key, value) {
+      map.set(key, value);
+  }
+
+  function Set() {}
+  var proto = map.prototype;
+  Set.prototype = {
+      constructor: Set,
+      has: proto.has,
+      add: function(value) {
+          value += "";
+          this[prefix + value] = value;
+          return this;
+      },
+      remove: proto.remove,
+      clear: proto.clear,
+      values: proto.keys,
+      size: proto.size,
+      empty: proto.empty,
+      each: proto.each
+  };
+
   /**
       @function nest
       @summary Extends the base behavior of d3.nest to allow for multiple depth levels.