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

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

@@ -0,0 +1,293 @@
+import { Transform } from '../../vega-dataflow/build/vega-dataflow.js';
+import { inherits, array, isFunction, accessorFields, hasOwnProperty as has, error } from '../../vega-util/build/vega-util.js';
+import forceSimulation from '../../d3-force/src/simulation.js';
+import forceY from '../../d3-force/src/y.js';
+import forceX from '../../d3-force/src/x.js';
+import forceLink from '../../d3-force/src/link.js';
+import forceManyBody from '../../d3-force/src/manyBody.js';
+import forceCollide from '../../d3-force/src/collide.js';
+import forceCenter from '../../d3-force/src/center.js';
+
+const ForceMap = {
+  center: forceCenter,
+  collide: forceCollide,
+  nbody: forceManyBody,
+  link: forceLink,
+  x: forceX,
+  y: forceY
+};
+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) {
+  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
+  }]
+};
+inherits(Force, 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 = forceSimulation(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 = 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 (isFunction(v = f[k]) && pulse.modified(accessorFields(v))) return 1;
+  }
+  return 0;
+}
+function getForce(_) {
+  var f, p;
+  if (!has(ForceMap, _.force)) {
+    error('Unrecognized force: ' + _.force);
+  }
+  f = ForceMap[_.force]();
+  for (p in _) {
+    if (isFunction(f[p])) setForceParam(f[p], _[p], _);
+  }
+  return f;
+}
+function setForceParam(f, v, _) {
+  f(isFunction(v) ? d => v(d, _) : v);
+}
+
+export { Force as force };

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

@@ -0,0 +1,191 @@
+import { SECONDS, MINUTES, HOURS, DATE, WEEK, MONTH, QUARTER, YEAR, MILLISECONDS, DAY, utcInterval, timeInterval } from '../../vega-time/build/vega-time.js';
+import { error, extend, isString, isObject } from '../../vega-util/build/vega-util.js';
+import formatLocale from '../../d3-format/src/locale.js';
+import formatLocale$1 from '../../d3-time-format/src/locale.js';
+import formatSpecifier from '../../d3-format/src/formatSpecifier.js';
+import { tickStep } from '../../d3-array/src/ticks.js';
+import precisionFixed from '../../d3-format/src/precisionFixed.js';
+import precisionRound from '../../d3-format/src/precisionRound.js';
+import precisionPrefix from '../../d3-format/src/precisionPrefix.js';
+import { format, formatPrefix } from '../../d3-format/src/defaultLocale.js';
+import { timeFormat, utcFormat, utcParse, timeParse } from '../../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(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(specifier == null ? ',f' : specifier);
+      const step = 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(step, value))) {
+                specifier.precision = precision;
+              }
+              return formatPrefix(specifier, value);
+            }
+          case '':
+          case 'e':
+          case 'g':
+          case 'p':
+          case 'r':
+            {
+              if (!isNaN(precision = precisionRound(step, value))) {
+                specifier.precision = precision - (specifier.type === 'e');
+              }
+              break;
+            }
+          case 'f':
+          case '%':
+            {
+              if (!isNaN(precision = precisionFixed(step))) {
+                specifier.precision = precision - (specifier.type === '%') * 2;
+              }
+              break;
+            }
+        }
+      }
+      return format(specifier);
+    }
+  };
+}
+let defaultNumberLocale;
+resetNumberFormatDefaultLocale();
+function resetNumberFormatDefaultLocale() {
+  return defaultNumberLocale = numberLocale({
+    format: format,
+    formatPrefix: formatPrefix
+  });
+}
+function numberFormatLocale(definition) {
+  return numberLocale(formatLocale(definition));
+}
+function numberFormatDefaultLocale(definition) {
+  return arguments.length ? defaultNumberLocale = numberFormatLocale(definition) : defaultNumberLocale;
+}
+
+function timeMultiFormat(format, interval, spec) {
+  spec = spec || {};
+  if (!isObject(spec)) {
+    error(`Invalid time multi-format specifier: ${spec}`);
+  }
+  const second = interval(SECONDS),
+    minute = interval(MINUTES),
+    hour = interval(HOURS),
+    day = interval(DATE),
+    week = interval(WEEK),
+    month = interval(MONTH),
+    quarter = interval(QUARTER),
+    year = interval(YEAR),
+    L = format(spec[MILLISECONDS] || '.%L'),
+    S = format(spec[SECONDS] || ':%S'),
+    M = format(spec[MINUTES] || '%I:%M'),
+    H = format(spec[HOURS] || '%I %p'),
+    d = format(spec[DATE] || spec[DAY] || '%a %d'),
+    w = format(spec[WEEK] || '%b %d'),
+    m = format(spec[MONTH] || '%B'),
+    q = format(spec[QUARTER] || '%B'),
+    y = format(spec[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 => isString(spec) ? timeFormat(spec) : timeMultiFormat(timeFormat, timeInterval, spec),
+    utcFormat: spec => isString(spec) ? utcFormat(spec) : timeMultiFormat(utcFormat, utcInterval, spec),
+    timeParse: memoize(locale.parse),
+    utcParse: memoize(locale.utcParse)
+  };
+}
+let defaultTimeLocale;
+resetTimeFormatDefaultLocale();
+function resetTimeFormatDefaultLocale() {
+  return defaultTimeLocale = timeLocale({
+    format: timeFormat,
+    parse: timeParse,
+    utcFormat: utcFormat,
+    utcParse: utcParse
+  });
+}
+function timeFormatLocale(definition) {
+  return timeLocale(formatLocale$1(definition));
+}
+function timeFormatDefaultLocale(definition) {
+  return arguments.length ? defaultTimeLocale = timeFormatLocale(definition) : defaultTimeLocale;
+}
+
+const createLocale = (number, time) => 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) {
+    error('defaultLocale expects either zero or two arguments.');
+  }
+  return args ? createLocale(numberFormatDefaultLocale(numberSpec), timeFormatDefaultLocale(timeSpec)) : createLocale(numberFormatDefaultLocale(), timeFormatDefaultLocale());
+}
+function resetDefaultLocale() {
+  resetNumberFormatDefaultLocale();
+  resetTimeFormatDefaultLocale();
+  return defaultLocale();
+}
+
+export { defaultLocale, locale, numberFormatDefaultLocale, numberFormatLocale, resetDefaultLocale, resetNumberFormatDefaultLocale, resetTimeFormatDefaultLocale, timeFormatDefaultLocale, timeFormatLocale };