@d3plus/core 3.0.0-alpha.0

package/es/src/shapes/Whisker.js

@@ -0,0 +1,330 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { nest } from "d3-collection";
+import { select } from "d3-selection";
+import { assign, elem } from "@d3plus/dom";
+import { accessor, BaseClass, configPrep, constant } from "../utils/index.js";
+import Circle from "./Circle.js";
+import Line from "./Line.js";
+import Rect from "./Rect.js";
+var shapes = {
+    Circle: Circle,
+    Rect: Rect
+};
+var Whisker = /*#__PURE__*/ function(BaseClass) {
+    "use strict";
+    _inherits(Whisker, BaseClass);
+    function Whisker() {
+        _class_call_check(this, Whisker);
+        var _this;
+        _this = _call_super(this, Whisker);
+        _this._endpoint = accessor("endpoint", "Rect");
+        _this._endpointConfig = {
+            Circle: {
+                r: accessor("r", 5)
+            }
+        };
+        _this._length = accessor("length", 25);
+        _this._lineConfig = {};
+        _this._orient = accessor("orient", "top");
+        _this._x = accessor("x", 0);
+        _this._y = accessor("y", 0);
+        return _this;
+    }
+    _create_class(Whisker, [
+        {
+            /**
+      @memberof Whisker
+      @desc Draws the whisker.
+      @param {Function} [*callback*]
+      @chainable
+  */ key: "render",
+            value: function render(callback) {
+                var _this = this;
+                if (this._select === void 0) {
+                    this.select(select("body").append("svg").style("width", "".concat(window.innerWidth, "px")).style("height", "".concat(window.innerHeight, "px")).style("display", "block").node());
+                }
+                var lineData = [];
+                this._data.forEach(function(d, i) {
+                    var orient = _this._orient(d, i);
+                    var x = _this._x(d, i);
+                    var y = _this._y(d, i);
+                    var endpointX = x;
+                    if (orient === "left") endpointX -= _this._length(d, i);
+                    else if (orient === "right") endpointX += _this._length(d, i);
+                    var endpointY = y;
+                    if (orient === "top") endpointY -= _this._length(d, i);
+                    else if (orient === "bottom") endpointY += _this._length(d, i);
+                    lineData.push({
+                        __d3plus__: true,
+                        data: d,
+                        i: i,
+                        id: i,
+                        x: x,
+                        y: y
+                    });
+                    lineData.push({
+                        __d3plus__: true,
+                        data: d,
+                        i: i,
+                        id: i,
+                        x: endpointX,
+                        y: endpointY
+                    });
+                });
+                // Draw whisker line.
+                this._line = new Line().data(lineData).select(elem("g.d3plus-Whisker", {
+                    parent: this._select
+                }).node()).config(configPrep.bind(this)(this._lineConfig, "shape")).render(callback);
+                var whiskerData = this._data.map(function(d, i) {
+                    var dataObj = {};
+                    dataObj.__d3plus__ = true;
+                    dataObj.data = d;
+                    dataObj.i = i;
+                    dataObj.endpoint = _this._endpoint(d, i);
+                    dataObj.length = _this._length(d, i);
+                    dataObj.orient = _this._orient(d, i);
+                    var endpointX = _this._x(d, i);
+                    if (dataObj.orient === "left") endpointX -= dataObj.length;
+                    else if (dataObj.orient === "right") endpointX += dataObj.length;
+                    var endpointY = _this._y(d, i);
+                    if (dataObj.orient === "top") endpointY -= dataObj.length;
+                    else if (dataObj.orient === "bottom") endpointY += dataObj.length;
+                    dataObj.x = endpointX;
+                    dataObj.y = endpointY;
+                    return dataObj;
+                });
+                // Draw whisker endpoint.
+                this._whiskerEndpoint = [];
+                nest().key(function(d) {
+                    return d.endpoint;
+                }).entries(whiskerData).forEach(function(shapeData) {
+                    var shapeName = shapeData.key;
+                    _this._whiskerEndpoint.push(new shapes[shapeName]().data(shapeData.values).select(elem("g.d3plus-Whisker-Endpoint-".concat(shapeName), {
+                        parent: _this._select
+                    }).node()).config({
+                        height: function(d) {
+                            return d.orient === "top" || d.orient === "bottom" ? 5 : 20;
+                        },
+                        width: function(d) {
+                            return d.orient === "top" || d.orient === "bottom" ? 20 : 5;
+                        }
+                    }).config(configPrep.bind(_this)(_this._endpointConfig, "shape", shapeName)).render());
+                });
+                return this;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc Sets the highlight accessor to the Shape class's active function.
+      @param {Function} [*value*]
+      @chainable
+  */ key: "active",
+            value: function active(_) {
+                if (this._line) this._line.active(_);
+                if (this._whiskerEndpoint) this._whiskerEndpoint.forEach(function(endPoint) {
+                    return endPoint.active(_);
+                });
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *data* is specified, sets the data array to the specified array and returns the current class instance. If *data* is not specified, returns the current data array.
+      @param {Array} [*data* = []]
+      @chainable
+  */ key: "data",
+            value: function data(_) {
+                return arguments.length ? (this._data = _, this) : this._data;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the endpoint accessor to the specified function or string and returns the current class instance.
+      @param {Function|String}
+      @chainable
+  */ key: "endpoint",
+            value: function endpoint(_) {
+                return arguments.length ? (this._endpoint = typeof _ === "function" ? _ : constant(_), this) : this._endpoint;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the config method for each endpoint and returns the current class instance.
+      @param {Object} [*value*]
+      @chainable
+  */ key: "endpointConfig",
+            value: function endpointConfig(_) {
+                return arguments.length ? (this._endpointConfig = assign(this._endpointConfig, _), this) : this._endpointConfig;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc Sets the highlight accessor to the Shape class's hover function.
+      @param {Function} [*value*]
+      @chainable
+  */ key: "hover",
+            value: function hover(_) {
+                if (this._line) this._line.hover(_);
+                if (this._whiskerEndpoint) this._whiskerEndpoint.forEach(function(endPoint) {
+                    return endPoint.hover(_);
+                });
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the length accessor for whisker and returns the current class instance.
+      @param {Function|Number} [*value*]
+      @chainable
+  */ key: "length",
+            value: function length(_) {
+                return arguments.length ? (this._length = typeof _ === "function" ? _ : constant(_), this) : this._length;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the config method for line shape and returns the current class instance.
+      @param {Object} [*value*]
+      @chainable
+  */ key: "lineConfig",
+            value: function lineConfig(_) {
+                return arguments.length ? (this._lineConfig = assign(this._lineConfig, _), this) : this._lineConfig;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the orientation to the specified value. If *value* is not specified, returns the current orientation.
+      @param {Function|String} [*value* = "top"] Accepts "top", "right", "bottom" or "left"
+      @chainable
+  */ key: "orient",
+            value: function orient(_) {
+                return arguments.length ? (this._orient = typeof _ === "function" ? _ : constant(_), this) : this._orient;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *selector* is specified, sets the SVG container element to the specified d3 selector or DOM element and returns the current class instance. If *selector* is not specified, returns the current SVG container element.
+      @param {String|HTMLElement} [*selector* = d3.select("body").append("svg")]
+      @chainable
+  */ key: "select",
+            value: function select1(_) {
+                return arguments.length ? (this._select = select(_), this) : this._select;
+            }
+        },
+        {
+            /**
+    @memberof Whisker
+    @desc If *value* is specified, sets the x axis to the specified function or number and returns the current class instance.
+    @param {Function|Number} [*value*]
+    @chainable
+    @example
+function(d) {
+  return d.x;
+}
+  */ key: "x",
+            value: function x(_) {
+                return arguments.length ? (this._x = typeof _ === "function" ? _ : constant(_), this) : this._x;
+            }
+        },
+        {
+            /**
+      @memberof Whisker
+      @desc If *value* is specified, sets the y axis to the specified function or number and returns the current class instance.
+      @param {Function|Number} [*value*]
+      @chainable
+      @example
+function(d) {
+  return d.y;
+}
+  */ key: "y",
+            value: function y(_) {
+                return arguments.length ? (this._y = typeof _ === "function" ? _ : constant(_), this) : this._y;
+            }
+        }
+    ]);
+    return Whisker;
+}(BaseClass);
+/**
+    @class Whisker
+    @extends BaseClass
+    @desc Creates SVG whisker based on an array of data.
+*/ export { Whisker as default };

package/es/src/shapes/index.js

@@ -0,0 +1,10 @@
+export { default as Shape } from "./Shape.js";
+export { default as Area } from "./Area.js";
+export { default as Bar } from "./Bar.js";
+export { default as Box } from "./Box.js";
+export { default as Circle } from "./Circle.js";
+export { default as Image } from "./Image.js";
+export { default as Line } from "./Line.js";
+export { default as Path } from "./Path.js";
+export { default as Rect } from "./Rect.js";
+export { default as Whisker } from "./Whisker.js";

package/es/src/utils/BaseClass.js

@@ -0,0 +1,204 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import { assign, isObject } from "@d3plus/dom";
+import { findLocale, translateLocale as dictionaries } from "@d3plus/locales";
+import RESET from "./RESET.js";
+import uuid from "./uuid.js";
+/**
+    @desc Recursive function that resets nested Object configs.
+    @param {Object} obj
+    @param {Object} defaults
+    @private
+*/ function nestedReset(obj, defaults) {
+    if (isObject(obj)) {
+        for(var nestedKey in obj){
+            if (({}).hasOwnProperty.call(obj, nestedKey) && !nestedKey.startsWith("_")) {
+                var defaultValue = defaults && isObject(defaults) ? defaults[nestedKey] : undefined;
+                if (obj[nestedKey] === RESET) {
+                    if (defaultValue) obj[nestedKey] = defaultValue;
+                    else delete obj[nestedKey];
+                } else if (isObject(obj[nestedKey])) {
+                    nestedReset(obj[nestedKey], defaultValue);
+                }
+            }
+        }
+    }
+}
+/**
+ * @desc finds all prototype methods of a class and it's parent classes
+ * @param {*} obj
+ * @private
+ */ function getAllMethods(obj) {
+    var props = [];
+    do {
+        props = props.concat(Object.getOwnPropertyNames(obj));
+        obj = Object.getPrototypeOf(obj);
+    }while (obj && obj !== Object.prototype);
+    return props.filter(function(e) {
+        return e.indexOf("_") !== 0 && ![
+            "config",
+            "constructor",
+            "parent",
+            "render"
+        ].includes(e);
+    });
+}
+var BaseClass = /*#__PURE__*/ function() {
+    "use strict";
+    function BaseClass() {
+        var _this = this;
+        _class_call_check(this, BaseClass);
+        this._locale = "en-US";
+        this._on = {};
+        this._parent = {};
+        this._translate = function(d) {
+            var locale = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _this._locale;
+            var dictionary = dictionaries[locale];
+            return dictionary && dictionary[d] ? dictionary[d] : d;
+        };
+        this._uuid = uuid();
+    }
+    _create_class(BaseClass, [
+        {
+            /**
+      @memberof BaseClass
+      @desc If *value* is specified, sets the methods that correspond to the key/value pairs and returns this class. If *value* is not specified, returns the current configuration.
+      @param {Object} [*value*]
+      @chainable
+  */ key: "config",
+            value: function config(_) {
+                var _this = this;
+                if (!this._configDefault) {
+                    var config = {};
+                    getAllMethods(this.__proto__).forEach(function(k) {
+                        var v = _this[k]();
+                        if (v !== _this) config[k] = isObject(v) ? assign({}, v) : v;
+                    });
+                    this._configDefault = config;
+                }
+                if (arguments.length) {
+                    for(var k in _){
+                        if (({}).hasOwnProperty.call(_, k) && k in this) {
+                            var v = _[k];
+                            if (v === RESET) {
+                                if (k === "on") this._on = this._configDefault[k];
+                                else this[k](this._configDefault[k]);
+                            } else {
+                                nestedReset(v, this._configDefault[k]);
+                                this[k](v);
+                            }
+                        }
+                    }
+                    return this;
+                } else {
+                    var config1 = {};
+                    getAllMethods(this.__proto__).forEach(function(k) {
+                        config1[k] = _this[k]();
+                    });
+                    return config1;
+                }
+            }
+        },
+        {
+            /**
+      @memberof BaseClass
+      @desc Sets the locale used for all text and number formatting. This method supports the locales defined in [d3plus-format](https://github.com/d3plus/d3plus-format/blob/master/src/locale.js). The locale can be defined as a complex Object (like in d3plus-format), a locale code (like "en-US"), or a 2-digit language code (like "en"). If a 2-digit code is provided, the "findLocale" function is used to identify the most approximate locale from d3plus-format.
+      @param {Object|String} [*value* = "en-US"]
+      @chainable
+      @example
+      {
+        separator: "",
+        suffixes: ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "B", "t", "q", "Q", "Z", "Y"],
+        grouping: [3],
+        delimiters: {
+          thousands: ",",
+          decimal: "."
+        },
+        currency: ["$", ""]
+      }
+  */ key: "locale",
+            value: function locale(_) {
+                return arguments.length ? (this._locale = findLocale(_), this) : this._locale;
+            }
+        },
+        {
+            /**
+      @memberof BaseClass
+      @desc Adds or removes a *listener* to each object for the specified event *typenames*. If a *listener* is not specified, returns the currently assigned listener for the specified event *typename*. Mirrors the core [d3-selection](https://github.com/d3/d3-selection#selection_on) behavior.
+      @param {String} [*typenames*]
+      @param {Function} [*listener*]
+      @chainable
+      @example <caption>By default, listeners apply globally to all objects, however, passing a namespace with the class name gives control over specific elements:</caption>
+new Plot
+  .on("click.Shape", function(d) {
+    console.log("data for shape clicked:", d);
+  })
+  .on("click.Legend", function(d) {
+    console.log("data for legend clicked:", d);
+  })
+  */ key: "on",
+            value: function on(_, f) {
+                return arguments.length === 2 ? (this._on[_] = f, this) : arguments.length ? typeof _ === "string" ? this._on[_] : (this._on = Object.assign({}, this._on, _), this) : this._on;
+            }
+        },
+        {
+            /**
+      @memberof Viz
+      @desc If *value* is specified, sets the parent config used by the wrapper and returns the current class instance.
+      @param {Object} [*value*]
+      @chainable
+  */ key: "parent",
+            value: function parent(_) {
+                return arguments.length ? (this._parent = _, this) : this._parent;
+            }
+        },
+        {
+            /**
+      @memberof BaseClass
+      @desc Defines how informational text strings should be displayed. By default, this function will try to find the string in question (which is the first argument provided to this function) inside of an internally managed translation Object. If you'd like to override to use custom text, simply pass this method your own custom formatting function.
+      @param {Function} [*value*]
+      @chainable
+      @example <caption>For example, if we wanted to only change the string "Back" and allow all other string to return in English:</caption>
+.translate(function(d) {
+  return d === "Back" ? "Get outta here" : d;
+})
+  */ key: "translate",
+            value: function translate(_) {
+                return arguments.length ? (this._translate = _, this) : this._translate;
+            }
+        },
+        {
+            /**
+      @memberof Viz
+      @desc If *value* is specified, sets the config method for each shape and returns the current class instance.
+      @param {Object} [*value*]
+      @chainable
+  */ key: "shapeConfig",
+            value: function shapeConfig(_) {
+                return arguments.length ? (this._shapeConfig = assign(this._shapeConfig, _), this) : this._shapeConfig;
+            }
+        }
+    ]);
+    return BaseClass;
+}();
+/**
+    @class BaseClass
+    @summary An abstract class that contains some global methods and functionality.
+*/ export { BaseClass as default };

package/es/src/utils/RESET.js

@@ -0,0 +1,4 @@
+/**
+    @constant RESET
+    @desc String constant used to reset an individual config property.
+*/ export default "D3PLUS-COMMON-RESET";

package/es/src/utils/accessor.js

@@ -0,0 +1,19 @@
+/**
+    @function accessor
+    @desc Wraps an object key in a simple accessor function.
+    @param {String} key The key to be returned from each Object passed to the function.
+    @param {*} [def] A default value to be returned if the key is not present.
+    @example <caption>this</caption>
+accessor("id");
+    @example <caption>returns this</caption>
+function(d) {
+  return d["id"];
+}
+*/ export default function(key, def) {
+    if (def === undefined) return function(d) {
+        return d[key];
+    };
+    return function(d) {
+        return d[key] === undefined ? def : d[key];
+    };
+}

package/es/src/utils/configPrep.js

@@ -0,0 +1,76 @@
+/**
+    @function configPrep
+    @desc Preps a config object for d3plus data, and optionally bubbles up a specific nested type. When using this function, you must bind a d3plus class' `this` context.
+    @param {Object} [config = this._shapeConfig] The configuration object to parse.
+    @param {String} [type = "shape"] The event classifier to user for "on" events. For example, the default event type of "shape" will apply all events in the "on" config object with that key, like "click.shape" and "mouseleave.shape", in addition to any gloval events like "click" and "mouseleave".
+    @param {String} [nest] An optional nested key to bubble up to the parent config level.
+*/ function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+export default function configPrep() {
+    var _this = this;
+    var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this._shapeConfig, type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "shape", nest = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    var newConfig = {
+        duration: this._duration,
+        on: {}
+    };
+    var wrapFunction = function(func) {
+        return function(d, i, s, e) {
+            if (!func) return func;
+            var parent;
+            while(d.__d3plus__){
+                if (parent) d.__d3plusParent__ = parent;
+                parent = d;
+                i = d.i;
+                d = d.data || d.feature;
+            }
+            return func.bind(_this)(d, i, s || parent, e);
+        };
+    };
+    var parseEvents = function(newObj, on) {
+        for(var event in on){
+            if (({}).hasOwnProperty.call(on, event) && !event.includes(".") || event.includes(".".concat(type))) {
+                newObj.on[event] = wrapFunction(on[event]);
+            }
+        }
+    };
+    var arrayEval = function(arr) {
+        return arr.map(function(d) {
+            if (_instanceof(d, Array)) return arrayEval(d);
+            else if ((typeof d === "undefined" ? "undefined" : _type_of(d)) === "object") return keyEval({}, d);
+            else if (typeof d === "function") return wrapFunction(d);
+            else return d;
+        });
+    };
+    var keyEval = function(newObj, obj) {
+        for(var key in obj){
+            if (({}).hasOwnProperty.call(obj, key)) {
+                if (key === "on") parseEvents(newObj, obj[key]);
+                else if (typeof obj[key] === "function") {
+                    newObj[key] = wrapFunction(obj[key]);
+                } else if (_instanceof(obj[key], Array)) {
+                    newObj[key] = arrayEval(obj[key]);
+                } else if (_type_of(obj[key]) === "object") {
+                    if (!newObj[key]) newObj[key] = {};
+                    newObj[key].on = {};
+                    keyEval(newObj[key], obj[key]);
+                } else newObj[key] = obj[key];
+            }
+        }
+    };
+    keyEval(newConfig, config);
+    if (this._on) parseEvents(newConfig, this._on);
+    if (nest && config[nest]) {
+        keyEval(newConfig, config[nest]);
+        if (config[nest].on) parseEvents(newConfig, config[nest].on);
+    }
+    return newConfig;
+}

package/es/src/utils/constant.js

@@ -0,0 +1,15 @@
+/**
+    @function constant
+    @desc Wraps non-function variables in a simple return function.
+    @param {Array|Number|Object|String} value The value to be returned from the function.
+    @example <caption>this</caption>
+constant(42);
+    @example <caption>returns this</caption>
+function() {
+  return 42;
+}
+*/ export default function(value) {
+    return function constant() {
+        return value;
+    };
+}

package/es/src/utils/getProp.js

@@ -0,0 +1,9 @@
+/**
+    @module getProp
+    @param {String} type
+    @param {Object} d
+    @param {Number} i
+    @private
+*/ export default function(type, d, i) {
+    return d[type] || this["_".concat(type)](d, i);
+}

package/es/src/utils/index.js

@@ -0,0 +1,7 @@
+export { default as accessor } from "./accessor.js";
+export { default as BaseClass } from "./BaseClass.js";
+export { default as configPrep } from "./configPrep.js";
+export { default as constant } from "./constant.js";
+export { default as getProp } from "./getProp.js";
+export { default as RESET } from "./RESET.js";
+export { default as uuid } from "./uuid.js";