@decohere/workspace 0.0.1-dev.116

package/README.md

@@ -0,0 +1,81 @@
+# @decohere/workspace
+
+Workspace and project model for Decohere tooling. Forge and Flux call it to find packages and derive import aliases. It is not a CLI — you do not run it; tools use it internally.
+
+## Workspace layout
+
+A **project** is a directory whose root contains a `package.json`. The workspace package discovers those files with `includeProjects` globs (cwd = the workspace root, usually `process.cwd()`).
+
+The workspace root may also have a `package.json`. That file is workspace metadata (name/version). It is **not** a project unless it also matches `includeProjects`.
+
+### Defaults
+
+| Option | Default |
+|---|---|
+| `includeProjects` | `projects/**/package.json` |
+| `ignoreProjects` | `**/node_modules/**`, `**/__fixtures__/**`, `**/dist/**` |
+| Source files | `**/*.ts` (not `**/*.d.ts`) |
+| Config file | `.decohere.js` if present; otherwise defaults |
+
+Nested `package.json` files under another discovered package are skipped (fixtures inside a project do not become projects).
+
+Default tree:
+
+```
+package.json                 # workspace (not a project)
+projects/api/package.json    # project
+projects/lib/package.json    # project
+```
+
+Packages do **not** have to live under `projects/` — that is only the default glob. Override `includeProjects` when the tree is different.
+
+### Optional `.decohere.js`
+
+If the file is missing, the workspace package uses the defaults above. Arrays in this file **replace** defaults (they are not concatenated).
+
+```js
+/** @type {import("@decohere/workspace").WorkspaceOptions} */
+export default {
+	includeProjects: ["apps/**/package.json", "packages/**/package.json"],
+};
+```
+
+Per-project settings go under `projects`, keyed by package name: `docker` (image, Dockerfile, tags, build args) and `ui` (the UI project a deployable ships, see [forge](../forge/README.md#shipping-the-ui-with-the-api)).
+
+`--config-file` on `forge` / `flux` selects a different config path. The default filename is still `.decohere.js`.
+
+### Package aliases
+
+For each discovered project, the workspace package maps `package.json` `name` to its source entry, and its subpaths to their sources (#518):
+
+- **The entry:** a TypeScript `main` as written (default `src/index.ts`). A `main` or `exports["."]` that describes the published layout (`index.js`, `./es6/src/index.js`) maps back to the source under `src/`.
+- **Each subpath in `exports`:** `./auth` → `./es6/src/auth/auth.extensions.js` becomes `src/auth/auth.extensions.ts`. Entries whose source doesn't exist are left out.
+- **Any other subpath (`name/*`):** `src/<sub>.ts` (or `.tsx`, `.mts` for `.mjs`, `.cts` for `.cjs`), else `src/<sub>/index.ts`. A package with only subpaths and no root entry resolves them under `src/`.
+
+Root `tsconfig.json` `paths` override the same keys. In this repo they come from `forge paths`, which writes this map to `tsconfig.paths.json` for `tsc`.
+
+Forge debug and Flux consume this map (SWC `jsc.paths` / resolve hooks). Why debug uses it instead of `node_modules` workspace links: [Forge — debug path aliases](../forge/README.md#debug-path-aliases-not-node_modules-links).
+
+## When to use
+
+| Use `@decohere/workspace` | Do not use it |
+|---|---|
+| Discover packages and watch their source | A user-facing “run this workspace” CLI (use Flux / Forge) |
+| Package-name aliases (`Workspace.getPackageAliases`) | pnpm/npm workspace protocol as the discovery source |
+| Shared project model for Forge + Flux | Browser bundler config (Vite / webpack) |
+
+## Programmatic API
+
+```ts
+import { WorkspaceFactory } from "@decohere/workspace";
+
+const workspace = await WorkspaceFactory.create({
+	configFile: undefined, // workspace defaults; or path to .decohere.js
+	rootDir: process.cwd(),
+});
+
+const projects = workspace.getProjects("debug");
+const aliases = workspace.getPackageAliases("debug");
+```
+
+Pass a pre-built `workspace` into Forge/Flux in tests to skip filesystem discovery.

package/commonjs/src/const.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get FIXTURES () {
+        return FIXTURES;
+    },
+    get NODE_MODULES () {
+        return NODE_MODULES;
+    },
+    get PACKAGE_JSON () {
+        return PACKAGE_JSON;
+    },
+    get PROJECTS_DIR () {
+        return PROJECTS_DIR;
+    },
+    get TS_CONFIG () {
+        return TS_CONFIG;
+    },
+    get WORKSPACE_CONFIG () {
+        return WORKSPACE_CONFIG;
+    },
+    get WorkspaceDefaults () {
+        return WorkspaceDefaults;
+    }
+});
+const TS_CONFIG = "tsconfig.json";
+const PACKAGE_JSON = "package.json";
+const NODE_MODULES = "node_modules";
+const FIXTURES = "__fixtures__";
+const WORKSPACE_CONFIG = ".decohere.js";
+const PROJECTS_DIR = "projects";
+const WorkspaceDefaults = {
+    rootDir: "./",
+    outDir: "dist",
+    includeProjects: [
+        `${PROJECTS_DIR}/**/${PACKAGE_JSON}`
+    ],
+    ignoreProjects: [
+        `**/${NODE_MODULES}/**`,
+        `**/${FIXTURES}/**`,
+        "**/dist/**"
+    ],
+    include: [
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.mts",
+        "**/*.cts"
+    ],
+    ignore: [
+        "**/*.d.ts",
+        "**/*.d.mts",
+        "**/*.d.cts",
+        `**/${NODE_MODULES}/**`
+    ],
+    copyFiles: [],
+    configurations: [
+        {
+            name: "debug"
+        }
+    ]
+};

package/commonjs/src/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WorkspaceConfigurationError", {
+    enumerable: true,
+    get: function() {
+        return WorkspaceConfigurationError;
+    }
+});
+class WorkspaceConfigurationError extends Error {
+}

package/commonjs/src/factories/config.factory.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UserConfigFactory", {
+    enumerable: true,
+    get: function() {
+        return UserConfigFactory;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodeurl = require("node:url");
+const _caching = require("@decohere/core/caching");
+const _io = require("@decohere/core/io");
+const _const = require("../const.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class ConfigFactory {
+    async getUserConfig(configFile) {
+        const file = configFile ?? _const.WORKSPACE_CONFIG;
+        if (!file || !await _io.io.fileExists(file)) {
+            return {};
+        }
+        const fileUrl = (0, _nodeurl.pathToFileURL)(_nodepath.default.resolve(file)).href;
+        const conf = (await Promise.resolve(fileUrl).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)))).default;
+        return conf;
+    }
+}
+_ts_decorate([
+    (0, _caching.cache)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ConfigFactory.prototype, "getUserConfig", null);
+const UserConfigFactory = new ConfigFactory();

package/commonjs/src/factories/find-workspace-root.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findWorkspaceRoot", {
+    enumerable: true,
+    get: function() {
+        return findWorkspaceRoot;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _const = require("../const.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function findWorkspaceRoot(startDir) {
+    const start = _nodepath.default.resolve(startDir);
+    let dir = start;
+    for(;;){
+        if ((0, _nodefs.existsSync)(_nodepath.default.join(dir, _const.PACKAGE_JSON)) && isDirectory(_nodepath.default.join(dir, _const.PROJECTS_DIR))) {
+            return dir;
+        }
+        const parent = _nodepath.default.dirname(dir);
+        if (parent === dir) return start;
+        dir = parent;
+    }
+}
+function isDirectory(fullPath) {
+    try {
+        return (0, _nodefs.statSync)(fullPath).isDirectory();
+    } catch  {
+        return false;
+    }
+}

package/commonjs/src/factories/project.factory.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProjectFactory", {
+    enumerable: true,
+    get: function() {
+        return ProjectFactory;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _io = require("@decohere/core/io");
+const _objects = require("@decohere/core/objects");
+const _errors = require("../errors.js");
+const _packagejsonmodel = require("../models/package-json.model.js");
+const _projectmodel = require("../models/project.model.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ProjectFactory {
+    static async getProjectSeeds(config) {
+        const { includeProjects, ignoreProjects, rootDir } = config;
+        const cwd = rootDir ?? "./";
+        const discoveredPackageJsonFiles = await _io.io.findFiles(includeProjects, {
+            cwd,
+            ignore: ignoreProjects
+        });
+        const packageJsonFiles = ProjectFactory.filterNestedPackageJsonFiles(discoveredPackageJsonFiles);
+        const projects = await Promise.all(packageJsonFiles.map((file)=>ProjectFactory.projectFrom(file, config)));
+        return projects.sort((a, b)=>a.name.localeCompare(b.name));
+    }
+    static filterNestedPackageJsonFiles(files) {
+        const normalize = (filePath)=>filePath.replaceAll("\\", "/");
+        const packageJsonSet = new Set(files.map((file)=>normalize(file.relativePath)));
+        return files.filter((file)=>{
+            const relativePath = normalize(file.relativePath);
+            const projectDir = _nodepath.default.posix.dirname(relativePath);
+            let dir = _nodepath.default.posix.dirname(projectDir);
+            while(dir !== "." && dir !== "/"){
+                if (packageJsonSet.has(`${dir}/package.json`)) {
+                    return false;
+                }
+                dir = _nodepath.default.posix.dirname(dir);
+            }
+            return true;
+        });
+    }
+    static async getProjects(config, configuration) {
+        const seeds = await ProjectFactory.getProjectSeeds(config);
+        return seeds.map((seed)=>new _projectmodel.Project(seed.name, seed.config, configuration));
+    }
+    static async projectFrom(file, config) {
+        const packageJsonData = await _io.io.readJsonFile(file.fullPath).catch((error)=>{
+            throw new _errors.WorkspaceConfigurationError(`Error reading package.json ${file.fullPath}`, error);
+        });
+        const name = packageJsonData.name;
+        const packageJson = new _packagejsonmodel.PackageJson(packageJsonData);
+        const projectDir = _nodepath.default.dirname(file.relativePath);
+        const mergedConfig = _objects.merge.withOptions({
+            mergeArrays: false
+        }, config, config?.projects?.[name] ?? {}, {
+            projectDir,
+            packageJson
+        });
+        return {
+            name,
+            config: mergedConfig
+        };
+    }
+}

package/commonjs/src/factories/workspace.factory.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WorkspaceFactory", {
+    enumerable: true,
+    get: function() {
+        return WorkspaceFactory;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _io = require("@decohere/core/io");
+const _objects = require("@decohere/core/objects");
+const _const = require("../const.js");
+const _packagejsonmodel = require("../models/package-json.model.js");
+const _workspacemodel = require("../models/workspace.model.js");
+const _configfactory = require("./config.factory.js");
+const _projectfactory = require("./project.factory.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class Factory {
+    async create(options = {}) {
+        const config = await this.getMergedConfig(options);
+        const projectSeeds = await _projectfactory.ProjectFactory.getProjectSeeds(config);
+        const packageJson = await this.getPackageJson(config.rootDir ?? "./");
+        const workspace = new _workspacemodel.Workspace({
+            packageJson,
+            config,
+            projects: projectSeeds
+        });
+        return workspace;
+    }
+    async getMergedConfig(options) {
+        const { configFile, ...rest } = options;
+        const userConfig = await _configfactory.UserConfigFactory.getUserConfig(configFile);
+        return _objects.merge.withOptions({
+            mergeArrays: false
+        }, _const.WorkspaceDefaults, userConfig, rest);
+    }
+    async getPackageJson(rootDir) {
+        const packageJsonPath = _nodepath.default.join(rootDir, _const.PACKAGE_JSON);
+        if (!await _io.io.fileExists(packageJsonPath)) return;
+        const data = await _io.io.readJsonFile(packageJsonPath);
+        return new _packagejsonmodel.PackageJson(data);
+    }
+}
+const WorkspaceFactory = new Factory();

package/commonjs/src/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_COMPILER_OPTIONS () {
+        return _tsconfigmodel.DEFAULT_COMPILER_OPTIONS;
+    },
+    get HasPackageJson () {
+        return _haspackagejsonmixin.HasPackageJson;
+    },
+    get HasTsConfig () {
+        return _hastsconfigmixin.HasTsConfig;
+    },
+    get PackageJson () {
+        return _packagejsonmodel.PackageJson;
+    },
+    get Project () {
+        return _projectmodel.Project;
+    },
+    get ProjectFactory () {
+        return _projectfactory.ProjectFactory;
+    },
+    get Tsconfig () {
+        return _tsconfigmodel.Tsconfig;
+    },
+    get UserConfigFactory () {
+        return _configfactory.UserConfigFactory;
+    },
+    get WORKSPACE_CONFIG () {
+        return _const.WORKSPACE_CONFIG;
+    },
+    get Workspace () {
+        return _workspacemodel.Workspace;
+    },
+    get WorkspaceConfigurationError () {
+        return _errors.WorkspaceConfigurationError;
+    },
+    get WorkspaceDefaults () {
+        return _const.WorkspaceDefaults;
+    },
+    get WorkspaceFactory () {
+        return _workspacefactory.WorkspaceFactory;
+    },
+    get findWorkspaceRoot () {
+        return _findworkspaceroot.findWorkspaceRoot;
+    },
+    get packageAliases () {
+        return _packagealiases.packageAliases;
+    },
+    get sourceExtensions () {
+        return _sourceextensions.sourceExtensions;
+    }
+});
+const _const = require("./const.js");
+const _errors = require("./errors.js");
+const _configfactory = require("./factories/config.factory.js");
+const _findworkspaceroot = require("./factories/find-workspace-root.js");
+const _projectfactory = require("./factories/project.factory.js");
+const _workspacefactory = require("./factories/workspace.factory.js");
+const _haspackagejsonmixin = require("./models/has-package-json.mixin.js");
+const _hastsconfigmixin = require("./models/has-tsconfig.mixin.js");
+const _packagealiases = require("./models/package-aliases.js");
+const _packagejsonmodel = require("./models/package-json.model.js");
+const _projectmodel = require("./models/project.model.js");
+const _sourceextensions = require("./models/source-extensions.js");
+const _tsconfigmodel = require("./models/tsconfig.model.js");
+const _workspacemodel = require("./models/workspace.model.js");

package/commonjs/src/models/has-package-json.mixin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HasPackageJson", {
+    enumerable: true,
+    get: function() {
+        return HasPackageJson;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _caching = require("@decohere/core/caching");
+const _io = require("@decohere/core/io");
+const _const = require("../const.js");
+const _packagejsonmodel = require("./package-json.model.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class HasPackageJson {
+    async getPackageJson() {
+        return new _packagejsonmodel.PackageJson(await _io.io.readJsonFile(_nodepath.default.join(this.packageJsonDirectory, _const.PACKAGE_JSON)));
+    }
+    get packageJsonPath() {
+        return _nodepath.default.join(this.packageJsonDirectory, _const.PACKAGE_JSON);
+    }
+    async getVersion() {
+        return (await this.getPackageJson()).version;
+    }
+    async persistPackageJson(packageJson) {
+        await _io.io.writeFile(this.packageJsonPath, packageJson.toJSON());
+        _caching.invalidateMemoize.evict(this, HasPackageJson.prototype.getPackageJson);
+    }
+}
+_ts_decorate([
+    (0, _caching.memoize)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], HasPackageJson.prototype, "getPackageJson", null);

package/commonjs/src/models/has-tsconfig.mixin.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HasTsConfig", {
+    enumerable: true,
+    get: function() {
+        return HasTsConfig;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _caching = require("@decohere/core/caching");
+const _io = require("@decohere/core/io");
+const _const = require("../const.js");
+const _tsconfigmodel = require("./tsconfig.model.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class HasTsConfig {
+    async getTsConfig() {
+        for (const configPath of this.tsConfigPaths){
+            if (await _io.io.fileExists(configPath)) return _tsconfigmodel.Tsconfig.parse(configPath);
+        }
+        return _tsconfigmodel.Tsconfig.default();
+    }
+    getTsConfigSync() {
+        const configPath = this.findTsConfigPath();
+        if (configPath != null) return _tsconfigmodel.Tsconfig.parseSync(configPath);
+        return _tsconfigmodel.Tsconfig.default();
+    }
+    /** First existing `tsconfig.json` on this object, if any. */ findTsConfigPath() {
+        return this.tsConfigPaths.find((configPath)=>HasTsConfig.fileExistsSync(configPath));
+    }
+    get tsConfigPaths() {
+        const paths = [
+            _nodepath.default.join(this.tsConfigDirectory, _const.TS_CONFIG)
+        ];
+        const fallback = this.fallbackTsConfigDirectory;
+        if (fallback != null) {
+            paths.push(_nodepath.default.join(fallback, _const.TS_CONFIG));
+        }
+        return paths;
+    }
+    static fileExistsSync(filePath) {
+        try {
+            return _nodefs.default.statSync(filePath).isFile();
+        } catch  {
+            return false;
+        }
+    }
+}
+_ts_decorate([
+    (0, _caching.memoize)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], HasTsConfig.prototype, "getTsConfig", null);
+_ts_decorate([
+    (0, _caching.memoize)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], HasTsConfig.prototype, "getTsConfigSync", null);