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

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

@@ -1,295 +0,0 @@
-'use strict';
-
-var vegaDataflow = require('../../vega-dataflow/build/vega-dataflow.js');
-var vegaUtil = require('../../vega-util/build/vega-util.js');
-var simulation$1 = require('../../d3-force/src/simulation.js');
-var y = require('../../d3-force/src/y.js');
-var x = require('../../d3-force/src/x.js');
-var link = require('../../d3-force/src/link.js');
-var manyBody = require('../../d3-force/src/manyBody.js');
-var collide = require('../../d3-force/src/collide.js');
-var center = require('../../d3-force/src/center.js');
-
-const ForceMap = {
-  center: center.default,
-  collide: collide.default,
-  nbody: manyBody.default,
-  link: link.default,
-  x: x.default,
-  y: y.default
-};
-const Forces = 'forces',
-  ForceParams = ['alpha', 'alphaMin', 'alphaTarget', 'velocityDecay', 'forces'],
-  ForceConfig = ['static', 'iterations'],
-  ForceOutput = ['x', 'y', 'vx', 'vy'];
-
-/**
- * Force simulation layout.
- * @constructor
- * @param {object} params - The parameters for this operator.
- * @param {Array<object>} params.forces - The forces to apply.
- */
-function Force(params) {
-  vegaDataflow.Transform.call(this, null, params);
-}
-Force.Definition = {
-  'type': 'Force',
-  'metadata': {
-    'modifies': true
-  },
-  'params': [{
-    'name': 'static',
-    'type': 'boolean',
-    'default': false
-  }, {
-    'name': 'restart',
-    'type': 'boolean',
-    'default': false
-  }, {
-    'name': 'iterations',
-    'type': 'number',
-    'default': 300
-  }, {
-    'name': 'alpha',
-    'type': 'number',
-    'default': 1
-  }, {
-    'name': 'alphaMin',
-    'type': 'number',
-    'default': 0.001
-  }, {
-    'name': 'alphaTarget',
-    'type': 'number',
-    'default': 0
-  }, {
-    'name': 'velocityDecay',
-    'type': 'number',
-    'default': 0.4
-  }, {
-    'name': 'forces',
-    'type': 'param',
-    'array': true,
-    'params': [{
-      'key': {
-        'force': 'center'
-      },
-      'params': [{
-        'name': 'x',
-        'type': 'number',
-        'default': 0
-      }, {
-        'name': 'y',
-        'type': 'number',
-        'default': 0
-      }]
-    }, {
-      'key': {
-        'force': 'collide'
-      },
-      'params': [{
-        'name': 'radius',
-        'type': 'number',
-        'expr': true
-      }, {
-        'name': 'strength',
-        'type': 'number',
-        'default': 0.7
-      }, {
-        'name': 'iterations',
-        'type': 'number',
-        'default': 1
-      }]
-    }, {
-      'key': {
-        'force': 'nbody'
-      },
-      'params': [{
-        'name': 'strength',
-        'type': 'number',
-        'default': -30,
-        'expr': true
-      }, {
-        'name': 'theta',
-        'type': 'number',
-        'default': 0.9
-      }, {
-        'name': 'distanceMin',
-        'type': 'number',
-        'default': 1
-      }, {
-        'name': 'distanceMax',
-        'type': 'number'
-      }]
-    }, {
-      'key': {
-        'force': 'link'
-      },
-      'params': [{
-        'name': 'links',
-        'type': 'data'
-      }, {
-        'name': 'id',
-        'type': 'field'
-      }, {
-        'name': 'distance',
-        'type': 'number',
-        'default': 30,
-        'expr': true
-      }, {
-        'name': 'strength',
-        'type': 'number',
-        'expr': true
-      }, {
-        'name': 'iterations',
-        'type': 'number',
-        'default': 1
-      }]
-    }, {
-      'key': {
-        'force': 'x'
-      },
-      'params': [{
-        'name': 'strength',
-        'type': 'number',
-        'default': 0.1
-      }, {
-        'name': 'x',
-        'type': 'field'
-      }]
-    }, {
-      'key': {
-        'force': 'y'
-      },
-      'params': [{
-        'name': 'strength',
-        'type': 'number',
-        'default': 0.1
-      }, {
-        'name': 'y',
-        'type': 'field'
-      }]
-    }]
-  }, {
-    'name': 'as',
-    'type': 'string',
-    'array': true,
-    'modify': false,
-    'default': ForceOutput
-  }]
-};
-vegaUtil.inherits(Force, vegaDataflow.Transform, {
-  transform(_, pulse) {
-    var sim = this.value,
-      change = pulse.changed(pulse.ADD_REM),
-      params = _.modified(ForceParams),
-      iters = _.iterations || 300;
-
-    // configure simulation
-    if (!sim) {
-      this.value = sim = simulation(pulse.source, _);
-      sim.on('tick', rerun(pulse.dataflow, this));
-      if (!_.static) {
-        change = true;
-        sim.tick(); // ensure we run on init
-      }
-      pulse.modifies('index');
-    } else {
-      if (change) {
-        pulse.modifies('index');
-        sim.nodes(pulse.source);
-      }
-      if (params || pulse.changed(pulse.MOD)) {
-        setup(sim, _, 0, pulse);
-      }
-    }
-
-    // run simulation
-    if (params || change || _.modified(ForceConfig) || pulse.changed() && _.restart) {
-      sim.alpha(Math.max(sim.alpha(), _.alpha || 1)).alphaDecay(1 - Math.pow(sim.alphaMin(), 1 / iters));
-      if (_.static) {
-        for (sim.stop(); --iters >= 0;) sim.tick();
-      } else {
-        if (sim.stopped()) sim.restart();
-        if (!change) return pulse.StopPropagation; // defer to sim ticks
-      }
-    }
-    return this.finish(_, pulse);
-  },
-  finish(_, pulse) {
-    const dataflow = pulse.dataflow;
-
-    // inspect dependencies, touch link source data
-    for (let args = this._argops, j = 0, m = args.length, arg; j < m; ++j) {
-      arg = args[j];
-      if (arg.name !== Forces || arg.op._argval.force !== 'link') {
-        continue;
-      }
-      for (var ops = arg.op._argops, i = 0, n = ops.length, op; i < n; ++i) {
-        if (ops[i].name === 'links' && (op = ops[i].op.source)) {
-          dataflow.pulse(op, dataflow.changeset().reflow());
-          break;
-        }
-      }
-    }
-
-    // reflow all nodes
-    return pulse.reflow(_.modified()).modifies(ForceOutput);
-  }
-});
-function rerun(df, op) {
-  return () => df.touch(op).run();
-}
-function simulation(nodes, _) {
-  const sim = simulation$1.default(nodes),
-    stop = sim.stop,
-    restart = sim.restart;
-  let stopped = false;
-  sim.stopped = () => stopped;
-  sim.restart = () => (stopped = false, restart());
-  sim.stop = () => (stopped = true, stop());
-  return setup(sim, _, true).on('end', () => stopped = true);
-}
-function setup(sim, _, init, pulse) {
-  var f = vegaUtil.array(_.forces),
-    i,
-    n,
-    p,
-    name;
-  for (i = 0, n = ForceParams.length; i < n; ++i) {
-    p = ForceParams[i];
-    if (p !== Forces && _.modified(p)) sim[p](_[p]);
-  }
-  for (i = 0, n = f.length; i < n; ++i) {
-    name = Forces + i;
-    p = init || _.modified(Forces, i) ? getForce(f[i]) : pulse && modified(f[i], pulse) ? sim.force(name) : null;
-    if (p) sim.force(name, p);
-  }
-  for (n = sim.numForces || 0; i < n; ++i) {
-    sim.force(Forces + i, null); // remove
-  }
-  sim.numForces = f.length;
-  return sim;
-}
-function modified(f, pulse) {
-  var k, v;
-  for (k in f) {
-    if (vegaUtil.isFunction(v = f[k]) && pulse.modified(vegaUtil.accessorFields(v))) return 1;
-  }
-  return 0;
-}
-function getForce(_) {
-  var f, p;
-  if (!vegaUtil.hasOwnProperty(ForceMap, _.force)) {
-    vegaUtil.error('Unrecognized force: ' + _.force);
-  }
-  f = ForceMap[_.force]();
-  for (p in _) {
-    if (vegaUtil.isFunction(f[p])) setForceParam(f[p], _[p], _);
-  }
-  return f;
-}
-function setForceParam(f, v, _) {
-  f(vegaUtil.isFunction(v) ? d => v(d, _) : v);
-}
-
-exports.force = Force;

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

@@ -1,201 +0,0 @@
-'use strict';
-
-var vegaTime = require('../../vega-time/build/vega-time.js');
-var vegaUtil = require('../../vega-util/build/vega-util.js');
-var locale$1 = require('../../d3-format/src/locale.js');
-var locale$2 = require('../../d3-time-format/src/locale.js');
-var formatSpecifier = require('../../d3-format/src/formatSpecifier.js');
-var ticks = require('../../d3-array/src/ticks.js');
-var precisionFixed = require('../../d3-format/src/precisionFixed.js');
-var precisionRound = require('../../d3-format/src/precisionRound.js');
-var precisionPrefix = require('../../d3-format/src/precisionPrefix.js');
-var defaultLocale$1 = require('../../d3-format/src/defaultLocale.js');
-var defaultLocale$2 = require('../../d3-time-format/src/defaultLocale.js');
-
-function memoize (method) {
-  const cache = {};
-  return spec => cache[spec] || (cache[spec] = method(spec));
-}
-
-function trimZeroes(numberFormat, decimalChar) {
-  return x => {
-    const str = numberFormat(x),
-      dec = str.indexOf(decimalChar);
-    if (dec < 0) return str;
-    let idx = rightmostDigit(str, dec);
-    const end = idx < str.length ? str.slice(idx) : '';
-    while (--idx > dec) if (str[idx] !== '0') {
-      ++idx;
-      break;
-    }
-    return str.slice(0, idx) + end;
-  };
-}
-function rightmostDigit(str, dec) {
-  let i = str.lastIndexOf('e'),
-    c;
-  if (i > 0) return i;
-  for (i = str.length; --i > dec;) {
-    c = str.charCodeAt(i);
-    if (c >= 48 && c <= 57) return i + 1; // is digit
-  }
-}
-function numberLocale(locale) {
-  const format = memoize(locale.format),
-    formatPrefix = locale.formatPrefix;
-  return {
-    format,
-    formatPrefix,
-    formatFloat(spec) {
-      const s = formatSpecifier.default(spec || ',');
-      if (s.precision == null) {
-        s.precision = 12;
-        switch (s.type) {
-          case '%':
-            s.precision -= 2;
-            break;
-          case 'e':
-            s.precision -= 1;
-            break;
-        }
-        return trimZeroes(format(s),
-        // number format
-        format('.1f')(1)[1] // decimal point character
-        );
-      } else {
-        return format(s);
-      }
-    },
-    formatSpan(start, stop, count, specifier) {
-      specifier = formatSpecifier.default(specifier == null ? ',f' : specifier);
-      const step = ticks.tickStep(start, stop, count),
-        value = Math.max(Math.abs(start), Math.abs(stop));
-      let precision;
-      if (specifier.precision == null) {
-        switch (specifier.type) {
-          case 's':
-            {
-              if (!isNaN(precision = precisionPrefix.default(step, value))) {
-                specifier.precision = precision;
-              }
-              return formatPrefix(specifier, value);
-            }
-          case '':
-          case 'e':
-          case 'g':
-          case 'p':
-          case 'r':
-            {
-              if (!isNaN(precision = precisionRound.default(step, value))) {
-                specifier.precision = precision - (specifier.type === 'e');
-              }
-              break;
-            }
-          case 'f':
-          case '%':
-            {
-              if (!isNaN(precision = precisionFixed.default(step))) {
-                specifier.precision = precision - (specifier.type === '%') * 2;
-              }
-              break;
-            }
-        }
-      }
-      return format(specifier);
-    }
-  };
-}
-let defaultNumberLocale;
-resetNumberFormatDefaultLocale();
-function resetNumberFormatDefaultLocale() {
-  return defaultNumberLocale = numberLocale({
-    format: defaultLocale$1.format,
-    formatPrefix: defaultLocale$1.formatPrefix
-  });
-}
-function numberFormatLocale(definition) {
-  return numberLocale(locale$1.default(definition));
-}
-function numberFormatDefaultLocale(definition) {
-  return arguments.length ? defaultNumberLocale = numberFormatLocale(definition) : defaultNumberLocale;
-}
-
-function timeMultiFormat(format, interval, spec) {
-  spec = spec || {};
-  if (!vegaUtil.isObject(spec)) {
-    vegaUtil.error(`Invalid time multi-format specifier: ${spec}`);
-  }
-  const second = interval(vegaTime.SECONDS),
-    minute = interval(vegaTime.MINUTES),
-    hour = interval(vegaTime.HOURS),
-    day = interval(vegaTime.DATE),
-    week = interval(vegaTime.WEEK),
-    month = interval(vegaTime.MONTH),
-    quarter = interval(vegaTime.QUARTER),
-    year = interval(vegaTime.YEAR),
-    L = format(spec[vegaTime.MILLISECONDS] || '.%L'),
-    S = format(spec[vegaTime.SECONDS] || ':%S'),
-    M = format(spec[vegaTime.MINUTES] || '%I:%M'),
-    H = format(spec[vegaTime.HOURS] || '%I %p'),
-    d = format(spec[vegaTime.DATE] || spec[vegaTime.DAY] || '%a %d'),
-    w = format(spec[vegaTime.WEEK] || '%b %d'),
-    m = format(spec[vegaTime.MONTH] || '%B'),
-    q = format(spec[vegaTime.QUARTER] || '%B'),
-    y = format(spec[vegaTime.YEAR] || '%Y');
-  return date => (second(date) < date ? L : minute(date) < date ? S : hour(date) < date ? M : day(date) < date ? H : month(date) < date ? week(date) < date ? d : w : year(date) < date ? quarter(date) < date ? m : q : y)(date);
-}
-function timeLocale(locale) {
-  const timeFormat = memoize(locale.format),
-    utcFormat = memoize(locale.utcFormat);
-  return {
-    timeFormat: spec => vegaUtil.isString(spec) ? timeFormat(spec) : timeMultiFormat(timeFormat, vegaTime.timeInterval, spec),
-    utcFormat: spec => vegaUtil.isString(spec) ? utcFormat(spec) : timeMultiFormat(utcFormat, vegaTime.utcInterval, spec),
-    timeParse: memoize(locale.parse),
-    utcParse: memoize(locale.utcParse)
-  };
-}
-let defaultTimeLocale;
-resetTimeFormatDefaultLocale();
-function resetTimeFormatDefaultLocale() {
-  return defaultTimeLocale = timeLocale({
-    format: defaultLocale$2.timeFormat,
-    parse: defaultLocale$2.timeParse,
-    utcFormat: defaultLocale$2.utcFormat,
-    utcParse: defaultLocale$2.utcParse
-  });
-}
-function timeFormatLocale(definition) {
-  return timeLocale(locale$2.default(definition));
-}
-function timeFormatDefaultLocale(definition) {
-  return arguments.length ? defaultTimeLocale = timeFormatLocale(definition) : defaultTimeLocale;
-}
-
-const createLocale = (number, time) => vegaUtil.extend({}, number, time);
-function locale(numberSpec, timeSpec) {
-  const number = numberSpec ? numberFormatLocale(numberSpec) : numberFormatDefaultLocale();
-  const time = timeSpec ? timeFormatLocale(timeSpec) : timeFormatDefaultLocale();
-  return createLocale(number, time);
-}
-function defaultLocale(numberSpec, timeSpec) {
-  const args = arguments.length;
-  if (args && args !== 2) {
-    vegaUtil.error('defaultLocale expects either zero or two arguments.');
-  }
-  return args ? createLocale(numberFormatDefaultLocale(numberSpec), timeFormatDefaultLocale(timeSpec)) : createLocale(numberFormatDefaultLocale(), timeFormatDefaultLocale());
-}
-function resetDefaultLocale() {
-  resetNumberFormatDefaultLocale();
-  resetTimeFormatDefaultLocale();
-  return defaultLocale();
-}
-
-exports.defaultLocale = defaultLocale;
-exports.locale = locale;
-exports.numberFormatDefaultLocale = numberFormatDefaultLocale;
-exports.numberFormatLocale = numberFormatLocale;
-exports.resetDefaultLocale = resetDefaultLocale;
-exports.resetNumberFormatDefaultLocale = resetNumberFormatDefaultLocale;
-exports.resetTimeFormatDefaultLocale = resetTimeFormatDefaultLocale;
-exports.timeFormatDefaultLocale = timeFormatDefaultLocale;
-exports.timeFormatLocale = timeFormatLocale;