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,
  copyTask,
  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"] }));

task(
  "prepare-for-build",
  parallel(
    babelTransformTask({ paths: ["src_js"], dest: "dist" }),
    copyTask({ paths: ["src_js/**/*.d.ts"], dest: "dist" }),
    emcmakeGenerateTask()
  )
);

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("prepare-for-build", `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("prepare-for-build", "cmake-build:all"));

task(
  "test",
  series(
    "prepare-for-build",
    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("prepare-for-build", "cmake-build:sync", runBenchTask())
);

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

function babelTransformTask(opts: {
  paths: ReadonlyArray<string>;
  dest: string;
}) {
  return () => {
    const args = [...opts.paths, "--source-maps", "--out-dir", opts.dest];
    logger.info(`Transforming [${opts.paths.join(",")}] to '${opts.dest}'`);

    return spawn(node, [require.resolve("@babel/cli/bin/babel"), ...args]);
  };
}

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",
    });
  };
}