boxwood 0.60.2 → 0.61.0

package/src/tags/index.js

@@ -1,53 +0,0 @@
-'use strict'
-
-const foreachTag = require('./foreach')
-const forTag = require('./for')
-const tryTag = require('./try')
-const catchTag = require('./catch')
-const unlessTag = require('./unless')
-const elseunlessTag = require('./elseunless')
-const switchTag = require('./switch')
-const caseTag = require('./case')
-const dataTag = require('./data')
-const defaultTag = require('./default')
-const doctypeTag = require('./doctype')
-const fontTag = require('./font')
-const ifTag = require('./if')
-const elseifTag = require('./elseif')
-const elseTag = require('./else')
-const slotTag = require('./slot')
-const imgTag = require('./img')
-const scriptTag = require('./script')
-const styleTag = require('./style')
-const templateTag = require('./template')
-const translateTag = require('./translate')
-const translationTag = require('./translation')
-const varTag = require('./var')
-const linkTag = require('./link')
-
-module.exports = {
-  foreach: foreachTag,
-  for: forTag,
-  try: tryTag,
-  catch: catchTag,
-  unless: unlessTag,
-  elseunless: elseunlessTag,
-  switch: switchTag,
-  case: caseTag,
-  data: dataTag,
-  default: defaultTag,
-  doctype: doctypeTag,
-  font: fontTag,
-  if: ifTag,
-  elseif: elseifTag,
-  else: elseTag,
-  slot: slotTag,
-  img: imgTag,
-  script: scriptTag,
-  style: styleTag,
-  template: templateTag,
-  translate: translateTag,
-  translation: translationTag,
-  var: varTag,
-  link: linkTag
-}

package/src/tags/link.js

@@ -1,14 +0,0 @@
-const { minify } = require('csso')
-const { findAsset } = require('../utilities/files')
-
-module.exports = function link ({ attrs, assets, options, styles }) {
-  const { value: path } = attrs.find(attr => attr.key === 'href')
-  const asset = findAsset(path, assets, options)
-  if (!asset) return
-  if (attrs.find(attr => attr.key === 'minify')) {
-    const { css } = minify(asset.source)
-    styles.push(css)
-  } else {
-    styles.push(asset.source.trim())
-  }
-}

package/src/tags/script/index.js

@@ -1,83 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { getLiteral } = require('../../utilities/ast')
-const { findAsset } = require('../../utilities/files')
-const { containsCurlyTag } = require('../../utilities/string')
-const { convertAttribute } = require('../../utilities/convert')
-const scoped = require('./scoped')
-
-const script = { scoped }
-
-module.exports = async function ({ tree, keys, attrs, fragment, assets, variables, promises, warnings, filters, translations, languages, append, scripts, options }) {
-  if (keys.includes('inline')) {
-    if (keys.includes('src')) {
-      const { value: path } = attrs.find(attr => attr.key === 'src')
-      const asset = findAsset(path, assets, options)
-      if (!asset) return
-      const content = asset.source.trim()
-      scripts.push(content)
-    } else {
-      const leaf = fragment.children[0]
-      leaf.used = true
-      const ast = new AbstractSyntaxTree(leaf.content)
-      ast.each('VariableDeclarator', node => variables.push(node.id.name))
-      ast.body.forEach(node => tree.append(node))
-    }
-  } else if (keys.includes('scoped')) {
-    const leaf = fragment.children[0]
-    if (!leaf) return
-    leaf.used = true
-    const promise = script.scoped({
-      source: leaf.content,
-      paths: options.script.paths,
-      attrs
-    })
-    promises.push(promise)
-    const output = await promise
-    scripts.push(output)
-  } else if (keys.includes('compiler')) {
-    const { value } = attrs.find(attr => attr.key === 'compiler')
-    const compiler = options.compilers[value]
-    // TODO errors.push when given compiler is not available
-    if (typeof compiler === 'function') {
-      const attr = attrs.find(attr => attr.key === 'options')
-      const params = attr && attr.value && JSON.parse(attr.value)
-      const leaf = fragment.children[0]
-      leaf.used = true
-      const output = compiler(leaf.content, params)
-      if (typeof output === 'string') {
-        scripts.push(output)
-      } else if (output instanceof Promise) {
-        promises.push(output)
-        const source = await output
-        scripts.push(source)
-      }
-    }
-  } else if (keys.includes('src')) {
-    append(getLiteral('<script'))
-    fragment.attributes.forEach(attribute => {
-      if (containsCurlyTag(attribute.value)) {
-        append(getLiteral(` ${attribute.key}="`))
-        append(convertAttribute(attribute.key, attribute.value, variables, filters, translations, languages))
-        append(getLiteral('"'))
-      } else if (attribute.value) {
-        append(getLiteral(` ${attribute.key}="${attribute.value}"`))
-      } else {
-        append(getLiteral(` ${attribute.key}`))
-      }
-    })
-    append(getLiteral('>'))
-    fragment.children.forEach(node => {
-      node.used = true
-      append(getLiteral(node.content))
-    })
-    append(getLiteral('</script>'))
-  } else {
-    fragment.children.forEach(node => {
-      node.used = true
-      const { content } = node
-      scripts.push(content)
-    })
-  }
-}

package/src/tags/script/scoped.js

@@ -1,26 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { join } = require('path')
-const Bundler = require('../../Bundler')
-
-function scoped ({ source, paths, attrs }) {
-  const tree = new AbstractSyntaxTree(source)
-  tree.replace(node => {
-    if (node.type === 'ImportDeclaration' && node.source.value === 'boxwood') {
-      node.source.value = '.'
-    }
-    return node
-  })
-  const bundlerAttr = attrs.find(attr => attr.key === 'bundler')
-  const bundler = new Bundler()
-  return bundler.bundle(tree.source, {
-    paths: [
-      join(__dirname, '../../vdom/browser'),
-      ...paths
-    ],
-    bundler: bundlerAttr ? bundlerAttr.value : 'esbuild'
-  })
-}
-
-module.exports = scoped

package/src/tags/slot.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-
-module.exports = function ({ fragment, tree, collectChildren }) {
-  const ast = new AbstractSyntaxTree('')
-  collectChildren(fragment, ast)
-  ast.body.forEach(node => tree.append(node))
-}

package/src/tags/style.js

@@ -1,9 +0,0 @@
-'use strict'
-
-module.exports = function ({ fragment, styles }) {
-  if (fragment.children?.length > 0) {
-    const { content } = fragment.children[0]
-    styles.push(content)
-    fragment.children[0].used = true
-  }
-}

package/src/tags/switch.js

@@ -1,13 +0,0 @@
-'use strict'
-
-module.exports = function ({ tree, attrs }) {
-  tree.append({
-    type: 'SwitchStatement',
-    discriminant: {
-      type: 'Literal',
-      value: true
-    },
-    attribute: attrs[0],
-    cases: []
-  })
-}

package/src/tags/template.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const { getLiteral } = require('../utilities/ast')
-const { getTemplateAssignmentExpression } = require('../utilities/factory')
-
-module.exports = function ({ tree, fragment, options }) {
-  let content = '<template'
-  fragment.attributes.forEach(attribute => {
-    if (attribute.value) {
-      content += ` ${attribute.key}="${attribute.value}"`
-    } else {
-      content += ` ${attribute.key}`
-    }
-  })
-  content += '>'
-  fragment.children.forEach(node => {
-    node.used = true
-    content += node.content
-  })
-  content += '</template>'
-  tree.append(getTemplateAssignmentExpression(options.variables.template, getLiteral(content)))
-}

package/src/tags/translate.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const { getTemplateAssignmentExpression } = require('../utilities/factory')
-const { getTranslateCallExpression } = require('../utilities/translations')
-const { stringify } = require('../utilities/html')
-const walk = require('himalaya-walk')
-
-const getSlotContent = (fragment, options) => {
-  if (fragment.children.length === 0) { return '' }
-  return stringify(fragment.children, '', options)
-}
-
-module.exports = function translate ({ tree, fragment, attrs, options, variables, filters, translations, languages }) {
-  walk(fragment.children, node => {
-    node.used = true
-  })
-  const content = getSlotContent(fragment, options)
-  const attribute = attrs[0]
-  const { key } = attribute
-  const expression = getTranslateCallExpression(key, variables, content, filters, translations, languages)
-  tree.append(getTemplateAssignmentExpression(options.variables.template, expression))
-}

package/src/tags/translation.js

@@ -1,38 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { OBJECT_VARIABLE } = require('../utilities/enum')
-const { createTranslationError } = require('../utilities/errors')
-
-const { IfStatement, BinaryExpression, MemberExpression, Identifier, Literal, BlockStatement } = AbstractSyntaxTree
-
-module.exports = function translation ({ tree, fragment, attrs, options, languages, stack, errors, collectChildren }) {
-  const attr = attrs[0]
-  const language = attr && attr.key
-  fragment.used = true
-  const leaf = fragment.children[0]
-  if (!leaf) {
-    errors.push(createTranslationError('Translation tag cannot be empty', stack))
-  } else if (!language) {
-    errors.push(createTranslationError('Translation tag needs to have a language attribute', stack))
-  } else if (!languages.includes(language)) {
-    errors.push(createTranslationError(`Translation tag uses a language that is not specified in compiler options: ${language}`, stack))
-  } else {
-    const ast = new AbstractSyntaxTree()
-    collectChildren(fragment, ast)
-    const statement = new IfStatement({
-      test: new BinaryExpression({
-        left: new MemberExpression({
-          object: new Identifier({ name: OBJECT_VARIABLE }),
-          property: new Identifier({ name: 'language' })
-        }),
-        right: new Literal({ value: language }),
-        operator: '==='
-      }),
-      consequent: new BlockStatement({
-        body: ast.body
-      })
-    })
-    tree.append(statement)
-  }
-}

package/src/tags/try.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { getIdentifier } = require('../utilities/ast')
-const { getTemplateVariableDeclaration, getTemplateAssignmentExpression, getTryStatement } = require('../utilities/factory')
-const { TEMPLATE_VARIABLE } = require('../utilities/enum')
-
-module.exports = function ({ fragment, tree, options, collectChildren }) {
-  const ast = new AbstractSyntaxTree('')
-  const variable = `_${TEMPLATE_VARIABLE}`
-  options.variables.template = variable
-  ast.append(getTemplateVariableDeclaration(variable))
-  collectChildren(fragment, ast)
-  ast.append(getTemplateAssignmentExpression(TEMPLATE_VARIABLE, getIdentifier(variable)))
-  options.variables.template = TEMPLATE_VARIABLE
-  tree.append(getTryStatement(ast.body))
-}

package/src/tags/unless.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { convertKey } = require('../utilities/convert')
-
-module.exports = function ({ fragment, tree, attrs, variables, depth, collectChildren }) {
-  const ast = new AbstractSyntaxTree('')
-  collectChildren(fragment, ast)
-  const { key } = attrs[0]
-  tree.append({
-    type: 'IfStatement',
-    test: {
-      type: 'UnaryExpression',
-      operator: '!',
-      prefix: true,
-      argument: convertKey(key, variables)
-    },
-    consequent: {
-      type: 'BlockStatement',
-      body: ast.body
-    },
-    depth
-  })
-}

package/src/tags/var.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { isCurlyTag, getTagValue } = require('../utilities/string')
-
-const getExpression = (value) => {
-  if (isCurlyTag(value)) {
-    const source = getTagValue(value)
-    const tree = new AbstractSyntaxTree(`(${source})`)
-    const { expression } = tree.body[0]
-    return expression
-  } else {
-    return { type: 'Literal', value }
-  }
-}
-
-module.exports = function ({ tree, attrs, variables }) {
-  const attribute = attrs[0]
-  const { key, value } = attribute
-  variables.push(key)
-  tree.append({
-    type: 'VariableDeclaration',
-    declarations: [
-      {
-        type: 'VariableDeclarator',
-        init: getExpression(value),
-        id: { type: 'Identifier', name: key }
-      }
-    ],
-    kind: 'var'
-  })
-}

package/src/transpilers/css/index.js

@@ -1,34 +0,0 @@
-'use strict'
-
-const { parse, walk, generate } = require('css-tree')
-const createHash = require('string-hash')
-const { camelize } = require('pure-utilities/string')
-
-function transpile (source) {
-  const hash = createHash(source)
-  const tree = parse(source)
-  walk(tree, node => {
-    if (node.type === 'ClassSelector') {
-      node.name = `${camelize(node.name)}-${hash}`
-    }
-    if (node.type === 'TypeSelector') {
-      node.type = 'ClassSelector'
-      node.name = `${camelize(node.name)}-${hash}`
-    }
-  })
-  return generate(tree)
-}
-
-function getSelectors (source) {
-  const tree = parse(source)
-  const selectors = {}
-  walk(tree, node => {
-    if (node.type === 'ClassSelector') {
-      const [key] = node.name.split('-')
-      selectors[key] = node.name
-    }
-  })
-  return selectors
-}
-
-module.exports = { transpile, getSelectors }

package/src/transpilers/html/expression.js

@@ -1,101 +0,0 @@
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { unique } = require('pure-utilities/array')
-const lexer = require('../../lexers/internal')
-const { BUILT_IN_VARIABLES } = require('../../utilities/enum')
-
-const { ArrayExpression, CallExpression, Identifier, Literal, ObjectPattern, Property, toBinaryExpression } = AbstractSyntaxTree
-
-function isIdentifierGlobal (name) {
-  return name === 'undefined' || BUILT_IN_VARIABLES.includes(name)
-}
-
-function markNodes (expression) {
-  if (!expression) { return }
-  if (expression.type === 'Identifier' && !isIdentifierGlobal(expression.name)) {
-    expression.parameter = true
-  }
-  markNodes(expression.left)
-  markNodes(expression.right)
-  markNodes(expression.argument)
-  markNodes(expression.expression)
-  markNodes(expression.test)
-  markNodes(expression.consequent)
-  markNodes(expression.alternate)
-  markNodes(expression.callee)
-  markNodes(expression.value)
-  markNodes(expression.object)
-  expression.computed && markNodes(expression.property)
-  expression.arguments?.forEach(markNodes)
-  expression.properties?.forEach(markNodes)
-  expression.elements?.forEach(markNodes)
-}
-
-function findParams (body) {
-  const tree = new AbstractSyntaxTree(body)
-  const nodes = tree.find('Identifier[parameter=true]')
-  return unique(nodes.map(node => node.name))
-}
-
-function findChildren (body) {
-  const tree = new AbstractSyntaxTree(body)
-  const node = tree.first('Identifier[name="__children__"]')
-  return node
-}
-
-function deduceParams (body) {
-  const params = findParams(body)
-  const children = findChildren(body)
-  return [
-    params.length > 0
-      ? new ObjectPattern({
-          properties: params.map(param => {
-            const node = new Identifier(param)
-            return new Property({
-              key: node,
-              value: node,
-              kind: 'init',
-              computed: false,
-              method: false,
-              shorthand: true
-            })
-          })
-        })
-      : children && new Identifier('__UNUSED_PARAM__'),
-    children
-  ].filter(Boolean)
-}
-
-function normalizeTokenValue (value) {
-  if (value.trim().startsWith('{') && value.trim().endsWith('}')) {
-    return `(${value})`
-  }
-  return value
-}
-
-function transpileExpression (source, escape = true) {
-  const tokens = lexer(source)
-  const nodes = tokens.map(token => {
-    if (token.type === 'expression') {
-      token.value = normalizeTokenValue(token.value)
-      const tree = new AbstractSyntaxTree(token.value)
-      const { expression } = tree.first('ExpressionStatement')
-      markNodes(expression)
-      if (escape) {
-        return new CallExpression({
-          callee: new Identifier({ name: 'escape' }),
-          arguments: [expression]
-        })
-      } else {
-        return expression
-      }
-    }
-    if (token.type === 'text') {
-      return new Literal({ value: token.value })
-    }
-    return null
-  }).filter(Boolean)
-
-  return toBinaryExpression(new ArrayExpression(nodes))
-}
-
-module.exports = { transpileExpression, findParams, markNodes, deduceParams }