boxwood 0.60.2 → 0.61.0

package/src/Optimizer.js

@@ -1,96 +0,0 @@
-'use strict'
-
-const { TEMPLATE_VARIABLE } = require('./utilities/enum')
-const {
-  match,
-  memberExpressionReduction,
-  logicalExpressionReduction,
-  binaryExpressionReduction,
-  ternaryOperatorReduction,
-  ifStatementRemoval
-} = require('abstract-syntax-tree')
-
-function isAssignmentExpressionWithLiteral (node) {
-  return isAssignmentExpression(node) && node.expression.right.type === 'Literal'
-}
-
-function isAssignmentExpression (node) {
-  return node && match(node, 'ExpressionStatement[expression.type="AssignmentExpression"]')
-}
-
-function isTemplateVariableDeclaration (node) {
-  return node && node.type === 'VariableDeclaration' && node.declarations[0].id.name === TEMPLATE_VARIABLE
-}
-
-class Optimizer {
-  optimize (tree) {
-    // can the below be done in one walk?
-    tree.replace({ enter: memberExpressionReduction })
-    tree.replace({ enter: logicalExpressionReduction })
-    tree.replace({ enter: binaryExpressionReduction })
-    tree.replace({ enter: ternaryOperatorReduction })
-    tree.replace({ enter: ifStatementRemoval })
-    this.concatenateLiterals(tree)
-    this.concatenateAssignmentExpressions(tree)
-    this.simplifyReturnValue(tree)
-  }
-
-  concatenateLiterals (tree) {
-    tree.walk(node => {
-      if (node.body && node.body.reduce) {
-        node.body = node.body.reduce((result, leaf) => {
-          const last = result[result.length - 1]
-          if (isAssignmentExpressionWithLiteral(leaf)) {
-            if (isTemplateVariableDeclaration(last)) {
-              last.declarations[0].init.value += leaf.expression.right.value
-            } else if (isAssignmentExpressionWithLiteral(last)) {
-              last.expression.right.value += leaf.expression.right.value
-            } else {
-              result.push(leaf)
-            }
-          } else {
-            result.push(leaf)
-          }
-          return result
-        }, [])
-      }
-    })
-  }
-
-  concatenateAssignmentExpressions (tree) {
-    tree.walk(node => {
-      if (node.body && node.body.reduce) {
-        node.body = node.body.reduce((result, leaf) => {
-          // add below code when empty statements are removed properly
-          // const last = result[result.length - 1]
-          // if (isAssignmentExpression(leaf)) {
-          //   if (isAssignmentExpression(last)) {
-          //     last.expression.right = {
-          //       type: "BinaryExpression",
-          //       left: last.expression.right,
-          //       right: leaf.expression.right,
-          //       operator: "+"
-          //     }
-          //   } else {
-          //     result.push(leaf)
-          //   }
-          // } else {
-          //   result.push(leaf)
-          // }
-          result.push(leaf)
-          return result
-        }, [])
-      }
-    })
-  }
-
-  simplifyReturnValue (tree) {
-    const { body } = tree
-    if (body.length === 2) {
-      const { value } = body[0].declarations[0].init
-      tree.body = [{ type: 'ReturnStatement', argument: { type: 'Literal', value } }]
-    }
-  }
-}
-
-module.exports = Optimizer

package/src/Scope.js

@@ -1,20 +0,0 @@
-const { replace } = require('abstract-syntax-tree')
-const { OBJECT_VARIABLE } = require('./utilities/enum')
-const { isGlobalVariable } = require('./utilities/globals')
-
-class Scope {
-  flatten (tree) {
-    replace(tree, node => {
-      if (isGlobalVariable(node)) {
-        return {
-          type: 'MemberExpression',
-          object: { type: 'Identifier', name: OBJECT_VARIABLE },
-          property: node.property,
-          computed: node.computed
-        }
-      }
-    })
-  }
-}
-
-module.exports = Scope

package/src/Statistics.js

@@ -1,58 +0,0 @@
-'use strict'
-
-// TODO pure-utilities unique should work for objects
-function uniq (array) {
-  // @ts-ignore
-  return Array.from(new Set(array.map(item => JSON.stringify(item)))).map(JSON.parse)
-}
-
-class Statistics {
-  constructor () {
-    this.components = []
-    this.partials = []
-    this.images = []
-    this.scripts = []
-    this.stylesheets = []
-    this.translations = []
-  }
-
-  concat (name, array) {
-    this[name] = this[name].concat(array)
-    return this
-  }
-
-  merge (statistics) {
-    this
-      .concat('components', statistics.components)
-      .concat('partials', statistics.partials)
-      .concat('images', statistics.images)
-      .concat('scripts', statistics.scripts)
-      .concat('stylesheets', statistics.stylesheets)
-      .concat('translations', statistics.translations)
-  }
-
-  assets () {
-    return uniq([].concat(
-      this.components.map(item => item.path),
-      this.partials.map(item => item.path),
-      this.images.map(item => item.path),
-      this.scripts.map(item => item.path),
-      this.stylesheets.map(item => item.path),
-      this.translations.map(item => item.path)
-    ))
-  }
-
-  serialize () {
-    return {
-      components: uniq(this.components),
-      partials: uniq(this.partials),
-      images: uniq(this.images),
-      scripts: uniq(this.scripts),
-      stylesheets: uniq(this.stylesheets),
-      translations: uniq(this.translations),
-      assets: this.assets()
-    }
-  }
-}
-
-module.exports = Statistics

package/src/bundlers/esbuild/index.js

@@ -1,55 +0,0 @@
-const esbuild = require('esbuild')
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { writeFileSync, unlinkSync } = require('fs')
-const { join } = require('path')
-const { tmpdir } = require('os')
-const { uid } = require('pure-utilities/string')
-const ResolvePlugin = require('./plugins/resolve')
-const HTMLPlugin = require('./plugins/html')
-const CSSPlugin = require('./plugins/css')
-const YAMLPlugin = require('./plugins/yaml')
-const ImagePlugin = require('./plugins/image')
-
-const bundle = async (source, options = {}) => {
-  const paths = options.paths || []
-  const styles = []
-  const input = join(tmpdir(), `${uid()}.js`)
-
-  writeFileSync(input, source)
-  const result = await esbuild.build({
-    platform: options.platform || 'node',
-    bundle: true,
-    plugins: [
-      ResolvePlugin({ paths }),
-      HTMLPlugin({ paths }),
-      CSSPlugin({ paths, styles }),
-      YAMLPlugin({ paths }),
-      ImagePlugin({ paths })
-    ],
-    entryPoints: [input],
-    format: options.format || 'iife',
-    minify: false,
-    write: false,
-    target: 'es2016'
-  })
-  const file = result.outputFiles[0]
-  unlinkSync(input)
-  const tree = new AbstractSyntaxTree(file.text)
-  tree.replace(node => {
-    // TODO we need a better way to match the global scoped style tag
-    // this could lead to false
-    if (
-      node.type === 'ObjectExpression' &&
-      node.properties.length === 1 &&
-      node.properties[0].type === 'Property' &&
-      node.properties[0].key.type === 'Identifier' &&
-      node.properties[0].key.name === 'scoped'
-    ) {
-      return { type: 'Literal', value: styles.join(' ') }
-    }
-    return node
-  })
-  return tree.source
-}
-
-module.exports = { bundle }

package/src/bundlers/esbuild/plugins/css.js

@@ -1,40 +0,0 @@
-const { promises: { readFile } } = require('fs')
-const { findAsset } = require('../utilities/asset')
-const { transpile: transpileCSS, getSelectors } = require('../../../transpilers/css')
-
-module.exports = ({ paths, styles }) => ({
-  name: 'css',
-  setup (build) {
-    build.onResolve({ filter: /\.css/ }, args => ({
-      path: args.path,
-      namespace: 'boxwood-css'
-    }))
-    build.onLoad({
-      filter: /.*/,
-      namespace: 'boxwood-css'
-    }, async (args) => {
-      const hasParams = args.path.includes('?')
-      const isScoped = hasParams && args.path.includes('scoped=true')
-      const path = hasParams ? args.path.substring(0, args.path.indexOf('?')) : args.path
-      const asset = findAsset(path, 'css', { paths })
-      if (!asset) {
-        // throw with a nice error message and add specs
-      }
-      const content = await readFile(asset.path, 'utf8')
-      if (isScoped) {
-        const style = transpileCSS(content)
-        const selectors = getSelectors(style)
-        styles.push(style)
-        return {
-          contents: `export default ${JSON.stringify(selectors)}`,
-          loader: 'js'
-        }
-      } else {
-        return {
-          contents: `export default \`${content}\``,
-          loader: 'js'
-        }
-      }
-    })
-  }
-})

package/src/bundlers/esbuild/plugins/html.js

@@ -1,27 +0,0 @@
-const { promises: { readFile } } = require('fs')
-const { findAsset } = require('../utilities/asset')
-const { transpile: transpileHTML } = require('../../../transpilers/html')
-
-module.exports = ({ paths }) => ({
-  name: 'html',
-  setup (build) {
-    build.onResolve({ filter: /\.html?$/ }, args => ({
-      path: args.path.replace(/\.html$/, ''),
-      namespace: 'boxwood-html'
-    }))
-    build.onLoad({
-      filter: /.*/,
-      namespace: 'boxwood-html'
-    }, async (args) => {
-      const asset = findAsset(args.path, 'html', { paths })
-      if (!asset) {
-        // throw with a nice error message and add specs
-      }
-      const content = await readFile(asset.path, 'utf8')
-      return {
-        contents: transpileHTML(content.trim()),
-        loader: 'js'
-      }
-    })
-  }
-})

package/src/bundlers/esbuild/plugins/image.js

@@ -1,38 +0,0 @@
-const { promises: { readFile } } = require('fs')
-const { findAsset } = require('../utilities/asset')
-const { getExtension, getBase64Extension } = require('../../../utilities/string')
-
-function getBase64String (base64, path) {
-  const extension = getExtension(path)
-  return [
-    `data:image/${getBase64Extension(extension)}`,
-    'charset=utf-8',
-    `base64,${base64}`
-  ].join(';')
-}
-
-module.exports = ({ paths }) => ({
-  name: 'image',
-  setup (build) {
-    build.onResolve({ filter: /\.png|\.svg|\.jpg|\.jpeg/ }, args => ({
-      path: args.path,
-      namespace: 'boxwood-image'
-    }))
-    build.onLoad({
-      filter: /.*/,
-      namespace: 'boxwood-image'
-    }, async (args) => {
-      const asset = findAsset(args.path, null, { paths })
-      if (!asset) {
-        // TODO throw with a nice error message and add specs
-      }
-
-      const buffer = await readFile(asset.path)
-      const base64 = buffer.toString('base64')
-      return {
-        contents: `export default "${getBase64String(base64, asset.path)}"`,
-        loader: 'js'
-      }
-    })
-  }
-})

package/src/bundlers/esbuild/plugins/resolve.js

@@ -1,11 +0,0 @@
-const { findAsset } = require('../utilities/asset')
-
-module.exports = ({ paths }) => ({
-  name: 'resolve',
-  setup (build) {
-    build.onResolve({ filter: /.*/ }, args => {
-      // TODO handle libs from node_modules out of the box
-      return findAsset(args.path, undefined, { paths })
-    })
-  }
-})

package/src/bundlers/esbuild/plugins/yaml.js

@@ -1,38 +0,0 @@
-const YAML = require('yaml')
-const { findAsset } = require('../utilities/asset')
-const { promises: { readFile } } = require('fs')
-
-module.exports = ({ paths }) => ({
-  name: 'yaml',
-  setup (build) {
-    build.onResolve({ filter: /\.yaml?$/ }, args => ({
-      path: args.path.replace(/\.yaml$/, ''),
-      namespace: 'boxwood-yaml'
-    }))
-    build.onLoad({
-      filter: /.*/,
-      namespace: 'boxwood-yaml'
-    }, async (args) => {
-      const asset = findAsset(args.path, 'yaml', { paths })
-      if (!asset) {
-        // throw with a nice error message and add specs
-      }
-      const content = await readFile(asset.path, 'utf8')
-      const data = YAML.parse(content)
-      return {
-        contents: `
-          const data = ${JSON.stringify(data)}
-
-          export function i18n (language) {
-            return function (key) {
-              return data.i18n[key][language]
-            }
-          }
-
-          export default data
-        `,
-        loader: 'js'
-      }
-    })
-  }
-})

package/src/bundlers/esbuild/utilities/asset.js

@@ -1,19 +0,0 @@
-const { existsSync } = require('fs')
-const { join } = require('path')
-
-function findAsset (filepath, extension = 'js', { paths }) {
-  const searchPath = extension
-    ? filepath.endsWith(`.${extension}`) ? filepath : `${filepath}.${extension}`
-    : filepath
-  for (let i = 0, ilen = paths.length; i < ilen; i += 1) {
-    const path = join(paths[i], searchPath)
-    const index = join(paths[i], filepath, `index.${extension}`)
-    if (existsSync(path)) {
-      return { path }
-    } else if (extension && existsSync(index)) {
-      return { path: index }
-    }
-  }
-}
-
-module.exports = { findAsset }

package/src/bundlers/rollup.js

@@ -1,38 +0,0 @@
-// @ts-nocheck
-
-'use strict'
-
-const AbstractSyntaxTree = require('abstract-syntax-tree')
-const { rollup } = require('rollup')
-const { nodeResolve } = require('@rollup/plugin-node-resolve')
-const commonjs = require('@rollup/plugin-commonjs')
-const paths = require('rollup-plugin-includepaths')
-const { writeFileSync, unlinkSync } = require('fs')
-const { join } = require('path')
-const { tmpdir } = require('os')
-const { uid } = require('pure-utilities/string')
-
-const bundle = async (source, options = {}) => {
-  const tree = new AbstractSyntaxTree(source)
-  if (tree.has('ImportDeclaration')) {
-    const input = join(tmpdir(), `${uid()}.js`)
-    writeFileSync(input, source)
-    const bundle = await rollup({
-      input,
-      plugins: [
-        paths({ paths: options.paths }),
-        // TODO we could try to find closest node_modules dir here via something like find-node-modules
-        nodeResolve(options.resolve),
-        commonjs()
-      ]
-    })
-    const { output } = await bundle.generate({ format: 'iife' })
-    const { code } = output[0]
-    unlinkSync(input)
-    return code
-  } else {
-    return source
-  }
-}
-
-module.exports = { bundle }

package/src/compile.js

@@ -1,6 +0,0 @@
-const Compiler = require('./Compiler')
-
-module.exports = async function compile (source, options = {}) {
-  const compiler = new Compiler(options)
-  return compiler.compile(source)
-}

package/src/compilers/any/Compiler.js

@@ -1,16 +0,0 @@
-const JSCompiler = require('../js/Compiler')
-const { transpile } = require('../../transpilers/html')
-
-class Compiler {
-  constructor (options = {}) {
-    this.options = options
-  }
-
-  async compile (input) {
-    const source = this.options.format === 'js' ? input : transpile(input, this.options)
-    const compiler = new JSCompiler(this.options)
-    return compiler.compile(source)
-  }
-}
-
-module.exports = Compiler

package/src/compilers/compile.js

@@ -1,17 +0,0 @@
-const JSCompiler = require('./js/Compiler')
-const HTMLCompiler = require('./html/Compiler')
-const AnyCompiler = require('./any/Compiler')
-const { getExtension } = require('../utilities/string')
-
-const compilers = {
-  js: JSCompiler,
-  html: HTMLCompiler,
-  any: AnyCompiler
-}
-
-module.exports = async function compile (input, options) {
-  const extension = getExtension(options.path) || 'html'
-  const Compiler = options.compiler ? compilers[options.compiler] : compilers[extension] || compilers.html
-  const compiler = new Compiler(options)
-  return compiler.compile(input)
-}

package/src/compilers/html/Analyzer.js

@@ -1,24 +0,0 @@
-'use strict'
-
-const { OBJECT_VARIABLE, ESCAPE_VARIABLE } = require('../../utilities/enum')
-
-class Analyzer {
-  analyze (tree) {
-    const params = this.deduceParams(tree)
-    return { params }
-  }
-
-  deduceParams (tree) {
-    // could do it more effectively by checking if given param was used at least once
-    // instead of querying here
-    if (tree.has(`Identifier[name="${ESCAPE_VARIABLE}"]`)) {
-      return [OBJECT_VARIABLE, ESCAPE_VARIABLE].join(', ')
-    } else if (tree.has(`Identifier[name="${OBJECT_VARIABLE}"]`)) {
-      return OBJECT_VARIABLE
-    } else {
-      return ''
-    }
-  }
-}
-
-module.exports = Analyzer

package/src/compilers/html/Compiler.js

@@ -1,47 +0,0 @@
-'use strict'
-
-const Transpiler = require('./Transpiler')
-const Parser = require('./Parser')
-const Renderer = require('./Renderer')
-const Generator = require('./Generator')
-const { validateOptions } = require('../../utilities/options')
-const { normalizeError } = require('../../utilities/errors')
-
-const transpile = (source) => {
-  const transpiler = new Transpiler()
-  return transpiler.transpile(source)
-}
-
-const parse = (source) => {
-  const parser = new Parser()
-  return parser.parse(source)
-}
-
-const generate = async (source, html, options) => {
-  const renderer = new Renderer()
-  const { tree, statistics, warnings, errors } = await renderer.render(source, html, options)
-  const generator = new Generator()
-  const { template, dynamic } = generator.generate(tree)
-  return {
-    template,
-    statistics: statistics.serialize(),
-    errors: errors.concat(validateOptions(options)).map(normalizeError),
-    warnings,
-    dynamic
-  }
-}
-
-class Compiler {
-  constructor (options) {
-    this.options = options
-  }
-
-  async compile (input) {
-    const { options } = this
-    const source = transpile(input)
-    const tree = parse(source)
-    return generate(source, tree, options)
-  }
-}
-
-module.exports = Compiler

package/src/compilers/html/Generator.js

@@ -1,19 +0,0 @@
-'use strict'
-
-const Analyzer = require('./Analyzer')
-
-const analyze = (tree) => {
-  const analyzer = new Analyzer()
-  return analyzer.analyze(tree)
-}
-
-class Generator {
-  generate (tree) {
-    const { params } = analyze(tree)
-    const template = new Function(`return function render(${params}) {\n${tree.source}}`)() // eslint-disable-line
-    const dynamic = params.length > 0
-    return { template, dynamic }
-  }
-}
-
-module.exports = Generator

package/src/compilers/html/Parser.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { parse } = require('../../utilities/html')
-
-class Parser {
-  parse (source) {
-    return parse(source)
-  }
-}
-
-module.exports = Parser