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

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

@@ -0,0 +1,295 @@
+'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

@@ -0,0 +1,201 @@
+'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;