deku 0.1.0

data/deps/node_modules/deku/lib/stringify.js

@@ -0,0 +1,105 @@
+var utils = require('./utils')
+var defaults = utils.defaults
+
+/**
+ * Expose `stringify`.
+ */
+
+module.exports = function (app) {
+  if (!app.element) {
+    throw new Error('No element mounted')
+  }
+
+  /**
+   * Render to string.
+   *
+   * @param {Component} component
+   * @param {Object} [props]
+   * @return {String}
+   */
+
+  function stringify (component, optProps) {
+    var propTypes = component.propTypes || {}
+    var state = component.initialState ? component.initialState() : {}
+    var props = defaults(optProps, component.defaultProps || {})
+
+    for (var name in propTypes) {
+      var options = propTypes[name]
+      if (options.source) {
+        props[name] = app.sources[options.source]
+      }
+    }
+
+    if (component.beforeMount) component.beforeMount({ props: props, state: state })
+    if (component.beforeRender) component.beforeRender({ props: props, state: state })
+    var node = component.render({ props: props, state: state })
+    return stringifyNode(node, '0')
+  }
+
+  /**
+   * Render a node to a string
+   *
+   * @param {Node} node
+   * @param {Tree} tree
+   *
+   * @return {String}
+   */
+
+  function stringifyNode (node, path) {
+    switch (node.type) {
+      case 'text': return node.data
+      case 'element':
+        var children = node.children
+        var attributes = node.attributes
+        var tagName = node.tagName
+        var innerHTML = attributes.innerHTML
+        var str = '<' + tagName + attrs(attributes) + '>'
+
+        if (innerHTML) {
+          str += innerHTML
+        } else {
+          for (var i = 0, n = children.length; i < n; i++) {
+            str += stringifyNode(children[i], path + '.' + i)
+          }
+        }
+
+        str += '</' + tagName + '>'
+        return str
+      case 'component': return stringify(node.component, node.props)
+    }
+
+    throw new Error('Invalid type')
+  }
+
+  return stringifyNode(app.element, '0')
+}
+
+/**
+ * HTML attributes to string.
+ *
+ * @param {Object} attributes
+ * @return {String}
+ * @api private
+ */
+
+function attrs (attributes) {
+  var str = ''
+  for (var key in attributes) {
+    if (key === 'innerHTML') continue
+    str += attr(key, attributes[key])
+  }
+  return str
+}
+
+/**
+ * HTML attribute to string.
+ *
+ * @param {String} key
+ * @param {String} val
+ * @return {String}
+ * @api private
+ */
+
+function attr (key, val) {
+  return ' ' + key + '="' + val + '"'
+}

data/deps/node_modules/deku/lib/svg.js

@@ -0,0 +1,107 @@
+var fast = require('fast.js')
+var indexOf = fast.indexOf
+
+/**
+ * This file lists the supported SVG elements used by the
+ * renderer. We may add better SVG support in the future
+ * that doesn't require whitelisting elements.
+ */
+
+exports.namespace  = 'http://www.w3.org/2000/svg'
+
+/**
+ * Supported SVG elements
+ *
+ * @type {Array}
+ */
+
+exports.elements = [
+  'circle',
+  'defs',
+  'ellipse',
+  'g',
+  'line',
+  'linearGradient',
+  'mask',
+  'path',
+  'pattern',
+  'polygon',
+  'polyline',
+  'radialGradient',
+  'rect',
+  'stop',
+  'svg',
+  'text',
+  'tspan'
+]
+
+/**
+ * Supported SVG attributes
+ */
+
+exports.attributes = [
+  'cx',
+  'cy',
+  'd',
+  'dx',
+  'dy',
+  'fill',
+  'fillOpacity',
+  'fontFamily',
+  'fontSize',
+  'fx',
+  'fy',
+  'gradientTransform',
+  'gradientUnits',
+  'markerEnd',
+  'markerMid',
+  'markerStart',
+  'offset',
+  'opacity',
+  'patternContentUnits',
+  'patternUnits',
+  'points',
+  'preserveAspectRatio',
+  'r',
+  'rx',
+  'ry',
+  'spreadMethod',
+  'stopColor',
+  'stopOpacity',
+  'stroke',
+  'strokeDasharray',
+  'strokeLinecap',
+  'strokeOpacity',
+  'strokeWidth',
+  'textAnchor',
+  'transform',
+  'version',
+  'viewBox',
+  'x1',
+  'x2',
+  'x',
+  'y1',
+  'y2',
+  'y'
+]
+
+/**
+ * Is element's namespace SVG?
+ *
+ * @param {String} name
+ */
+
+exports.isElement = function (name) {
+  return indexOf(exports.elements, name) !== -1
+}
+
+/**
+ * Are element's attributes SVG?
+ *
+ * @param {String} attr
+ */
+
+exports.isAttribute = function (attr) {
+  return indexOf(exports.attributes, attr) !== -1
+}
+

data/deps/node_modules/deku/lib/utils.js

@@ -0,0 +1,18 @@
+/**
+ * The npm 'defaults' module but without clone because
+ * it was requiring the 'Buffer' module which is huge.
+ *
+ * @param {Object} options
+ * @param {Object} defaults
+ *
+ * @return {Object}
+ */
+
+exports.defaults = function(options, defaults) {
+  Object.keys(defaults).forEach(function(key) {
+    if (typeof options[key] === 'undefined') {
+      options[key] = defaults[key]
+    }
+  })
+  return options
+}

data/deps/node_modules/deku/lib/virtual.js

@@ -0,0 +1,247 @@
+/**
+ * Module dependencies.
+ */
+
+var type = require('component-type')
+var slice = require('sliced')
+var flatten = require('array-flatten')
+
+/**
+ * This function lets us create virtual nodes using a simple
+ * syntax. It is compatible with JSX transforms so you can use
+ * JSX to write nodes that will compile to this function.
+ *
+ * let node = virtual('div', { id: 'foo' }, [
+ *   virtual('a', { href: 'http://google.com' }, 'Google')
+ * ])
+ *
+ * You can leave out the attributes or the children if either
+ * of them aren't needed and it will figure out what you're
+ * trying to do.
+ */
+
+module.exports = virtual
+
+/**
+ * Create virtual DOM trees.
+ *
+ * This creates the nicer API for the user.
+ * It translates that friendly API into an actual tree of nodes.
+ *
+ * @param {String|Function} type
+ * @param {Object} props
+ * @param {Array} children
+ * @return {Node}
+ * @api public
+ */
+
+function virtual (type, props, children) {
+  // Default to div with no args
+  if (!type) {
+    throw new Error('Element needs a type. https://gist.github.com/anthonyshort/77ced43b5defe39908af')
+  }
+
+  // Skipped adding attributes and we're passing
+  // in children instead.
+  if (arguments.length === 2 && (typeof props === 'string' || Array.isArray(props))) {
+    children = props
+    props = {}
+  }
+
+  // Account for JSX putting the children as multiple arguments.
+  // This is essentially just the ES6 rest param
+  if (arguments.length > 2 && Array.isArray(arguments[2]) === false) {
+    children = slice(arguments, 2)
+  }
+
+  children = children || []
+  props = props || {}
+
+  // passing in a single child, you can skip
+  // using the array
+  if (!Array.isArray(children)) {
+    children = [ children ]
+  }
+
+  children = flatten(children, 1).reduce(normalize, [])
+
+  // pull the key out from the data.
+  var key = 'key' in props ? String(props.key) : null
+  delete props['key']
+
+  // if you pass in a function, it's a `Component` constructor.
+  // otherwise it's an element.
+  var node
+  if (typeof type === 'string') {
+    node = new ElementNode(type, props, key, children)
+  } else {
+    node = new ComponentNode(type, props, key, children)
+  }
+
+  // set the unique ID
+  node.index = 0
+
+  return node
+}
+
+/**
+ * Parse nodes into real `Node` objects.
+ *
+ * @param {Mixed} node
+ * @param {Integer} index
+ * @return {Node}
+ * @api private
+ */
+
+function normalize (acc, node) {
+  if (node == null) {
+    return acc
+  }
+  if (typeof node === 'string' || typeof node === 'number') {
+    var newNode = new TextNode(String(node))
+    newNode.index = acc.length
+    acc.push(newNode)
+  } else {
+    node.index = acc.length
+    acc.push(node)
+  }
+  return acc
+}
+
+/**
+ * Initialize a new `ComponentNode`.
+ *
+ * @param {Component} component
+ * @param {Object} props
+ * @param {String} key Used for sorting/replacing during diffing.
+ * @param {Array} children Child virtual nodes
+ * @api public
+ */
+
+function ComponentNode (component, props, key, children) {
+  this.key = key
+  this.props = props
+  this.type = 'component'
+  this.component = component
+  this.props.children = children || []
+}
+
+/**
+ * Initialize a new `ElementNode`.
+ *
+ * @param {String} tagName
+ * @param {Object} attributes
+ * @param {String} key Used for sorting/replacing during diffing.
+ * @param {Array} children Child virtual dom nodes.
+ * @api public
+ */
+
+function ElementNode (tagName, attributes, key, children) {
+  this.type = 'element'
+  this.attributes = parseAttributes(attributes)
+  this.tagName = tagName
+  this.children = children || []
+  this.key = key
+}
+
+/**
+ * Initialize a new `TextNode`.
+ *
+ * This is just a virtual HTML text object.
+ *
+ * @param {String} text
+ * @api public
+ */
+
+function TextNode (text) {
+  this.type = 'text'
+  this.data = String(text)
+}
+
+/**
+ * Parse attributes for some special cases.
+ *
+ * TODO: This could be more functional and allow hooks
+ * into the processing of the attributes at a component-level
+ *
+ * @param {Object} attributes
+ *
+ * @return {Object}
+ */
+
+function parseAttributes (attributes) {
+  // style: { 'text-align': 'left' }
+  if (attributes.style) {
+    attributes.style = parseStyle(attributes.style)
+  }
+
+  // class: { foo: true, bar: false, baz: true }
+  // class: ['foo', 'bar', 'baz']
+  if (attributes.class) {
+    attributes.class = parseClass(attributes.class)
+  }
+
+  // Remove attributes with false values
+  var filteredAttributes = {}
+  for (var key in attributes) {
+    var value = attributes[key]
+    if (value == null || value === false) continue
+    filteredAttributes[key] = value
+  }
+
+  return filteredAttributes
+}
+
+/**
+ * Parse a block of styles into a string.
+ *
+ * TODO: this could do a lot more with vendor prefixing,
+ * number values etc. Maybe there's a way to allow users
+ * to hook into this?
+ *
+ * @param {Object} styles
+ *
+ * @return {String}
+ */
+
+function parseStyle (styles) {
+  if (type(styles) === 'string') {
+    return styles
+  }
+  var str = ''
+  for (var name in styles) {
+    var value = styles[name]
+    str = str + name + ':' + value + ';'
+  }
+  return str;
+}
+
+/**
+ * Parse the class attribute so it's able to be
+ * set in a more user-friendly way
+ *
+ * @param {String|Object|Array} value
+ *
+ * @return {String}
+ */
+
+function parseClass (value) {
+  // { foo: true, bar: false, baz: true }
+  if (type(value) === 'object') {
+    var matched = []
+    for (var key in value) {
+      if (value[key]) matched.push(key)
+    }
+    value = matched
+  }
+
+  // ['foo', 'bar', 'baz']
+  if (type(value) === 'array') {
+    if (value.length === 0) {
+      return
+    }
+    value = value.join(' ')
+  }
+
+  return value
+}