A simple bundler for TypeScript projects using TypeScript project references. 

ashleydavis

ts-project-bundle

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {

    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }

    return new (P || (P = Promise))(function (resolve, reject) {

        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }

        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }

        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }

        step((generator = generator.apply(thisArg, _arguments || [])).next());

var __generator = (this && this.__generator) || function (thisArg, body) {

    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;

    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;

    function verb(n) { return function (v) { return step([n, v]); }; }

        if (f) throw new TypeError("Generator is already executing.");

            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;

            if (y = 0, t) op = [op[0] & 2, t.value];

                case 0: case 1: t = op; break;

                case 4: _.label++; return { value: op[1], done: false };

                case 5: _.label++; y = op[1]; op = [0]; continue;

                case 7: op = _.ops.pop(); _.trys.pop(); continue;

                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }

                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }

                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }

                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }

                    if (t[2]) _.ops.pop();

                    _.trys.pop(); continue;

        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }

        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };

Object.defineProperty(exports, "__esModule", { value: true });

var TsBundler = /** @class */ (function () {

    // Loads a tsconfig file from a particular project.

    TsBundler.prototype.loadTsConfig = function (projectPath) {

        return __awaiter(this, void 0, void 0, function () {

            var tsConfigFilePath, tsConfigExists, _a, _b;

            return __generator(this, function (_c) {

                        tsConfigFilePath = path.join(projectPath, "tsconfig.json");

                        return [4 /*yield*/, fs_extra_1.pathExists(tsConfigFilePath)];

                        tsConfigExists = _c.sent();

                        if (!tsConfigExists) {

                            throw new Error("Can't find tsconfig.json for project in " + projectPath + ", are sure this is a TypeScript project?");

                        _b = (_a = JSON5).parse;

                        return [4 /*yield*/, fs_extra_1.readFile(path.join(projectPath, "tsconfig.json"), "utf8")];

                    case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];

                        return [4 /*yield*/, fs_extra_1.readFile(tsConfigFilePath, "utf8")];

                    case 2: return [2 /*return*/, _b.apply(_a, [_c.sent()])];

    // Main function for the TsBundler api.

    TsBundler.prototype.invoke = function (args) {

            var projectPath, outputPath, mainTsConfig, references, referencedProjectRelativePaths, rootPath, referencedProjectPaths, allProjectPaths, relativeMainProjectPath, outMainPath, _i, referencedProjectRelativePaths_1, relativeLibraryPath, fullLibraryPath, libraryTsConfig;

            return __generator(this, function (_a) {

                        projectPath = path.resolve(args.projectPath || "./");

                        outputPath = path.resolve(args.outPath || "./out");

                        console.log("Bundling project from: " + projectPath + " to " + outputPath + ".");

                        return [4 /*yield*/, this.loadTsConfig(projectPath)];

                        mainTsConfig = _a.sent();

                        references = mainTsConfig.references || [];

                        referencedProjectRelativePaths = references.map(function (reference) { return reference.path; });

                        if (args.projectRoot) {

                            // Project root is specified.

                            rootPath = path.resolve(args.projectRoot);

                            referencedProjectPaths = referencedProjectRelativePaths.map(function (relativePath) { return path.resolve(path.join(projectPath, relativePath)); });

                            allProjectPaths = [projectPath].concat(referencedProjectPaths);

                            rootPath = lca_1.findCommonRoot(allProjectPaths);

                            console.log("Automatically detected project root: " + rootPath);

                        relativeMainProjectPath = path.relative(rootPath, projectPath);

                        outMainPath = path.resolve(path.join(outputPath, relativeMainProjectPath));

                        return [4 /*yield*/, fs_extra_1.ensureDir(outMainPath)];

                        _i = 0, referencedProjectRelativePaths_1 = referencedProjectRelativePaths;

                        if (!(_i < referencedProjectRelativePaths_1.length)) return [3 /*break*/, 7];

                        relativeLibraryPath = referencedProjectRelativePaths_1[_i];

                        fullLibraryPath = path.resolve(path.join(projectPath, relativeLibraryPath));

                        return [4 /*yield*/, this.loadTsConfig(fullLibraryPath)];

                        libraryTsConfig = _a.sent();

                        // Copy the compiled library package to the output directory.

                        return [4 /*yield*/, this.copyCompiledPackaged(outMainPath, relativeLibraryPath, fullLibraryPath, libraryTsConfig)];

                        return [3 /*break*/, 3];

                    // Copy the compiled main package to the output directory.

                    return [4 /*yield*/, this.copyCompiledPackaged(outMainPath, "./", projectPath, mainTsConfig)];

                        // Copy the compiled main package to the output directory.

                        return [2 /*return*/];

    TsBundler.prototype.copyFile = function (from, to) {

                        console.log("cp " + from + " " + to);

                        return [4 /*yield*/, fs_extra_1.copyFile(from, to)];

    TsBundler.prototype.copyDir = function (from, to) {

                        console.log("cp -r " + from + " " + to);

                        return [4 /*yield*/, fs_extra_1.copy(from, to)];

    // Copies a compiled TypeScript package to the output directory.

    "description": "A simple bundler for TypeScript projects using TypeScript project references.",

        "build:watch": "tsc  --incremental --watch",

        "prepublishOnly": "npm run clean && npm run test && tsc",

        "lint": "tslint -c tslint.json 'src/**/*.{ts,tsx}'",

        "url": "git+https://ashleydavis@github.com/ashleydavis/ts-project-bundle.git"

    "author": "ashley@codecapers.com.au",

        "url": "https://github.com/ashleydavis/ts-project-bundle/issues"

    "homepage": "https://github.com/ashleydavis/ts-project-bundle#readme",

A simple bundler for TypeScript projects using [TypeScript project references](https://www.typescriptlang.org/docs/handbook/project-references.html).

This is a prototype! Please create an issue to give feedback.

Please see my other repo for some [examples of TypeScript projects that demonstrate project references](https://github.com/ashleydavis/sharing-typescript-code-libraries).

**! Sorry this is a prototype and there's no graceful error handling yet. Please make sure your inputs are sane :-)**

Open a terminal and navigate to your main TypeScript project:

Your main project must use [TypeScript project references](https://www.typescriptlang.org/docs/handbook/project-references.html) to specify how it depends on shared TypeScript libraries.

First compile your project and it's dependencies:

Note the use of the `--build` argument. This causes dependent projects to be built as well.

Now install `ts-project-bundle` into your main project as a dev dependency:

Now run `ts-project-bundle` against your main project:

`ts-project-bundle` automatically uses the current working directory as the main project. You can also specify the project directory with the `--project=<dir>` parameter.

`ts-project-bundle` automatically detects referenced TypeScript libraries and the root path that contains both the main project and all the referenced libraries. The root path is required because it is required to reconstitute the directories for the main project and the library projects in the bundle. You can override the automatic root directory using the `--root=<dir>` argument, use with care.

The main project directory and all library directories must be valid TypeScript projects and must each contains a `tsconfig.json` file.

`ts-project-bundle` automatically defaults the output directory for the bundle to `./out` under the project directory. You can set this specifically using the `--out=<dir>` argument.

Here's how you might want to run this for a monorepo that contains microservices.

    microservices/              # Each subdirectory contains a TypeScript microservice.

    libs/                       # Each subdirectory contains a shared TypeScript library.

Here's how we can bundle the code for `microserviceA`.

cd some/path/my-application/microservices/microserviceA

npx tsc --build     # Compiles the microservice and all references libraries.

ts-project-bundler  # Bundles combined code for microservice and libraries in the .out directory.

ts-project-bundle --root=../ --project=./ --out=../../out

		{
		"name": "ts-project-bundle",
		"version": "0.0.8",
		"version": "0.0.9",
		"description": "A simple bundler for TypeScript projects using TypeScript project references.",
		@@ -5,0 +5,0 @@ "main": "build/index.js",

Improved metrics

Worsened metrics

		@@ -55,9 +55,16 @@ "use strict";
		return __awaiter(this, void 0, void 0, function () {
		var _a, _b;
		var tsConfigFilePath, tsConfigExists, _a, _b;
		return __generator(this, function (_c) {
		switch (_c.label) {
		case 0:
		tsConfigFilePath = path.join(projectPath, "tsconfig.json");
		return [4 /yield/, fs_extra_1.pathExists(tsConfigFilePath)];
		case 1:
		tsConfigExists = _c.sent();
		if (!tsConfigExists) {
		throw new Error("Can't find tsconfig.json for project in " + projectPath + ", are sure this is a TypeScript project?");
		}
		_b = (_a = JSON5).parse;
		return [4 /yield/, fs_extra_1.readFile(path.join(projectPath, "tsconfig.json"), "utf8")];
		case 1: return [2 /return/, _b.apply(_a, [_c.sent()])];
		return [4 /yield/, fs_extra_1.readFile(tsConfigFilePath, "utf8")];
		case 2: return [2 /return/, _b.apply(_a, [_c.sent()])];
		}
		@@ -64,0 +71,0 @@ });

		@@ -11,4 +11,2 @@ # ts-project-bundle

		! Sorry this is a prototype and there's no graceful error handling yet. Please make sure your inputs are sane :-)

		Open a terminal and navigate to your main TypeScript project:
		@@ -15,0 +13,0 @@