@knapsack/app/dist/cli/commands.js

Build Design Systems on top of knapsack, by Basalt

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getMeta = getMeta;
exports.writeTemplateMeta = writeTemplateMeta;
exports.initAll = initAll;
exports.build = build;
exports.testPatternRenders = testPatternRenders;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _fsExtra = _interopRequireDefault(require("fs-extra"));

var _portfinder = _interopRequireDefault(require("portfinder"));

var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));

var _path = require("path");

var _serverUtils = require("../server/server-utils");

var _utils = require("../lib/utils");

var log = _interopRequireWildcard(require("./log"));

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

async function getMeta(config) {
  const {
    version,
    name
  } = await (0, _serverUtils.readJson)((0, _path.join)(__dirname, '../../package.json'));
  const cacheDir = (0, _findCacheDir.default)({
    name,
    create: true
  });
  const serverPort = await _portfinder.default.getPortPromise({
    port: 3999
  });
  const websocketsPort = await _portfinder.default.getPortPromise();
  return {
    websocketsPort,
    serverPort,
    knapsackVersion: version,
    cacheDir,
    version: config.version,
    hasKnapsackCloud: 'cloud' in config
  };
}

async function writeTemplateMeta({
  templateRenderers,
  allPatterns,
  distDir
}) {
  const getTime = (0, _utils.timer)();
  const metaDir = (0, _path.join)(distDir, 'meta');

  try {
    await _fsExtra.default.emptyDir(metaDir);
  } catch (e) {
    const msg = `'Could not empty the meta directory in the dist directory': ${e.message}`;
    log.error(msg, e);
    throw new Error(e);
  }

  await Promise.all(templateRenderers.filter(t => t.getTemplateMeta).map(async templateRenderer => {
    const templateMetaFiles = [];
    await Promise.all(allPatterns.map(async pattern => {
      return Promise.all(pattern.templates.filter(t => t.templateLanguageId === templateRenderer.id).map(async template => {
        const files = await templateRenderer.getTemplateMeta({
          pattern,
          template
        });

        if ((files === null || files === void 0 ? void 0 : files.length) > 0) {
          const dir = (0, _path.join)(distDir, 'meta', pattern.id);
          files.map(file => _objectSpread({}, file, {
            path: (0, _path.join)(dir, file.path)
          })).forEach(file => templateMetaFiles.push(file));
        }
      }));
    }));

    if ((templateMetaFiles === null || templateMetaFiles === void 0 ? void 0 : templateMetaFiles.length) > 0) {
      const filesToWrite = templateRenderer.alterTemplateMetaFiles ? await templateRenderer.alterTemplateMetaFiles({
        files: templateMetaFiles,
        metaDir
      }) : templateMetaFiles;
      const dirs = new Set();
      filesToWrite.forEach(file => dirs.add((0, _path.dirname)(file.path)));
      await Promise.all([...dirs].map(async dir => {
        try {
          await _fsExtra.default.ensureDir(dir);
        } catch (e) {
          // sometimes fails if it already exists, but that's ok! Can probably remove warning once we feel better.
          const relativeDir = (0, _path.relative)(process.cwd(), dir);
          log.warn(`Had an error that is probably ok but wanted to warn for now while running "ensureDir" in "writeTemplateMeta" for ${relativeDir}`, e);
        }
      })); // To ensure that we don't try to write to the same file twice, we'll do this synchronous

      filesToWrite.forEach(file => {
        const filePath = (0, _path.isAbsolute)(file.path) ? file.path : (0, _path.join)(metaDir, file.path);

        _fsExtra.default.writeFileSync(filePath, file.contents, {
          encoding: file.encoding
        });
      });
    }
  })).catch(err => {
    const msg = `Error writeTemplateMeta: ${err.message}`;
    log.error(msg, err);
    throw new Error(err);
  });
  log.verbose(`writeTemplateMeta took ${getTime()}s`);
}

async function initAll(ksBrain) {
  log.info('Initializing...');
  const {
    config,
    patterns
  } = ksBrain;
  const meta = await getMeta(config);
  await patterns.init({
    cacheDir: meta.cacheDir
  });
  await Promise.all(config.templateRenderers.map(async templateRenderer => {
    if (templateRenderer.init) {
      await templateRenderer.init({
        config,
        patterns,
        cacheDir: meta.cacheDir
      });
      log.info('Init done', null, `templateRenderer:${templateRenderer.id}`);
    }
  }));

  if (config.plugins) {
    await Promise.all(config.plugins.filter(p => p.init).map(p => p.init(ksBrain)));
  }

  await writeTemplateMeta({
    templateRenderers: config.templateRenderers,
    allPatterns: patterns.allPatterns,
    distDir: config.dist
  });
  log.info('Done: Initializing');
  return meta;
}

async function build({
  config,
  patterns
}) {
  const getTime = (0, _utils.timer)();
  log.info('Building...');
  await writeTemplateMeta({
    allPatterns: patterns.allPatterns,
    templateRenderers: config.templateRenderers,
    distDir: config.dist
  });
  await Promise.all(config.templateRenderers.map(async templateRenderer => {
    if (!templateRenderer.build) return;
    await templateRenderer.build({
      templatePaths: patterns.getAllTemplatePaths({
        templateLanguageId: templateRenderer.id
      })
    });
    log.info('Built', null, `templateRenderer:${templateRenderer.id}`);
  }));
  log.info('Knapsack built', null, 'build');
  log.verbose(`Build took ${getTime()}s`);
}

async function testPatternRenders(allPatterns, patterns) {
  const results = [];
  await Promise.all(allPatterns.map(async pattern => Promise.all(pattern.templates.map(async template => {
    return Promise.all(template.demos.map(async demo => {
      const result = await patterns.render({
        patternId: pattern.id,
        templateId: template.id,
        demo: template.demosById[demo]
      });
      results.push({
        ok: result.ok,
        patternId: pattern.id,
        templateId: template.id
      });
    }));
  })))).catch(err => {
    log.error('Test error', err, 'test');
    process.exit(1);
  });
  let exitCode = 0;
  results.forEach(result => {
    const {
      ok,
      patternId,
      templateId
    } = result;

    if (!ok) {
      exitCode = 1;
      log.error(`fail - Pattern: ${patternId} - Template: ${templateId}`, null, 'test');
    }

    log.info(`ok - Pattern: ${patternId} - Template: ${templateId}`, null, 'test');
  });
  const ok = exitCode === 0;
  const fails = results.filter(p => p.ok).length;
  const msg = `${results.length} tests ran, ${fails} failed`;

  if (!ok) {
    log.error(msg, null, 'test');
    process.exit(1);
  }

  log.info(msg, null, 'test');
}