@veritone-ce/design-system 2.8.13-next.1 → 2.8.13

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

@@ -1,90 +0,0 @@
-'use strict';
-
-var vegaScale = require('../../vega-scale/build/vega-scale.js');
-var index = require('../../d3-geo/src/path/index.js');
-var transverseMercator = require('../../d3-geo/src/projection/transverseMercator.js');
-var stereographic = require('../../d3-geo/src/projection/stereographic.js');
-var orthographic = require('../../d3-geo/src/projection/orthographic.js');
-var naturalEarth1 = require('../../d3-geo/src/projection/naturalEarth1.js');
-var mollweide = require('../../d3-geo-projection/src/mollweide.js');
-var mercator = require('../../d3-geo/src/projection/mercator.js');
-var identity = require('../../d3-geo/src/projection/identity.js');
-var gnomonic = require('../../d3-geo/src/projection/gnomonic.js');
-var equirectangular = require('../../d3-geo/src/projection/equirectangular.js');
-var equalEarth = require('../../d3-geo/src/projection/equalEarth.js');
-var conicEquidistant = require('../../d3-geo/src/projection/conicEquidistant.js');
-var conicEqualArea = require('../../d3-geo/src/projection/conicEqualArea.js');
-var conicConformal = require('../../d3-geo/src/projection/conicConformal.js');
-var azimuthalEquidistant = require('../../d3-geo/src/projection/azimuthalEquidistant.js');
-var azimuthalEqualArea = require('../../d3-geo/src/projection/azimuthalEqualArea.js');
-var albersUsa = require('../../d3-geo/src/projection/albersUsa.js');
-var albers = require('../../d3-geo/src/projection/albers.js');
-
-const defaultPath = index.default();
-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 = index.default().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 vegaScale.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: albers.default,
-  albersusa: albersUsa.default,
-  azimuthalequalarea: azimuthalEqualArea.default,
-  azimuthalequidistant: azimuthalEquidistant.default,
-  conicconformal: conicConformal.default,
-  conicequalarea: conicEqualArea.default,
-  conicequidistant: conicEquidistant.default,
-  equalEarth: equalEarth.default,
-  equirectangular: equirectangular.default,
-  gnomonic: gnomonic.default,
-  identity: identity.default,
-  mercator: mercator.default,
-  mollweide: mollweide.default,
-  naturalEarth1: naturalEarth1.default,
-  orthographic: orthographic.default,
-  stereographic: stereographic.default,
-  transversemercator: transverseMercator.default
-};
-for (const key in projections) {
-  projection(key, projections[key]);
-}
-
-exports.getProjectionPath = getProjectionPath;
-exports.projection = projection;
-exports.projectionProperties = projectionProperties;

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

@@ -1,236 +0,0 @@
-'use strict';
-
-var vegaStatistics = require('../../vega-statistics/build/vega-statistics.js');
-var vegaDataflow = require('../../vega-dataflow/build/vega-dataflow.js');
-var vegaUtil = require('../../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) {
-  vegaDataflow.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
-  }]
-};
-vegaUtil.inherits(Loess, vegaDataflow.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(vegaUtil.accessorName),
-        m = names.length,
-        as = _.as || [vegaUtil.accessorName(_.x), vegaUtil.accessorName(_.y)],
-        values = [];
-      groups.forEach(g => {
-        vegaStatistics.regressionLoess(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(vegaDataflow.ingest(t));
-        });
-      });
-      if (this.value) out.rem = this.value;
-      this.value = out.add = out.source = values;
-    }
-    return out;
-  }
-});
-
-const Methods = {
-  constant: vegaStatistics.regressionConstant,
-  linear: vegaStatistics.regressionLinear,
-  log: vegaStatistics.regressionLog,
-  exp: vegaStatistics.regressionExp,
-  pow: vegaStatistics.regressionPow,
-  quad: vegaStatistics.regressionQuad,
-  poly: vegaStatistics.regressionPoly
-};
-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) {
-  vegaDataflow.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
-  }]
-};
-vegaUtil.inherits(Regression, vegaDataflow.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(vegaUtil.accessorName),
-        method = _.method || 'linear',
-        order = _.order == null ? 3 : _.order,
-        dof = degreesOfFreedom(method, order),
-        as = _.as || [vegaUtil.accessorName(_.x), vegaUtil.accessorName(_.y)],
-        fit = Methods[method],
-        values = [];
-      let domain = _.extent;
-      if (!vegaUtil.hasOwnProperty(Methods, method)) {
-        vegaUtil.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(vegaDataflow.ingest({
-            keys: g.dims,
-            coef: model.coef,
-            rSquared: model.rSquared
-          }));
-          return;
-        }
-        const dom = domain || vegaUtil.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(vegaDataflow.ingest(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
-          vegaStatistics.sampleCurve(model.predict, dom, 25, 200).forEach(add);
-        }
-      });
-      if (this.value) out.rem = this.value;
-      this.value = out.add = out.source = values;
-    }
-    return out;
-  }
-});
-
-exports.loess = Loess;
-exports.regression = Regression;