splendid/build/App.js

const { join } = require('path');
const { getBlocks } = require('./lib/blocks');
const getRules = require('./lib/components/competent');
const { loadComponents, loadElements } = require('./lib/components/load');

const SPLENDID_COMPS = join(__dirname, 'components')
const SPLENDID_ELS = join(__dirname, 'elements')

/**
 * @todo Load components/elements on demand.
 */
class App {
  /**
   * The app holds components, elements and other replacements.
   * @param {Config} conf
   */
  constructor(conf, { splendidComps = true, splendidEls = true } = {}) {
    this.conf = conf
    /**
     * @type {Object<string, ()}}
     * The hashmap of elements.
     * Elements are functions for static HTML, not published JS.
     */
    this.els = {}
    /**
     * @type {Object<string, ()}}
     * The hashmap of components.
     */
    this.comps = {}

    const { appDir, elements, components } = this.conf

    /**
     * The array of directories with components.
     * @type {string[]}
     */
    this.componentsDirs = []
    if (splendidComps) this.componentsDirs.push(SPLENDID_COMPS)
    /**
     * The array of directories with elements.
     * @type {string[]}
     */
    this.elementsDirs = []
    if (splendidEls) this.elementsDirs.push(SPLENDID_ELS)

    if (components) {
      const compDirs = Array.isArray(components) ? components : [components]
      this.componentsDirs.push(...compDirs.map(el => join(appDir, el)))
    }

    if (elements) {
      const elDirs = Array.isArray(elements) ? elements : [elements]
      this.elementsDirs.push(...elDirs.map(el => join(appDir, el)))
    }

    /**
     * Cached layouts.
     */
    this.layouts = {}
  }
  get compsAndEls() {
    return { ...this.comps, ...this.els }
  }
  _updateReplacements() {
    const replacements = getRules(this.compsAndEls)
    /**
     * The rule for components and elements.
     */
    this.replacements = replacements
  }
  async updateEls(skipReplacements = false) {
    const { els, map, loaded } = await this.elementsDirs.reduce(async (acc, dir) => {
      acc = await acc
      const { els: e, map: m, loaded: l } = await loadElements(dir)
      Object.assign(acc.els, e)
      Object.assign(acc.map, m)
      Object.assign(acc.loaded, l)
      return acc
    }, { els: {}, map: {}, loaded: {} })
    this.els = els
    this.elMap = map
    if (!skipReplacements) this._updateReplacements()
    return loaded
  }
  /**
   * Reads the components from the given dir.
   */
  async updateComps() {
    const { comps, map, loaded } = await this.componentsDirs.reduce(async (acc, dir) => {
      acc = await acc
      const { comps: e, map: m, loaded: l } = await loadComponents(dir, this.els, dir != SPLENDID_COMPS)
      Object.assign(acc.comps, e)
      Object.assign(acc.map, m)
      Object.assign(acc.loaded, l)
      return acc
    }, { comps: {}, map: {}, loaded: {} })

    this.comps = comps
    this.map = map

    this._updateReplacements()
    return loaded
  }
  async updateBlocks() {
    const { blocks, appDir } = this.conf
    if (!blocks) { this.blocks = []; return }
    const b = Array.isArray(blocks) ? blocks : [blocks]
    const bb = await Promise.all(b.map(async (path) => {
      const block = await getBlocks(appDir, path)
      return block
    }))
    this.blocks = bb
  }
  async init() {
    await this.updateEls(true)
    await this.updateComps()
    await this.updateBlocks()
    const {
      replacements: regexReplacements = [],
    } = this.conf
    const areaReplacements = [
      ...this.blocks,
      ...regexReplacements,
    ]
    // const replacements = [
    //   ...compsReplacements,
    //   ...elsReplacements,
    // {
    //   re: /[\s\S]+/,
    //   replacement(m) {
    //     debugger
    //     return m
    //   },
    // },
    // ]
    this.areaReplacements = areaReplacements
  }
}

/**
 * @typedef {import('splendid').Config} Config
 * @typedef {import('splendid').Page} Page
 */

module.exports = App