boxwood 0.60.2 → 0.61.0

package/src/transpilers/html/index.js

@@ -1,189 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { deduceParams } = require('./expression')
-const BoxModelPlugin = require('../../plugins/BoxModelPlugin')
-const CurlyStylesPlugin = require('../../plugins/CurlyStylesPlugin')
-const { parse, walk } = require('../../utilities/html')
-const { findAttributeByKey } = require('../../utilities/attributes')
-const { transpileNode } = require('./node')
-// TODO: initial transpilation, move to a separate dir? or inline here after removing the outdated compiler
-const Transpiler = require('../../compilers/html/Transpiler')
-const { pathToIdentifier } = require('./utilities/path')
-
-const {
-  ArrayExpression,
-  Identifier,
-  ImportDeclaration,
-  ImportDefaultSpecifier,
-  ImportSpecifier,
-  Literal
-} = AbstractSyntaxTree
-
-const program = (body) => {
-  const params = deduceParams(body)
-  return AbstractSyntaxTree.program(
-    AbstractSyntaxTree.template(`
-      export default function (%= params %) {
-        return <%= body %>
-      }
-    `, { params, body })
-  )
-}
-
-function createComponentImportDeclarations (imports) {
-  return imports.map(node => {
-    const { path } = node
-    return new ImportDeclaration({
-      specifiers: [
-        new ImportDefaultSpecifier({
-          local: new Identifier(pathToIdentifier(path))
-        })
-      ],
-      source: new Literal(path)
-    })
-  })
-}
-
-function deducePartials (tree) {
-  return tree.find('Identifier[partial=true]')
-}
-
-function createPartialImportDeclarations (imports) {
-  return imports.map(node => {
-    const { name, path } = node
-    return new ImportDeclaration({
-      specifiers: [
-        new ImportDefaultSpecifier({
-          local: new Identifier(name)
-        })
-      ],
-      source: new Literal(path)
-    })
-  })
-}
-
-function deduceComponents (htmlTree) {
-  const nodes = []
-  walk(htmlTree, node => {
-    if (node.tagName === 'import') {
-      nodes.push({
-        tag: node.attributes[0].key,
-        path: findAttributeByKey(node.attributes, 'from').value
-      })
-    }
-  })
-  return nodes
-}
-
-function deduceBoxwoodImports (tree) {
-  const methods = ['tag', 'escape']
-  const imports = []
-  methods.forEach(method => {
-    if (tree.has(`CallExpression[callee.name="${method}"]`)) {
-      imports.push(method)
-    }
-  })
-  return imports
-}
-
-function createBoxwoodImportDeclaration (imports) {
-  return new ImportDeclaration({
-    specifiers: imports.map(name => (new ImportSpecifier({
-      local: new Identifier(name),
-      imported: new Identifier(name)
-    }))),
-    source: new Literal('boxwood')
-  })
-}
-
-function prerunPlugins (tree, plugins) {
-  plugins.forEach(plugin => plugin.beforeprerun())
-  walk(tree, node => {
-    plugins.forEach(plugin => {
-      plugin.prerun({
-        tag: node.tagName,
-        keys: node.attributes ? node.attributes.map(attribute => attribute.key) : [],
-        attrs: node.attributes || [],
-        fragment: node
-      })
-    })
-  })
-  plugins.forEach(plugin => plugin.afterprerun())
-}
-
-function body (tree, options) {
-  const plugins = [
-    // new DataPlugin(),
-    // new InlinePlugin(),
-    new BoxModelPlugin(options),
-    new CurlyStylesPlugin()
-    // new ScopedStylesPlugin(),
-    // new SwappedStylesPlugin(),
-    // new InternationalizationPlugin({ translations, filters, errors })
-  ]
-  prerunPlugins(tree, plugins)
-  return tree.length === 1
-    ? transpileNode({ node: tree[0], parent: tree, index: 0 })
-    : new ArrayExpression(
-      tree
-        .map((node, index) => transpileNode({ node, parent: tree, index }))
-        .filter(Boolean)
-    )
-}
-
-function transpile (source, options) {
-  source = new Transpiler().transpile(source)
-
-  const tree = parse(source)
-  const outputTree = new AbstractSyntaxTree(
-    program(body(tree, options))
-  )
-
-  let imports
-
-  imports = deduceComponents(tree)
-  if (imports.length > 0) {
-    outputTree.prepend(createComponentImportDeclarations(imports))
-
-    outputTree.replace(node => {
-      if (node.type === 'CallExpression' && node.callee.name === 'tag') {
-        imports.forEach(leaf => {
-          if (node.arguments[0].value === leaf.tag) {
-            node.callee.name = pathToIdentifier(leaf.path)
-            node.arguments.shift()
-          }
-        })
-      }
-    })
-  }
-
-  // console.log(outputTree.source)
-
-  imports = deducePartials(outputTree)
-  if (imports.length > 0) {
-    outputTree.prepend(createPartialImportDeclarations(imports))
-  }
-
-  imports = deduceBoxwoodImports(outputTree)
-  if (imports.length > 0) {
-    outputTree.prepend(createBoxwoodImportDeclaration(imports))
-  }
-
-  const block = outputTree.first('ExportDefaultDeclaration > FunctionDeclaration > BlockStatement')
-  const statement = block.body.find(node => node.type === 'ReturnStatement')
-  if (statement.argument.type === 'ArrayExpression') {
-    statement.argument.elements = statement.argument.elements.filter(element => {
-      if (element.type === 'Literal' && element.value === null) {
-        return false
-      }
-      return true
-    })
-    if (statement.argument.elements.length === 1) {
-      statement.argument = statement.argument.elements[0]
-    }
-  }
-  return outputTree.source
-}
-
-module.exports = { transpile }

package/src/transpilers/html/node.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const tags = require('./tags')
-
-function transpileNode ({ node: htmlNode, parent, index }) {
-  const { type, tagName } = htmlNode
-  if (type === 'text') {
-    return tags.text(htmlNode)
-  } else if (type === 'comment') {
-    return tags.comment()
-  } else if (tagName === 'if') {
-    const statement = tags.if(htmlNode, parent, index, transpileNode)
-    const { expression } = AbstractSyntaxTree.iife(statement)
-    return expression
-  } else if (tagName === 'else') {
-    return null
-  } else if (tagName === 'elseif') {
-    return null
-  } else if (tagName === 'unless') {
-    const statement = tags.unless(htmlNode, parent, index, transpileNode)
-    const { expression } = AbstractSyntaxTree.iife(statement)
-    return expression
-  } else if (tagName === 'elseunless') {
-    return null
-  } else if (tagName === 'try') {
-    const statement = tags.try(htmlNode, parent, index, transpileNode)
-    const { expression } = AbstractSyntaxTree.iife(statement)
-    return expression
-  } else if (tagName === 'catch') {
-    return null
-  } else if (tagName === 'for') {
-    return tags.for(htmlNode, parent, index, transpileNode)
-  } else if (tagName === 'import') {
-    return tags.import(htmlNode)
-  } else if (tagName === '!doctype') {
-    return tags.doctype()
-  } else if (tagName === 'partial') {
-    return tags.partial(htmlNode)
-  } else if (tagName === 'slot') {
-    return tags.slot(htmlNode)
-  }
-  return tags.any(htmlNode, transpileNode)
-}
-
-module.exports = { transpileNode }

package/src/transpilers/html/tags/any.js

@@ -1,53 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { transpileExpression } = require('../expression')
-
-const {
-  ArrayExpression,
-  CallExpression,
-  Identifier,
-  Literal,
-  ObjectExpression,
-  Property
-} = AbstractSyntaxTree
-
-function mapAttributes (attributes) {
-  function getAttributeValue (value) {
-    if (value === null) { return new Literal(true) }
-    return transpileExpression(value, false)
-  }
-  return attributes.length > 0
-    ? new ObjectExpression({
-        properties: attributes.map(attribute => {
-          return new Property({
-            key: new Identifier(attribute.key),
-            value: getAttributeValue(attribute.value),
-            kind: 'init',
-            computed: false,
-            method: false,
-            shorthand: false
-          })
-        })
-      })
-    : new ObjectExpression({ properties: [] })
-}
-function mapChildren (children, transpileNode) {
-  return children.length > 0 && new ArrayExpression({
-    elements: children.map((childNode, index) => {
-      return transpileNode({ node: childNode, parent: children, index })
-    }).filter(Boolean)
-  })
-}
-
-function any (htmlNode, transpileNode) {
-  const { tagName, attributes, children } = htmlNode
-  return new CallExpression({
-    callee: new Identifier('tag'),
-    arguments: [
-      new Literal(tagName),
-      mapAttributes(attributes),
-      mapChildren(children, transpileNode)
-    ].filter(Boolean)
-  })
-}
-
-module.exports = any

package/src/transpilers/html/tags/comment.js

@@ -1,7 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-const { Literal } = AbstractSyntaxTree
-
-module.exports = function () {
-  return new Literal('')
-}

package/src/transpilers/html/tags/doctype.js

@@ -1,6 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-module.exports = function doctype () {
-  const [node] = AbstractSyntaxTree.template('tag("!DOCTYPE", { html: true })', {})
-  return node.expression
-}

package/src/transpilers/html/tags/for.js

@@ -1,30 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { Identifier } = AbstractSyntaxTree
-
-let FOR_LOOP_INDEX = 0
-
-function mapForStatement (htmlNode, parent, index, transpileNode) {
-  FOR_LOOP_INDEX++
-  const [node] = AbstractSyntaxTree.template(`
-    (function () {
-      var __output__ = [];
-      for (var <%= index %> = 0, <%= length %> = <%= array %>.length; <%= index %> < <%= length %>; <%= index %>++) {
-        var <%= item %> = <%= array %>[<%= index %>];
-        __output__.push(%= children %);
-      }
-      return __output__;
-    })();
-  `, {
-    index: new Identifier(`__i${FOR_LOOP_INDEX}__`),
-    length: new Identifier(`__ilen${FOR_LOOP_INDEX}__`),
-    item: new Identifier(htmlNode.attributes[0].key),
-    // TODO we should not mark params which were created on the fly, e.g. for nested loops
-    array: new Identifier({ name: htmlNode.attributes[2].key, parameter: true }),
-    children: htmlNode.children.map((child, index) =>
-      transpileNode({ node: child, parent: htmlNode, index: index })
-    )
-  })
-  return node.expression
-}
-
-module.exports = mapForStatement

package/src/transpilers/html/tags/if.js

@@ -1,55 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { transpileExpression } = require('../expression')
-const { isCurlyTag } = require('../../../utilities/string')
-
-const { BlockStatement, Literal, Identifier, IfStatement, ReturnStatement } = AbstractSyntaxTree
-
-function mapIfStatement (htmlNode, parent, index = 0, transpileNode) {
-  function mapAttributesToTest ({ attributes }) {
-    if (attributes.length === 1) {
-      if (attributes[0].key === 'true' || attributes[0].key === '{true}') {
-        return new Literal(true)
-      } else if (attributes[0].key === 'false' || attributes[0].key === '{false}') {
-        return new Literal(false)
-      } else if (isCurlyTag(attributes[0].key)) {
-        return transpileExpression(attributes[0].key)
-      } else {
-        return new Identifier({ name: attributes[0].key, parameter: true })
-      }
-    }
-    throw new Error('Unsupported length of attributes (if)')
-  }
-
-  function mapCurrentNodeToConsequent (htmlNode) {
-    const body = htmlNode.children.map((node, index) => transpileNode({ node, parent: htmlNode.children, index })).filter(Boolean)
-    const argument = body.pop() || new Literal('')
-    body.push(new ReturnStatement({ argument }))
-    return new BlockStatement({ body })
-  }
-
-  function mapNextNodeToAlternate (nextNode) {
-    if (nextNode && nextNode.tagName === 'else') {
-      const body = nextNode.children.map((node, index) => transpileNode({ node, parent: nextNode.children, index })).filter(Boolean)
-      const argument = body.pop()
-      body.push(new ReturnStatement({ argument }))
-      return new BlockStatement({ body })
-    } else if (nextNode && nextNode.tagName === 'elseif') {
-      return mapIfStatement(nextNode, parent, index + 1, transpileNode)
-    }
-    return new BlockStatement({
-      body: [
-        new ReturnStatement({
-          argument: new Literal('')
-        })
-      ]
-    })
-  }
-
-  return new IfStatement({
-    test: mapAttributesToTest(htmlNode),
-    consequent: mapCurrentNodeToConsequent(htmlNode),
-    alternate: mapNextNodeToAlternate(parent[index + 1])
-  })
-}
-
-module.exports = mapIfStatement

package/src/transpilers/html/tags/import.js

@@ -1,7 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-const { Literal } = AbstractSyntaxTree
-
-module.exports = function importTag (node) {
-  return new Literal({ value: null })
-}

package/src/transpilers/html/tags/index.js

@@ -1,13 +0,0 @@
-module.exports = {
-  import: require('./import'),
-  doctype: require('./doctype'),
-  partial: require('./partial'),
-  slot: require('./slot'),
-  for: require('./for'),
-  if: require('./if'),
-  unless: require('./unless'),
-  try: require('./try'),
-  any: require('./any'),
-  comment: require('./comment'),
-  text: require('./text')
-}

package/src/transpilers/html/tags/partial.js

@@ -1,17 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { findAttributeByKey } = require('../../../utilities/attributes')
-const { pathToIdentifier } = require('../utilities/path')
-
-const { CallExpression, Identifier } = AbstractSyntaxTree
-
-module.exports = function partial (node) {
-  const attribute = findAttributeByKey(node.attributes, 'from')
-  const path = attribute.value
-  return new CallExpression({
-    callee: new Identifier({
-      name: pathToIdentifier(path),
-      partial: true,
-      path
-    })
-  })
-}

package/src/transpilers/html/tags/slot.js

@@ -1,7 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-const { Identifier } = AbstractSyntaxTree
-
-module.exports = function slotTag (node) {
-  return new Identifier({ name: '__children__' })
-}

package/src/transpilers/html/tags/text.js

@@ -1,6 +0,0 @@
-const { transpileExpression } = require('../expression')
-
-module.exports = function (htmlNode) {
-  const { content } = htmlNode
-  return transpileExpression(content)
-}

package/src/transpilers/html/tags/try.js

@@ -1,30 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-const { ReturnStatement, BlockStatement, TryStatement, CatchClause } = AbstractSyntaxTree
-
-function mapTryStatement (htmlNode, parent, index, transpileNode) {
-  function mapCurrentNodeToBlockStatement (htmlNode) {
-    const body = htmlNode.children.map((node, index) => transpileNode({ node, parent: htmlNode.children, index })).filter(Boolean)
-    const argument = body.pop()
-    body.push(new ReturnStatement({ argument }))
-    return new BlockStatement({ body })
-  }
-
-  function mapNextNodeToCatchClause (nextNode) {
-    if (nextNode && nextNode.tagName === 'catch') {
-      const body = nextNode.children.map((node, index) => transpileNode({ node, parent: htmlNode.children, index })).filter(Boolean)
-      const argument = body.pop()
-      body.push(new ReturnStatement({ argument }))
-      return new CatchClause({
-        body: new BlockStatement({ body })
-      })
-    }
-    return null
-  }
-  return new TryStatement({
-    block: mapCurrentNodeToBlockStatement(htmlNode),
-    handler: mapNextNodeToCatchClause(parent[index + 1])
-  })
-}
-
-module.exports = mapTryStatement

package/src/transpilers/html/tags/unless.js

@@ -1,58 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const ifTag = require('./if')
-
-const { Identifier, Literal, IfStatement, ReturnStatement, BlockStatement, UnaryExpression } = AbstractSyntaxTree
-
-function mapUnlessStatement (htmlNode, parent, index, transpileNode) {
-  function mapAttributesToTest ({ attributes }) {
-    if (attributes.length === 1) {
-      if (attributes[0].key === 'true' || attributes[0].key === '{true}') {
-        return new Literal(true)
-      } else if (attributes[0].key === 'false' || attributes[0].key === '{false}') {
-        return new Literal(false)
-      } else {
-        return new Identifier({ name: attributes[0].key, parameter: true })
-      }
-    }
-    throw new Error('Unsupported length of attributes (unless)')
-  }
-
-  function mapCurrentNodeToConsequent (htmlNode) {
-    const body = htmlNode.children.map((node, index) => transpileNode({ node, parent: htmlNode.children, index })).filter(Boolean)
-    const argument = body.pop()
-    body.push(new ReturnStatement({ argument }))
-    return new BlockStatement({ body })
-  }
-
-  function mapNextNodeToAlternate (nextNode) {
-    if (nextNode && nextNode.tagName === 'else') {
-      const body = nextNode.children.map((node, index) => transpileNode({ node, parent: nextNode.children, index })).filter(Boolean)
-      const argument = body.pop()
-      body.push(new ReturnStatement({ argument }))
-      return new BlockStatement({ body })
-    } else if (nextNode && nextNode.tagName === 'elseunless') {
-      return mapUnlessStatement(nextNode, parent, index + 1, transpileNode)
-    } else if (nextNode && nextNode.tagName === 'elseif') {
-      return ifTag(nextNode, parent, index + 1, transpileNode)
-    }
-    return new BlockStatement({
-      body: [
-        new ReturnStatement({
-          argument: new Literal('')
-        })
-      ]
-    })
-  }
-
-  return new IfStatement({
-    test: new UnaryExpression({
-      operator: '!',
-      argument: mapAttributesToTest(htmlNode),
-      prefix: true
-    }),
-    consequent: mapCurrentNodeToConsequent(htmlNode),
-    alternate: mapNextNodeToAlternate(parent[index + 1])
-  })
-}
-
-module.exports = mapUnlessStatement

package/src/transpilers/html/utilities/path.js

@@ -1,9 +0,0 @@
-const { camelize } = require('pure-utilities/string')
-
-function pathToIdentifier (path) {
-  return `__${camelize(path.replace(/\./g, 'Dot_').replace(/\//g, 'Slash_'))}__`
-}
-
-module.exports = {
-  pathToIdentifier
-}