yoga/javascript/just.config.ts

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @format
 */

import {
  argv,
  cleanTask,
  eslintTask,
  logger,
  jestTask,
  option,
  parallel,
  series,
  spawn,
  task,
  tscTask,
} from 'just-scripts';

import glob from 'glob';
import path from 'path';
import which from 'which';

const node = process.execPath;

option('fix');

task('clean', cleanTask({paths: ['build', 'dist']}));

function defineFlavor(flavor: string, env: NodeJS.ProcessEnv) {
  task(`cmake-build:${flavor}`, cmakeBuildTask({targets: [flavor]}));
  task(
    `jest:${flavor}`,
    jestTask({config: path.join(__dirname, 'jest.config.ts'), env}),
  );
  task(
    `test:${flavor}`,
    series(emcmakeGenerateTask(), `cmake-build:${flavor}`, `jest:${flavor}`),
  );
}

defineFlavor('asmjs-async', {WASM: '0', SYNC: '0'});
defineFlavor('asmjs-sync', {WASM: '0', SYNC: '1'});
defineFlavor('wasm-async', {WASM: '1', SYNC: '0'});
defineFlavor('wasm-sync', {WASM: '1', SYNC: '1'});

task('cmake-build:all', cmakeBuildTask());
task(
  'cmake-build:async',
  cmakeBuildTask({targets: ['asmjs-async', 'wasm-async']}),
);
task(
  'cmake-build:sync',
  cmakeBuildTask({targets: ['asmjs-sync', 'wasm-sync']}),
);

task('build', series(emcmakeGenerateTask(), 'cmake-build:all'));

task(
  'test',
  series(
    emcmakeGenerateTask(),
    series('cmake-build:asmjs-async', 'jest:asmjs-async'),
    series('cmake-build:asmjs-sync', 'jest:asmjs-sync'),
    series('cmake-build:wasm-async', 'jest:wasm-async'),
    series('cmake-build:wasm-sync', 'jest:wasm-sync'),
  ),
);

task(
  'benchmark',
  series(emcmakeGenerateTask(), 'cmake-build:sync', runBenchTask()),
);

task(
  'lint',
  parallel(
    tscTask({noEmit: true}),
    series(eslintTask({fix: argv().fix}), clangFormatTask({fix: argv().fix})),
  ),
);

task(
  'prepublish',
  parallel(
    'build',
    tscTask({emitDeclarationOnly: true}),
    babelTransformTask({dir: 'src'}),
  ),
);

function babelTransformTask(opts: {dir: string}) {
  return () => {
    const args = [
      opts.dir,
      '--source-maps',
      '--out-dir',
      opts.dir,
      '--extensions',
      '.js,.ts',
    ];
    logger.info(`Transforming "${path.resolve(opts.dir)}"`);

    return spawn(node, [require.resolve('@babel/cli/bin/babel'), ...args], {
      cwd: __dirname,
    });
  };
}

function runBenchTask() {
  return () => {
    const files = glob.sync('./tests/Benchmarks/**/*');
    const args = ['./tests/bin/run-bench.ts', ...files];
    logger.info(args.join(' '));

    return spawn(node, args, {
      stdio: 'inherit',
      env: {NODE_OPTIONS: '-r ts-node/register'},
    });
  };
}

function emcmakeGenerateTask() {
  return () => {
    const emcmake = which.sync('emcmake');
    const ninja = which.sync('ninja', {nothrow: true});
    const args = [
      'cmake',
      '-S',
      '.',
      '-B',
      'build',
      ...(ninja ? ['-G', 'Ninja'] : []),
    ];
    logger.info(['emcmake', ...args].join(' '));

    return spawn(emcmake, args);
  };
}

function cmakeBuildTask(opts?: {targets?: ReadonlyArray<string>}) {
  return () => {
    const cmake = which.sync('cmake');
    const args = [
      '--build',
      'build',
      ...(opts?.targets ? ['--target', ...opts.targets] : []),
    ];
    logger.info(['cmake', ...args].join(' '));

    return spawn(cmake, args, {stdio: 'inherit'});
  };
}

function clangFormatTask(opts?: {fix?: boolean}) {
  return () => {
    const args = [
      ...(opts?.fix ? ['-i'] : ['--dry-run', '--Werror']),
      ...glob.sync('**/*.{h,hh,hpp,c,cpp,cc,m,mm}'),
    ];
    logger.info(['clang-format', ...args].join(' '));

    return spawn(node, [require.resolve('clang-format'), ...args], {
      stdio: 'inherit',
    });
  };
}