boxwood 0.60.2 → 0.61.0

package/src/compilers/html/Preprocessor.js

@@ -1,130 +0,0 @@
-const ScopedStylesPlugin = require('../../plugins/ScopedStylesPlugin')
-const InlinePlugin = require('../../plugins/InlinePlugin')
-const SwappedStylesPlugin = require('../../plugins/SwappedStylesPlugin')
-
-const plugins = [
-  new InlinePlugin(),
-  new ScopedStylesPlugin(),
-  new SwappedStylesPlugin()
-]
-
-function walk (node, callback) {
-  let children
-  if (Array.isArray(node)) {
-    children = node
-  } else {
-    callback(node)
-    children = node.children
-  }
-  if (children) {
-    let child = children[0]
-    let i = 0
-    while (child) {
-      walk(child, callback)
-      child = children[++i]
-    }
-  }
-}
-
-function remove (tree, callback) {
-  tree = tree.map(node => {
-    if (callback(node)) {
-      return null
-    }
-    return node
-  }).filter(Boolean)
-  walk(tree, node => {
-    if (node.children) {
-      for (let i = 0, ilen = node.children.length; i < ilen; i++) {
-        if (callback(node.children[i])) {
-          node.children[i] = null
-        }
-      }
-      node.children = node.children.filter(Boolean)
-    }
-  })
-  return tree
-}
-
-class Preprocessor {
-  preprocess (tree, assets, options) {
-    const references = {}
-    const styles = []
-
-    // things that are missing
-    // - use the scoped styles plugin first
-    // - handle imported components
-
-    // it would be nicer to do this in a more functional way, like `abstract-syntax-tree` lib
-    //
-
-    plugins.forEach(plugin => {
-      plugin.depth += 1
-      plugin.beforeprerun()
-    })
-
-    walk(tree, node => {
-      if (node.tagName === 'head') {
-        references.head = node
-      } else if (node.tagName === 'style') {
-        styles.push(node)
-        plugins.forEach(plugin => {
-          plugin.prerun({
-            tag: node.tagName,
-            keys: node.attributes.map(leaf => leaf.key),
-            attributes: node.attributes,
-            attrs: node.attributes,
-            children: node.children || [],
-            fragment: node,
-            assets,
-            options
-          })
-        })
-      }
-    })
-    plugins.forEach(plugin => { plugin.afterprerun() })
-    plugins.forEach(plugin => { plugin.beforerun() })
-    walk(tree, node => {
-      plugins.forEach(plugin => {
-        plugin.run({
-          tag: node.tagName,
-          keys: node.attributes && node.attributes.map(leaf => leaf.key),
-          fragment: node,
-          attributes: node.attributes,
-          assets,
-          options,
-          children: node.children || []
-        })
-      })
-    })
-    plugins.forEach(plugin => {
-      plugin.afterrun()
-      plugin.depth -= 1
-    })
-
-    tree = remove(tree, node => {
-      return node && node.tagName === 'style'
-    })
-
-    if (styles.length > 0 && references.head) {
-      references.head.children.push({
-        type: 'element',
-        tagName: 'style',
-        attributes: [],
-        children: [
-          {
-            type: 'text',
-            content: styles.reduce((result, style) => {
-              const { content } = style.children[0]
-              return result + content
-            }, '')
-          }
-        ]
-      })
-    }
-
-    return { tree, styles }
-  }
-}
-
-module.exports = Preprocessor

package/src/compilers/html/Renderer.js

@@ -1,167 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const walk = require('himalaya-walk')
-const { TEMPLATE_VARIABLE, OBJECT_VARIABLE, ESCAPE_VARIABLE, BUILT_IN_VARIABLES } = require('../../utilities/enum')
-const { getTemplateVariableDeclaration, getTemplateReturnStatement, getTemplateAssignmentExpression } = require('../../utilities/factory')
-const collect = require('../../utilities/collect')
-const { getFilter } = require('../../utilities/filters')
-const { concatenateScripts } = require('../../utilities/js')
-const { unique } = require('pure-utilities/array')
-const Statistics = require('../../Statistics')
-const DataPlugin = require('../../plugins/DataPlugin')
-const CurlyStylesPlugin = require('../../plugins/CurlyStylesPlugin')
-const ScopedStylesPlugin = require('../../plugins/ScopedStylesPlugin')
-const InternationalizationPlugin = require('../../plugins/InternationalizationPlugin')
-const BoxModelPlugin = require('../../plugins/BoxModelPlugin')
-const InlinePlugin = require('../../plugins/InlinePlugin')
-const SwappedStylesPlugin = require('../../plugins/SwappedStylesPlugin')
-const Importer = require('../../Importer')
-const Optimizer = require('../../Optimizer')
-const Scope = require('../../Scope')
-const { getLiteral } = require('../../utilities/ast')
-const Preprocessor = require('./Preprocessor')
-const { transpile: transpileCSS } = require('../../transpilers/css')
-
-function replaceNeedleOrAppend (tree, { needles, needle, tag, content }) {
-  if (content) {
-    const all = `<${tag}>${content}</${tag}>`
-    if (needles[needle]) {
-      const node = tree.first(`Literal[value=__NEEDLE_${needle.toUpperCase()}__]`)
-      node.value = all
-    } else {
-      tree.append(getTemplateAssignmentExpression(TEMPLATE_VARIABLE, getLiteral(all)))
-    }
-  } else {
-    tree.replace((node) => {
-      if (node.type === 'ExpressionStatement' &&
-        node.expression.type === 'AssignmentExpression' &&
-        node.expression.right.type === 'Literal' &&
-        node.expression.right.value === `__NEEDLE_${needle.toUpperCase()}__`) {
-        return null
-      }
-      return node
-    })
-  }
-}
-
-class Renderer {
-  async render (source, htmltree, options) {
-    if (!htmltree) { return null }
-    const tree = new AbstractSyntaxTree('')
-    const variables = [
-      TEMPLATE_VARIABLE,
-      OBJECT_VARIABLE,
-      ESCAPE_VARIABLE
-    ].concat(BUILT_IN_VARIABLES)
-    const filters = []
-    const components = []
-    const statistics = new Statistics()
-    const importer = new Importer(source, options)
-    const { assets, warnings } = await importer.import()
-    assets.forEach(asset => {
-      if (asset.type === 'COMPONENT') {
-        statistics.components.push(asset)
-      } else if (asset.type === 'PARTIAL') {
-        statistics.partials.push(asset)
-      } else if (asset.type === 'SCRIPT') {
-        statistics.scripts.push(asset)
-      } else if (asset.type === 'STYLESHEET') {
-        statistics.stylesheets.push(asset)
-      } else if (asset.type === 'IMAGE') {
-        statistics.images.push(asset)
-      } else if (asset.type === 'TRANSLATION') {
-        statistics.translations.push(asset)
-      }
-    })
-    const scripts = []
-    const stack = [options.path]
-    const store = {}
-    const translations = {}
-    const needles = {}
-    const promises = []
-    const errors = []
-    const plugins = [
-      new DataPlugin(),
-      new InlinePlugin(),
-      new BoxModelPlugin(options),
-      new CurlyStylesPlugin(),
-      new ScopedStylesPlugin(),
-      new SwappedStylesPlugin(),
-      new InternationalizationPlugin({ translations, filters, errors })
-    ]
-    const depth = 0
-    tree.append(getTemplateVariableDeclaration(TEMPLATE_VARIABLE))
-    plugins.forEach(plugin => {
-      plugin.depth = 0
-      plugin.beforeprerun()
-    })
-    const preprocessor = new Preprocessor()
-    const output = preprocessor.preprocess(htmltree, assets, options)
-    htmltree = output.tree
-    const styles = output.styles
-      ? output.styles.map(style => style.children[0] && style.children[0].content).filter(Boolean)
-      : []
-
-    assets.forEach(asset => {
-      if (asset.type === 'COMPONENT' && asset.path.endsWith('.css')) {
-        const css = transpileCSS(asset.source)
-        styles.push(css)
-      }
-    })
-    walk(htmltree, async fragment => {
-      try {
-        const attrs = fragment.attributes || []
-        plugins.forEach(plugin => {
-          plugin.prerun({
-            source,
-            tag: fragment.tagName,
-            keys: attrs.map(attribute => attribute.key),
-            attrs,
-            fragment,
-            options,
-            assets,
-            stack,
-            errors,
-            ...fragment,
-            pass: 'renderer'
-          })
-        })
-      } catch (exception) {
-        errors.push(exception)
-      }
-    })
-    plugins.forEach(plugin => { plugin.afterprerun() })
-
-    const severities = warnings.map(warning => warning.severity)
-    if (!severities.includes('critical')) {
-      walk(htmltree, async fragment => {
-        await collect({ source, tree, fragment, assets, variables, filters, components, styles, scripts, translations, plugins, stack, store, depth, options, promises, errors, warnings, needles })
-      })
-      await Promise.all(promises)
-
-      const style = unique(styles).join(' ')
-      replaceNeedleOrAppend(tree, { needles, needle: 'head', tag: 'style', content: style })
-
-      const script = concatenateScripts(scripts)
-      replaceNeedleOrAppend(tree, { needles, needle: 'body', tag: 'script', content: script })
-
-      const used = []
-      unique(filters).forEach(name => {
-        const filter = getFilter(name, translations, options)
-        if (filter && !used.includes(filter.id.name)) {
-          tree.prepend(filter)
-          used.push(filter.id.name)
-        }
-      })
-    }
-    tree.append(getTemplateReturnStatement())
-    const scope = new Scope()
-    scope.flatten(tree)
-    const optimizer = new Optimizer()
-    optimizer.optimize(tree)
-    return { tree, statistics, warnings, errors }
-  }
-}
-
-module.exports = Renderer

package/src/compilers/html/Transpiler.js

@@ -1,76 +0,0 @@
-'use strict'
-
-const { isCurlyTag, getTagValue } = require('../../utilities/string')
-const { SPECIAL_TAGS } = require('../../utilities/enum')
-const tokenize = require('../../lexers/html')
-
-const transform = (tokens) => {
-  const output = []
-  const contexts = []
-  const imports = []
-  let lastTag
-  tokens.forEach((token, index) => {
-    const [type, value] = token
-    const next = tokens[index + 1]
-    if (type === 'tagName') {
-      lastTag = value
-      if (value === 'if' || value === 'unless') {
-        contexts.push(value)
-      } else if (value === 'elseif' || value === 'else' || value === 'elseunless') {
-        const context = contexts[contexts.length - 1]
-        if (context === 'if' || context === 'elseif' || context === 'unless') {
-          const last = output.pop()
-          output.push(['beginEndTag', '</'])
-          output.push(['tagName', context])
-          output.push(['finishTag', '>'])
-          output.push(last)
-          contexts.push(value)
-        }
-      } else if (value === 'end') {
-        const context = contexts[contexts.length - 1]
-        if (context === 'if' || context === 'unless' || context === 'elseunless' || context === 'else' || context === 'elseif') {
-          tokens[index - 1][0] = 'beginEndTag'
-          tokens[index - 1][1] = '</'
-          token[1] = context
-          contexts.pop()
-        }
-      }
-      output.push(token)
-    } else if (type === 'attributeName' && (lastTag === 'import' || lastTag === 'require')) {
-      const [, value] = token
-      if (value !== 'from' && value !== '{' && value !== '}') {
-        // TODO unify with getComponentNames
-        const parts = value.replace('{', '').replace('}', '').split(/,/g).map(key => key.trim()).filter(Boolean)
-        parts.forEach(part => imports.push(part))
-      }
-      output.push(token)
-    } else if (type === 'attributeName' && isCurlyTag(value) && next && next[0] !== 'attributeAssign') {
-      const tags = SPECIAL_TAGS.filter(tag => !imports.includes(tag))
-      if (tags.includes(lastTag)) {
-        output.push(token)
-      } else {
-        output.push(['attributeName', getTagValue(value)])
-        output.push(['attributeAssign', '='])
-        output.push(['beginAttributeValue', '"'])
-        output.push(['attributeData', value])
-        output.push(['finishAttributeValue', '"'])
-      }
-    } else {
-      output.push(token)
-    }
-  })
-  return output
-}
-
-const stringify = (tokens) => {
-  return tokens.map(([type, value]) => value).join('')
-}
-
-class Transpiler {
-  transpile (source) {
-    const tokens = tokenize(source)
-    return stringify(transform(tokens))
-  }
-}
-
-module.exports = Transpiler

package/src/compilers/js/Bundler.js

@@ -1,84 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { join } = require('path')
-const ESBundler = require('../../Bundler')
-const { OBJECT_VARIABLE } = require('../../utilities/enum')
-
-const { CallExpression, ExpressionStatement, FunctionExpression, Identifier, ImportDeclaration, ImportSpecifier, Literal } = AbstractSyntaxTree
-
-function getRenderImportSpecifier () {
-  const identifier = new Identifier('render')
-  return new ImportSpecifier({
-    local: identifier,
-    imported: identifier
-  })
-}
-
-function getRenderCallExpression (node) {
-  return new CallExpression({
-    callee: new Identifier('render'),
-    arguments: [
-      new CallExpression({
-        callee: new FunctionExpression(node.declaration),
-        arguments: [new Identifier(OBJECT_VARIABLE)]
-      })
-    ]
-  })
-}
-
-function isBoxwoodImportDeclaration (node) {
-  return AbstractSyntaxTree.match(node, 'ImportDeclaration[source.value="boxwood"]')
-}
-
-function getBoxwoodImportDeclaration () {
-  return new ImportDeclaration({
-    specifiers: [getRenderImportSpecifier()],
-    source: new Literal('boxwood')
-  })
-}
-
-function isFunctionExportDeclaration (node) {
-  return AbstractSyntaxTree.match(node, 'ExportDefaultDeclaration[declaration.type="FunctionDeclaration"]')
-}
-
-class Bundler {
-  constructor (options) {
-    this.options = options
-  }
-
-  async bundle (input) {
-    const tree = this.parse(input)
-
-    const bundler = new ESBundler()
-    return await bundler.bundle(tree.source, {
-      platform: 'node',
-      format: 'iife',
-      paths: [
-        join(__dirname, '../../vdom/server'),
-        ...this.options.paths
-      ]
-    })
-  }
-
-  parse (input) {
-    const tree = new AbstractSyntaxTree(input)
-    let imported = false
-    tree.replace(node => {
-      if (isBoxwoodImportDeclaration(node)) {
-        imported = true
-        node.specifiers.push(getRenderImportSpecifier())
-      }
-    })
-    if (!imported) {
-      tree.prepend(getBoxwoodImportDeclaration())
-    }
-    tree.replace(node => {
-      if (isFunctionExportDeclaration(node)) {
-        return new ExpressionStatement({ expression: getRenderCallExpression(node) })
-      }
-      return node
-    })
-    return tree
-  }
-}
-
-module.exports = Bundler

package/src/compilers/js/Compiler/index.js

@@ -1,27 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const Bundler = require('../Bundler')
-const { OBJECT_VARIABLE } = require('../../../utilities/enum')
-const { getOptions, validateOptions } = require('../../../utilities/options')
-
-class Compiler {
-  constructor (options) {
-    this.options = getOptions(options)
-  }
-
-  async compile (input) {
-    const { options } = this
-    const errors = validateOptions(options)
-    if (errors.length > 0) { return { errors } }
-    const bundler = new Bundler(options)
-    const bundle = await bundler.bundle(input)
-    const tree = new AbstractSyntaxTree(bundle)
-    const expression = tree.first('CallExpression > ArrowFunctionExpression')
-    const { body } = expression.body
-    const lastNode = body.pop()
-    body.push({ type: 'ReturnStatement', argument: lastNode.expression })
-    const template = new Function(`return function render(${OBJECT_VARIABLE}) {\nreturn ${tree.source}}`)() // eslint-disable-line
-    return { template, errors: [] }
-  }
-}
-
-module.exports = Compiler

package/src/conditions/isEqual.js

@@ -1,5 +0,0 @@
-function isEqual (a, b) {
-  return a === b
-}
-
-module.exports = isEqual

package/src/lexers/html.js

@@ -1,49 +0,0 @@
-const Lexer = require('html-lexer')
-
-const tokenize = (source) => {
-  const tokens = []
-  const delegate = {
-    write: (token) => tokens.push(token),
-    end: () => null
-  }
-  const lexer = new Lexer(delegate)
-  lexer.write(source)
-  lexer.end()
-  return reduce(normalize(tokens))
-}
-
-const normalize = (tokens) => {
-  for (let i = 0, ilen = tokens.length; i < ilen; i += 1) {
-    const current = tokens[i]
-    if (current[0] === 'endTagPrefix') {
-      const previous = tokens[i - 1]
-      const next = tokens[i + 1]
-      if (previous && next && previous[0] === 'rawtext' && next[0] === 'rawtext') {
-        current[0] = 'rawtext'
-      }
-    }
-  }
-  return tokens
-}
-
-const reduce = (tokens) => {
-  const newTokens = []
-  for (let i = 0, ilen = tokens.length; i < ilen; i += 1) {
-    const current = tokens[i]
-    if (current[0] === 'rawtext') {
-      let text = current[1]
-      let next = tokens[i + 1]
-      while (next && next[0] === 'rawtext') {
-        i++
-        text += next[1]
-        next = tokens[i + 1]
-      }
-      newTokens.push(['rawtext', text])
-    } else {
-      newTokens.push(tokens[i])
-    }
-  }
-  return newTokens
-}
-
-module.exports = tokenize

package/src/lexers/internal.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const START_TAG = '{'
-const END_TAG = '}'
-
-const TEXT = 'text'
-const EXPRESSION = 'expression'
-
-module.exports = function tokenize (input) {
-  const tokens = []
-  const length = input.length
-  let index = 0
-  let character = input[0]
-  function advance () {
-    index += 1
-    character = input[index]
-    return character
-  }
-  function current (tag) {
-    return character === tag
-  }
-  function push (type, value) {
-    if (value) tokens.push({ type, value })
-  }
-  let value = ''
-  let type = current(START_TAG) ? EXPRESSION : TEXT
-  let depth = 0
-  while (index < length) {
-    if (current(START_TAG)) { depth += 1 } else if (current(END_TAG)) { depth -= 1 }
-
-    if (current(START_TAG) && depth === 1) {
-      push(type, value)
-      advance()
-      value = ''
-      type = EXPRESSION
-    } else if (current(END_TAG) && depth === 0) {
-      push(type, value)
-      advance()
-      value = ''
-      type = TEXT
-    } else {
-      value += character
-      advance()
-    }
-  }
-  push(type, value)
-
-  return tokens
-}

package/src/linters/html/bracket.js

@@ -1,36 +0,0 @@
-const tokenize = require('../../lexers/html')
-
-const OPENING_ANGLE_BRACKET = '<'
-const CLOSING_ANGLE_BRACKET = '>'
-
-function isOpeningBracket (character) {
-  return character === OPENING_ANGLE_BRACKET
-}
-
-function isClosingBracket (character) {
-  return character === CLOSING_ANGLE_BRACKET
-}
-
-function verifyBrackets (source) {
-  const tokens = tokenize(source).filter(token => token[0] !== 'rawtext')
-  const text = tokens.map(token => token[1]).join('')
-
-  const errors = []
-  let bracket = null
-  for (const character of text) {
-    if (isOpeningBracket(character)) {
-      if (isOpeningBracket(bracket)) {
-        errors.push({ type: 'CLOSING_ANGLE_BRACKET_MISSING', message: 'closing angle bracket is missing' })
-      }
-      bracket = OPENING_ANGLE_BRACKET
-    } else if (isClosingBracket(character)) {
-      if (!isOpeningBracket(bracket)) {
-        errors.push({ type: 'OPENING_ANGLE_BRACKET_MISSING', message: 'opening angle bracket is missing' })
-      }
-      bracket = CLOSING_ANGLE_BRACKET
-    }
-  }
-  return errors
-}
-
-module.exports = { verifyBrackets }

package/src/linters/html/component.js

@@ -1,43 +0,0 @@
-'use strict'
-
-const walk = require('himalaya-walk')
-const { unique } = require('pure-utilities/array')
-const { isImportTag } = require('../../utilities/string')
-const { getComponentNames } = require('../../utilities/attributes')
-
-function isStyleImport (node) {
-  const from = node.attributes.find(attr => attr.key === 'from')
-  if (from && from.value.endsWith('.css')) {
-    return true
-  }
-  return false
-}
-
-function analyze (tree) {
-  const components = []
-  walk(tree, node => {
-    if (isImportTag(node.tagName) && !isStyleImport(node)) {
-      const names = getComponentNames(node.attributes)
-      names.forEach(name => components.push(name))
-    }
-  })
-  return { components: unique(components) }
-}
-
-function verifyComponents (tree) {
-  const warnings = []
-  const { components } = analyze(tree)
-  walk(tree, node => {
-    const index = components.indexOf(node.tagName)
-    if (index !== -1) {
-      components.splice(index, 1)
-    }
-  })
-  // TODO: unify warnings.
-  components.forEach(component => {
-    warnings.push({ type: 'UNUSED_COMPONENT', message: `${component} component is unused` })
-  })
-  return warnings
-}
-
-module.exports = { verifyComponents, analyze }