dtable-ui-component 0.1.71 → 0.1.75-beta

package/es/utils/unified/index.js

@@ -0,0 +1,470 @@
+'use strict';
+/* Dependencies. */
+
+var extend = require('extend');
+
+var bail = require('bail');
+
+var vfile = require('../vfile');
+
+var trough = require('trough');
+
+var string = require('x-is-string');
+
+var plain = require('is-plain-obj');
+/* Expose a frozen processor. */
+
+
+module.exports = unified().freeze();
+var slice = [].slice;
+var own = {}.hasOwnProperty;
+/* Process pipeline. */
+
+var pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);
+
+function pipelineParse(p, ctx) {
+  ctx.tree = p.parse(ctx.file);
+}
+
+function pipelineRun(p, ctx, next) {
+  p.run(ctx.tree, ctx.file, done);
+
+  function done(err, tree, file) {
+    if (err) {
+      next(err);
+    } else {
+      ctx.tree = tree;
+      ctx.file = file;
+      next();
+    }
+  }
+}
+
+function pipelineStringify(p, ctx) {
+  ctx.file.contents = p.stringify(ctx.tree, ctx.file);
+}
+/* Function to create the first processor. */
+
+
+function unified() {
+  var attachers = [];
+  var transformers = trough();
+  var namespace = {};
+  var frozen = false;
+  var freezeIndex = -1;
+  /* Data management. */
+
+  processor.data = data;
+  /* Lock. */
+
+  processor.freeze = freeze;
+  /* Plug-ins. */
+
+  processor.attachers = attachers;
+  processor.use = use;
+  /* API. */
+
+  processor.parse = parse;
+  processor.stringify = stringify;
+  processor.run = run;
+  processor.runSync = runSync;
+  processor.process = process;
+  processor.processSync = processSync;
+  /* Expose. */
+
+  return processor;
+  /* Create a new processor based on the processor
+   * in the current scope. */
+
+  function processor() {
+    var destination = unified();
+    var length = attachers.length;
+    var index = -1;
+
+    while (++index < length) {
+      destination.use.apply(null, attachers[index]);
+    }
+
+    destination.data(extend(true, {}, namespace));
+    return destination;
+  }
+  /* Freeze: used to signal a processor that has finished
+   * configuration.
+   *
+   * For example, take unified itself.  It’s frozen.
+   * Plug-ins should not be added to it.  Rather, it should
+   * be extended, by invoking it, before modifying it.
+   *
+   * In essence, always invoke this when exporting a
+   * processor. */
+
+
+  function freeze() {
+    var values;
+    var plugin;
+    var options;
+    var transformer;
+
+    if (frozen) {
+      return processor;
+    }
+
+    while (++freezeIndex < attachers.length) {
+      values = attachers[freezeIndex];
+      plugin = values[0];
+      options = values[1];
+      transformer = null;
+
+      if (options === false) {
+        continue;
+      }
+
+      if (options === true) {
+        values[1] = undefined;
+      }
+
+      transformer = plugin.apply(processor, values.slice(1));
+
+      if (typeof transformer === 'function') {
+        transformers.use(transformer);
+      }
+    }
+
+    frozen = true;
+    freezeIndex = Infinity;
+    return processor;
+  }
+  /* Data management.
+   * Getter / setter for processor-specific informtion. */
+
+
+  function data(key, value) {
+    if (string(key)) {
+      /* Set `key`. */
+      if (arguments.length === 2) {
+        assertUnfrozen('data', frozen);
+        namespace[key] = value;
+        return processor;
+      }
+      /* Get `key`. */
+
+
+      return own.call(namespace, key) && namespace[key] || null;
+    }
+    /* Set space. */
+
+
+    if (key) {
+      assertUnfrozen('data', frozen);
+      namespace = key;
+      return processor;
+    }
+    /* Get space. */
+
+
+    return namespace;
+  }
+  /* Plug-in management.
+   *
+   * Pass it:
+   * *   an attacher and options,
+   * *   a preset,
+   * *   a list of presets, attachers, and arguments (list
+   *     of attachers and options). */
+
+
+  function use(value) {
+    var settings;
+    assertUnfrozen('use', frozen);
+
+    if (value === null || value === undefined) {
+      /* Empty */
+    } else if (typeof value === 'function') {
+      addPlugin.apply(null, arguments);
+    } else if (typeof value === 'object') {
+      if ('length' in value) {
+        addList(value);
+      } else {
+        addPreset(value);
+      }
+    } else {
+      throw new Error('Expected usable value, not `' + value + '`');
+    }
+
+    if (settings) {
+      namespace.settings = extend(namespace.settings || {}, settings);
+    }
+
+    return processor;
+
+    function addPreset(result) {
+      addList(result.plugins);
+
+      if (result.settings) {
+        settings = extend(settings || {}, result.settings);
+      }
+    }
+
+    function add(value) {
+      if (typeof value === 'function') {
+        addPlugin(value);
+      } else if (typeof value === 'object') {
+        if ('length' in value) {
+          addPlugin.apply(null, value);
+        } else {
+          addPreset(value);
+        }
+      } else {
+        throw new Error('Expected usable value, not `' + value + '`');
+      }
+    }
+
+    function addList(plugins) {
+      var length;
+      var index;
+
+      if (plugins === null || plugins === undefined) {
+        /* Empty */
+      } else if (typeof plugins === 'object' && 'length' in plugins) {
+        length = plugins.length;
+        index = -1;
+
+        while (++index < length) {
+          add(plugins[index]);
+        }
+      } else {
+        throw new Error('Expected a list of plugins, not `' + plugins + '`');
+      }
+    }
+
+    function addPlugin(plugin, value) {
+      var entry = find(plugin);
+
+      if (entry) {
+        if (plain(entry[1]) && plain(value)) {
+          value = extend(entry[1], value);
+        }
+
+        entry[1] = value;
+      } else {
+        attachers.push(slice.call(arguments));
+      }
+    }
+  }
+
+  function find(plugin) {
+    var length = attachers.length;
+    var index = -1;
+    var entry;
+
+    while (++index < length) {
+      entry = attachers[index];
+
+      if (entry[0] === plugin) {
+        return entry;
+      }
+    }
+  }
+  /* Parse a file (in string or VFile representation)
+   * into a Unist node using the `Parser` on the
+   * processor. */
+
+
+  function parse(doc) {
+    var file = vfile(doc);
+    var Parser;
+    freeze();
+    Parser = processor.Parser;
+    assertParser('parse', Parser);
+
+    if (newable(Parser)) {
+      return new Parser(String(file), file).parse();
+    }
+
+    return Parser(String(file), file); // eslint-disable-line new-cap
+  }
+  /* Run transforms on a Unist node representation of a file
+   * (in string or VFile representation), async. */
+
+
+  function run(node, file, cb) {
+    assertNode(node);
+    freeze();
+
+    if (!cb && typeof file === 'function') {
+      cb = file;
+      file = null;
+    }
+
+    if (!cb) {
+      return new Promise(executor);
+    }
+
+    executor(null, cb);
+
+    function executor(resolve, reject) {
+      transformers.run(node, vfile(file), done);
+
+      function done(err, tree, file) {
+        tree = tree || node;
+
+        if (err) {
+          reject(err);
+        } else if (resolve) {
+          resolve(tree);
+        } else {
+          cb(null, tree, file);
+        }
+      }
+    }
+  }
+  /* Run transforms on a Unist node representation of a file
+   * (in string or VFile representation), sync. */
+
+
+  function runSync(node, file) {
+    var complete = false;
+    var result;
+    run(node, file, done);
+    assertDone('runSync', 'run', complete);
+    return result;
+
+    function done(err, tree) {
+      complete = true;
+      bail(err);
+      result = tree;
+    }
+  }
+  /* Stringify a Unist node representation of a file
+   * (in string or VFile representation) into a string
+   * using the `Compiler` on the processor. */
+
+
+  function stringify(node, doc) {
+    var file = vfile(doc);
+    var Compiler;
+    freeze();
+    Compiler = processor.Compiler;
+    assertCompiler('stringify', Compiler);
+    assertNode(node);
+
+    if (newable(Compiler)) {
+      return new Compiler(node, file).compile();
+    }
+
+    return Compiler(node, file); // eslint-disable-line new-cap
+  }
+  /* Parse a file (in string or VFile representation)
+   * into a Unist node using the `Parser` on the processor,
+   * then run transforms on that node, and compile the
+   * resulting node using the `Compiler` on the processor,
+   * and store that result on the VFile. */
+
+
+  function process(doc, cb) {
+    freeze();
+    assertParser('process', processor.Parser);
+    assertCompiler('process', processor.Compiler);
+
+    if (!cb) {
+      return new Promise(executor);
+    }
+
+    executor(null, cb);
+
+    function executor(resolve, reject) {
+      var file = vfile(doc);
+      pipeline.run(processor, {
+        file: file
+      }, done);
+
+      function done(err) {
+        if (err) {
+          reject(err);
+        } else if (resolve) {
+          resolve(file);
+        } else {
+          cb(null, file);
+        }
+      }
+    }
+  }
+  /* Process the given document (in string or VFile
+   * representation), sync. */
+
+
+  function processSync(doc) {
+    var complete = false;
+    var file;
+    freeze();
+    assertParser('processSync', processor.Parser);
+    assertCompiler('processSync', processor.Compiler);
+    file = vfile(doc);
+    process(file, done);
+    assertDone('processSync', 'process', complete);
+    return file;
+
+    function done(err) {
+      complete = true;
+      bail(err);
+    }
+  }
+}
+/* Check if `func` is a constructor. */
+
+
+function newable(value) {
+  return typeof value === 'function' && keys(value.prototype);
+}
+/* Check if `value` is an object with keys. */
+
+
+function keys(value) {
+  var key;
+
+  for (key in value) {
+    return true;
+  }
+
+  return false;
+}
+/* Assert a parser is available. */
+
+
+function assertParser(name, Parser) {
+  if (typeof Parser !== 'function') {
+    throw new Error('Cannot `' + name + '` without `Parser`');
+  }
+}
+/* Assert a compiler is available. */
+
+
+function assertCompiler(name, Compiler) {
+  if (typeof Compiler !== 'function') {
+    throw new Error('Cannot `' + name + '` without `Compiler`');
+  }
+}
+/* Assert the processor is not frozen. */
+
+
+function assertUnfrozen(name, frozen) {
+  if (frozen) {
+    throw new Error(['Cannot invoke `' + name + '` on a frozen processor.\nCreate a new ', 'processor first, by invoking it: use `processor()` instead of ', '`processor`.'].join(''));
+  }
+}
+/* Assert `node` is a Unist node. */
+
+
+function assertNode(node) {
+  if (!node || !string(node.type)) {
+    throw new Error('Expected node, got `' + node + '`');
+  }
+}
+/* Assert that `complete` is `true`. */
+
+
+function assertDone(name, asyncName, complete) {
+  if (!complete) {
+    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');
+  }
+}

package/es/utils/vfile/core.js

@@ -0,0 +1,172 @@
+'use strict';
+
+var path = require('path');
+
+var replace = require('replace-ext');
+
+var buffer = require('is-buffer');
+
+module.exports = VFile;
+var own = {}.hasOwnProperty;
+var proto = VFile.prototype;
+proto.toString = toString;
+/* Order of setting (least specific to most), we need this because
+ * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path
+ * is needed before a stem can be set. */
+
+var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
+/* Construct a new file. */
+
+function VFile(options) {
+  var prop;
+  var index;
+  var length;
+
+  if (typeof options === 'number') {
+    options = options.toString();
+  }
+
+  if (!options) {
+    options = {};
+  } else if (typeof options === 'string' || buffer(options)) {
+    options = {
+      contents: options
+    };
+  } else if ('message' in options && 'messages' in options) {
+    return options;
+  }
+
+  if (!(this instanceof VFile)) {
+    return new VFile(options);
+  }
+
+  this.data = {};
+  this.messages = [];
+  this.history = [];
+  this.cwd = process.cwd();
+  /* Set path related properties in the correct order. */
+
+  index = -1;
+  length = order.length;
+
+  while (++index < length) {
+    prop = order[index];
+
+    if (own.call(options, prop)) {
+      this[prop] = options[prop];
+    }
+  }
+  /* Set non-path related properties. */
+
+
+  for (prop in options) {
+    if (order.indexOf(prop) === -1) {
+      this[prop] = options[prop];
+    }
+  }
+}
+/* Access full path (`~/index.min.js`). */
+
+
+Object.defineProperty(proto, 'path', {
+  get: function get() {
+    return this.history[this.history.length - 1];
+  },
+  set: function set(path) {
+    assertNonEmpty(path, 'path');
+
+    if (path !== this.path) {
+      this.history.push(path);
+    }
+  }
+});
+/* Access parent path (`~`). */
+
+Object.defineProperty(proto, 'dirname', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;
+  },
+  set: function set(dirname) {
+    assertPath(this.path, 'dirname');
+    this.path = path.join(dirname || '', this.basename);
+  }
+});
+/* Access basename (`index.min.js`). */
+
+Object.defineProperty(proto, 'basename', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.basename(this.path) : undefined;
+  },
+  set: function set(basename) {
+    assertNonEmpty(basename, 'basename');
+    assertPart(basename, 'basename');
+    this.path = path.join(this.dirname || '', basename);
+  }
+});
+/* Access extname (`.js`). */
+
+Object.defineProperty(proto, 'extname', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.extname(this.path) : undefined;
+  },
+  set: function set(extname) {
+    var ext = extname || '';
+    assertPart(ext, 'extname');
+    assertPath(this.path, 'extname');
+
+    if (ext) {
+      if (ext.charAt(0) !== '.') {
+        throw new Error('`extname` must start with `.`');
+      }
+
+      if (ext.indexOf('.', 1) !== -1) {
+        throw new Error('`extname` cannot contain multiple dots');
+      }
+    }
+
+    this.path = replace(this.path, ext);
+  }
+});
+/* Access stem (`index.min`). */
+
+Object.defineProperty(proto, 'stem', {
+  get: function get() {
+    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;
+  },
+  set: function set(stem) {
+    assertNonEmpty(stem, 'stem');
+    assertPart(stem, 'stem');
+    this.path = path.join(this.dirname || '', stem + (this.extname || ''));
+  }
+});
+/* Get the value of the file. */
+
+function toString(encoding) {
+  var value = this.contents || '';
+  return buffer(value) ? value.toString(encoding) : String(value);
+}
+/* Assert that `part` is not a path (i.e., does
+ * not contain `path.sep`). */
+
+
+function assertPart(part, name) {
+  if (part.indexOf(path.sep) !== -1) {
+    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');
+  }
+}
+/* Assert that `part` is not empty. */
+
+
+function assertNonEmpty(part, name) {
+  if (!part) {
+    throw new Error('`' + name + '` cannot be empty');
+  }
+}
+/* Assert `path` exists. */
+
+
+function assertPath(path, name) {
+  if (!path) {
+    throw new Error('Setting `' + name + '` requires `path` to be set too');
+  }
+}

package/es/utils/vfile/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var VMessage = require('vfile-message');
+
+var VFile = require('./core.js');
+
+module.exports = VFile;
+var proto = VFile.prototype;
+proto.message = message;
+proto.info = info;
+proto.fail = fail;
+/* Slight backwards compatibility.  Remove in the future. */
+
+proto.warn = message;
+/* Create a message with `reason` at `position`.
+ * When an error is passed in as `reason`, copies the stack. */
+
+function message(reason, position, origin) {
+  var filePath = this.path;
+  var message = new VMessage(reason, position, origin);
+
+  if (filePath) {
+    message.name = filePath + ':' + message.name;
+    message.file = filePath;
+  }
+
+  message.fatal = false;
+  this.messages.push(message);
+  return message;
+}
+/* Fail. Creates a vmessage, associates it with the file,
+ * and throws it. */
+
+
+function fail() {
+  var message = this.message.apply(this, arguments);
+  message.fatal = true;
+  throw message;
+}
+/* Info. Creates a vmessage, associates it with the file,
+ * and marks the fatality as null. */
+
+
+function info() {
+  var message = this.message.apply(this, arguments);
+  message.fatal = null;
+  return message;
+}