@veritone-ce/design-system 2.9.0-next.2 → 2.9.0-next.3

package/dist/esm/bundled_modules/vega-projection/build/vega-projection.js

@@ -0,0 +1,86 @@
+import { registerScale } from '../../vega-scale/build/vega-scale.js';
+import geoPath from '../../d3-geo/src/path/index.js';
+import geoTransverseMercator from '../../d3-geo/src/projection/transverseMercator.js';
+import geoStereographic from '../../d3-geo/src/projection/stereographic.js';
+import geoOrthographic from '../../d3-geo/src/projection/orthographic.js';
+import geoNaturalEarth1 from '../../d3-geo/src/projection/naturalEarth1.js';
+import geoMollweide from '../../d3-geo-projection/src/mollweide.js';
+import geoMercator from '../../d3-geo/src/projection/mercator.js';
+import geoIdentity from '../../d3-geo/src/projection/identity.js';
+import geoGnomonic from '../../d3-geo/src/projection/gnomonic.js';
+import geoEquirectangular from '../../d3-geo/src/projection/equirectangular.js';
+import geoEqualEarth from '../../d3-geo/src/projection/equalEarth.js';
+import geoConicEquidistant from '../../d3-geo/src/projection/conicEquidistant.js';
+import geoConicEqualArea from '../../d3-geo/src/projection/conicEqualArea.js';
+import geoConicConformal from '../../d3-geo/src/projection/conicConformal.js';
+import geoAzimuthalEquidistant from '../../d3-geo/src/projection/azimuthalEquidistant.js';
+import geoAzimuthalEqualArea from '../../d3-geo/src/projection/azimuthalEqualArea.js';
+import geoAlbersUsa from '../../d3-geo/src/projection/albersUsa.js';
+import geoAlbers from '../../d3-geo/src/projection/albers.js';
+
+const defaultPath = geoPath();
+const projectionProperties = [
+// standard properties in d3-geo
+'clipAngle', 'clipExtent', 'scale', 'translate', 'center', 'rotate', 'parallels', 'precision', 'reflectX', 'reflectY',
+// extended properties in d3-geo-projections
+'coefficient', 'distance', 'fraction', 'lobes', 'parallel', 'radius', 'ratio', 'spacing', 'tilt'];
+
+/**
+ * Augment projections with their type and a copy method.
+ */
+function create(type, constructor) {
+  return function projection() {
+    const p = constructor();
+    p.type = type;
+    p.path = geoPath().projection(p);
+    p.copy = p.copy || function () {
+      const c = projection();
+      projectionProperties.forEach(prop => {
+        if (p[prop]) c[prop](p[prop]());
+      });
+      c.path.pointRadius(p.path.pointRadius());
+      return c;
+    };
+    return registerScale(p);
+  };
+}
+function projection(type, proj) {
+  if (!type || typeof type !== 'string') {
+    throw new Error('Projection type must be a name string.');
+  }
+  type = type.toLowerCase();
+  if (arguments.length > 1) {
+    projections[type] = create(type, proj);
+    return this;
+  } else {
+    return projections[type] || null;
+  }
+}
+function getProjectionPath(proj) {
+  return proj && proj.path || defaultPath;
+}
+const projections = {
+  // base d3-geo projection types
+  albers: geoAlbers,
+  albersusa: geoAlbersUsa,
+  azimuthalequalarea: geoAzimuthalEqualArea,
+  azimuthalequidistant: geoAzimuthalEquidistant,
+  conicconformal: geoConicConformal,
+  conicequalarea: geoConicEqualArea,
+  conicequidistant: geoConicEquidistant,
+  equalEarth: geoEqualEarth,
+  equirectangular: geoEquirectangular,
+  gnomonic: geoGnomonic,
+  identity: geoIdentity,
+  mercator: geoMercator,
+  mollweide: geoMollweide,
+  naturalEarth1: geoNaturalEarth1,
+  orthographic: geoOrthographic,
+  stereographic: geoStereographic,
+  transversemercator: geoTransverseMercator
+};
+for (const key in projections) {
+  projection(key, projections[key]);
+}
+
+export { getProjectionPath, projection, projectionProperties };

package/dist/esm/bundled_modules/vega-regression/build/vega-regression.js

@@ -0,0 +1,233 @@
+import { regressionLoess as loess, regressionPoly as poly, regressionQuad as quad, regressionPow as pow, regressionExp as exp, regressionLog as log, regressionLinear as linear, regressionConstant as constant, sampleCurve } from '../../vega-statistics/build/vega-statistics.js';
+import { Transform, ingest as ingest$1 } from '../../vega-dataflow/build/vega-dataflow.js';
+import { inherits, accessorName, hasOwnProperty as has, error, extent } from '../../vega-util/build/vega-util.js';
+
+function partition (data, groupby) {
+  var groups = [],
+    get = function (f) {
+      return f(t);
+    },
+    map,
+    i,
+    n,
+    t,
+    k,
+    g;
+
+  // partition data points into stack groups
+  if (groupby == null) {
+    groups.push(data);
+  } else {
+    for (map = {}, i = 0, n = data.length; i < n; ++i) {
+      t = data[i];
+      k = groupby.map(get);
+      g = map[k];
+      if (!g) {
+        map[k] = g = [];
+        g.dims = k;
+        groups.push(g);
+      }
+      g.push(t);
+    }
+  }
+  return groups;
+}
+
+/**
+ * Compute locally-weighted regression fits for one or more data groups.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(object): *} params.x - An accessor for the predictor data field.
+ * @param {function(object): *} params.y - An accessor for the predicted data field.
+ * @param {Array<function(object): *>} [params.groupby] - An array of accessors to groupby.
+ * @param {number} [params.bandwidth=0.3] - The loess bandwidth.
+ */
+function Loess(params) {
+  Transform.call(this, null, params);
+}
+Loess.Definition = {
+  'type': 'Loess',
+  'metadata': {
+    'generates': true
+  },
+  'params': [{
+    'name': 'x',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'y',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'groupby',
+    'type': 'field',
+    'array': true
+  }, {
+    'name': 'bandwidth',
+    'type': 'number',
+    'default': 0.3
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'array': true
+  }]
+};
+inherits(Loess, Transform, {
+  transform(_, pulse) {
+    const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);
+    if (!this.value || pulse.changed() || _.modified()) {
+      const source = pulse.materialize(pulse.SOURCE).source,
+        groups = partition(source, _.groupby),
+        names = (_.groupby || []).map(accessorName),
+        m = names.length,
+        as = _.as || [accessorName(_.x), accessorName(_.y)],
+        values = [];
+      groups.forEach(g => {
+        loess(g, _.x, _.y, _.bandwidth || 0.3).forEach(p => {
+          const t = {};
+          for (let i = 0; i < m; ++i) {
+            t[names[i]] = g.dims[i];
+          }
+          t[as[0]] = p[0];
+          t[as[1]] = p[1];
+          values.push(ingest$1(t));
+        });
+      });
+      if (this.value) out.rem = this.value;
+      this.value = out.add = out.source = values;
+    }
+    return out;
+  }
+});
+
+const Methods = {
+  constant: constant,
+  linear: linear,
+  log: log,
+  exp: exp,
+  pow: pow,
+  quad: quad,
+  poly: poly
+};
+const degreesOfFreedom = (method, order) => method === 'poly' ? order : method === 'quad' ? 2 : 1;
+
+/**
+ * Compute regression fits for one or more data groups.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {function(object): *} params.x - An accessor for the predictor data field.
+ * @param {function(object): *} params.y - An accessor for the predicted data field.
+ * @param {string} [params.method='linear'] - The regression method to apply.
+ * @param {Array<function(object): *>} [params.groupby] - An array of accessors to groupby.
+ * @param {Array<number>} [params.extent] - The domain extent over which to plot the regression line.
+ * @param {number} [params.order=3] - The polynomial order. Only applies to the 'poly' method.
+ */
+function Regression(params) {
+  Transform.call(this, null, params);
+}
+Regression.Definition = {
+  'type': 'Regression',
+  'metadata': {
+    'generates': true
+  },
+  'params': [{
+    'name': 'x',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'y',
+    'type': 'field',
+    'required': true
+  }, {
+    'name': 'groupby',
+    'type': 'field',
+    'array': true
+  }, {
+    'name': 'method',
+    'type': 'string',
+    'default': 'linear',
+    'values': Object.keys(Methods)
+  }, {
+    'name': 'order',
+    'type': 'number',
+    'default': 3
+  }, {
+    'name': 'extent',
+    'type': 'number',
+    'array': true,
+    'length': 2
+  }, {
+    'name': 'params',
+    'type': 'boolean',
+    'default': false
+  }, {
+    'name': 'as',
+    'type': 'string',
+    'array': true
+  }]
+};
+inherits(Regression, Transform, {
+  transform(_, pulse) {
+    const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);
+    if (!this.value || pulse.changed() || _.modified()) {
+      const source = pulse.materialize(pulse.SOURCE).source,
+        groups = partition(source, _.groupby),
+        names = (_.groupby || []).map(accessorName),
+        method = _.method || 'linear',
+        order = _.order == null ? 3 : _.order,
+        dof = degreesOfFreedom(method, order),
+        as = _.as || [accessorName(_.x), accessorName(_.y)],
+        fit = Methods[method],
+        values = [];
+      let domain = _.extent;
+      if (!has(Methods, method)) {
+        error('Invalid regression method: ' + method);
+      }
+      if (domain != null) {
+        if (method === 'log' && domain[0] <= 0) {
+          pulse.dataflow.warn('Ignoring extent with values <= 0 for log regression.');
+          domain = null;
+        }
+      }
+      groups.forEach(g => {
+        const n = g.length;
+        if (n <= dof) {
+          pulse.dataflow.warn('Skipping regression with more parameters than data points.');
+          return;
+        }
+        const model = fit(g, _.x, _.y, order);
+        if (_.params) {
+          // if parameter vectors requested return those
+          values.push(ingest$1({
+            keys: g.dims,
+            coef: model.coef,
+            rSquared: model.rSquared
+          }));
+          return;
+        }
+        const dom = domain || extent(g, _.x),
+          add = p => {
+            const t = {};
+            for (let i = 0; i < names.length; ++i) {
+              t[names[i]] = g.dims[i];
+            }
+            t[as[0]] = p[0];
+            t[as[1]] = p[1];
+            values.push(ingest$1(t));
+          };
+        if (method === 'linear' || method === 'constant') {
+          // for linear or constant regression we only need the end points
+          dom.forEach(x => add([x, model.predict(x)]));
+        } else {
+          // otherwise return trend line sample points
+          sampleCurve(model.predict, dom, 25, 200).forEach(add);
+        }
+      });
+      if (this.value) out.rem = this.value;
+      this.value = out.add = out.source = values;
+    }
+    return out;
+  }
+});
+
+export { Loess as loess, Regression as regression };