scontainers/dist/loader.js

A container/collection/iterator library for JavaScript, comfortable to use, performant and versatile.

"use strict";

function _implSymbol(target, sym, value) {
  Object.defineProperty(target, sym, {
    value,
    configurable: true
  });
  return target[sym];
}

function _getSymbol(targetSymName, ...traitSets) {
  let symbol;
  traitSets.forEach(traitSet => {
    const sym = traitSet[targetSymName];

    if (typeof sym === 'symbol') {
      if (!!symbol && symbol !== sym) {
        throw new Error(`Symbol ${targetSymName} offered by multiple trait sets.`);
      }

      symbol = sym;
    }
  });

  if (!symbol) {
    throw new Error(`No trait set is providing symbol ${targetSymName}.`);
  }

  return symbol;
}

function _testTraitSet(traitSet) {
  if (!traitSet || typeof traitSet === 'boolean' || typeof traitSet === 'number' || typeof traitSet === 'string') {
    throw new Error(`${traitSet} cannot be used as a trait set.`);
  }
}

const path = require('path');

const scontainersPath = path.dirname(require.resolve('./utils.js'));

const logger = require('./logger.js')(`loader`);

function load(opts = {}) {
  const backupCache = {};
  logger.log();
  logger.log(`Cleaning require.cache`);
  logger.group(); // clearing the require cache for scontainers' directories

  for (let modPath in require.cache) {
    modPath = require.resolve(modPath);

    if (modPath.startsWith(scontainersPath)) {
      logger.log(modPath);
      backupCache[modPath] = require.cache[modPath];
      delete require.cache[modPath];
    }
  }

  logger.groupEnd();
  logger.log(`Reloading scontainers`);
  logger.group();

  const options = require('./options.js');

  Object.assign(options, opts);

  const scontainers = require('./index.js'); // restoring the older require cache


  Object.assign(require.cache, backupCache);
  logger.groupEnd();
  return scontainers;
}

module.exports = load;

if (require.main === module) {
  const assert = require('assert');

  let getFn;
  {
    const scontainers = require('./index.js');

    _testTraitSet(scontainers);

    const _iter = _getSymbol("iter", scontainers);

    const _map = _getSymbol("map", scontainers);

    const _get = _getSymbol("get", scontainers);

    assert(![][_iter]);
    getFn = [][_map](x => x)[_get].factory().toString();
    assert(getFn === [][_map](x => x)[_get].factory().toString());
  }
  {
    const scontainers = load({
      debug: true,
      generation: false
    });

    _testTraitSet(scontainers);

    const _iter2 = _getSymbol("iter", scontainers);

    const _map2 = _getSymbol("map", scontainers);

    const _get2 = _getSymbol("get", scontainers);

    assert(!![][_iter2]);
    assert(getFn !== [][_map2](x => x)[_get2].factory().toString());
  }
  {
    const scontainers = load();

    _testTraitSet(scontainers);

    const _iter3 = _getSymbol("iter", scontainers);

    const _map3 = _getSymbol("map", scontainers);

    const _get3 = _getSymbol("get", scontainers);

    assert(![][_iter3]);
    assert(getFn === [][_map3](x => x)[_get3].factory().toString());
  }
}