@decohere/workspace 0.0.1-dev.116

package/commonjs/src/models/source-extensions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sourceExtensions", {
+    enumerable: true,
+    get: function() {
+        return sourceExtensions;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** TypeScript source extensions a workspace compiles (#518). */ const SOURCE = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts"
+];
+/** The sources an import's extension can name: `./a.js` is `a.ts` or `a.tsx`, `./a.mjs` is `a.mts`. */ const SOURCES_FOR = {
+    ".js": [
+        ".ts",
+        ".tsx"
+    ],
+    ".jsx": [
+        ".tsx"
+    ],
+    ".mjs": [
+        ".mts"
+    ],
+    ".cjs": [
+        ".cts"
+    ],
+    "": [
+        ".ts",
+        ".tsx"
+    ]
+};
+/** Whether a path is a TypeScript source (not a declaration file). */ function isSource(file) {
+    return SOURCE.some((ext)=>file.endsWith(ext)) && !/\.d\.[mc]?ts$/.test(file);
+}
+/**
+ * The source files a path written in an import (or a built path) could name, most likely first:
+ * itself when it is already a source, else the same stem with each matching source extension.
+ */ function candidates(file) {
+    if (isSource(file)) return [
+        file
+    ];
+    const ext = _nodepath.default.extname(file);
+    const known = SOURCES_FOR[ext];
+    if (known == null) return [
+        `${file}.ts`,
+        `${file}.tsx`
+    ];
+    const stem = ext === "" ? file : file.slice(0, -ext.length);
+    return known.map((sourceExt)=>`${stem}${sourceExt}`);
+}
+/** The extension a source builds to: `.mts` to `.mjs`, `.cts` to `.cjs`, the rest to `.js`. */ function outputExtension(file) {
+    if (file.endsWith(".mts")) return ".mjs";
+    if (file.endsWith(".cts")) return ".cjs";
+    return ".js";
+}
+/** The path a source builds to: `a.mts` to `a.mjs`, `a.cts` to `a.cjs`, `a.ts` and `a.tsx` to `a.js`. */ function outputPath(file) {
+    const ext = _nodepath.default.extname(file);
+    const stem = ext === "" ? file : file.slice(0, -ext.length);
+    return `${stem}${outputExtension(file)}`;
+}
+/** Whether a source is CommonJS (`.cts`); everything else compiles as an ES module. */ function isCommonJs(file) {
+    return file.endsWith(".cts");
+}
+const sourceExtensions = {
+    SOURCE,
+    isSource,
+    candidates,
+    outputExtension,
+    outputPath,
+    isCommonJs
+};

package/commonjs/src/models/tsconfig.model.js

@@ -0,0 +1,97 @@
+"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 DEFAULT_COMPILER_OPTIONS;
+    },
+    get Tsconfig () {
+        return Tsconfig;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _io = require("@decohere/core/io");
+const _typescript = /*#__PURE__*/ _interop_require_default(require("typescript"));
+const _errors = require("../errors.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const host = _typescript.default.sys;
+host.readFile = (file)=>{
+    return _nodefs.default.readFileSync(file, {
+        encoding: "utf8"
+    });
+};
+host.readDirectory = (directoryName)=>{
+    return _nodefs.default.readdirSync(directoryName, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+};
+const DEFAULT_COMPILER_OPTIONS = {
+    emitDeclarationOnly: true,
+    declaration: true,
+    baseUrl: "./"
+};
+class Tsconfig {
+    static default() {
+        return new Tsconfig();
+    }
+    static async parse(filePath) {
+        if (!await _io.io.fileExists(filePath)) {
+            throw new _errors.WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+        }
+        const configFileText = await _io.io.readFile(filePath);
+        const result = _typescript.default.parseConfigFileTextToJson(filePath, configFileText);
+        if (result.error) {
+            const errorMessage = result.error.messageText.toString();
+            throw new _errors.WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+        }
+        const dirName = _nodepath.default.resolve(_nodepath.default.dirname(filePath));
+        const configParseResult = _typescript.default.parseJsonConfigFileContent(result.config, host, dirName);
+        return new Tsconfig({
+            compilerOptions: configParseResult.options,
+            errors: configParseResult.errors
+        });
+    }
+    static parseSync(filePath) {
+        if (!Tsconfig.fileExistsSync(filePath)) {
+            throw new _errors.WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+        }
+        const configFileText = _nodefs.default.readFileSync(filePath, "utf8");
+        const result = _typescript.default.parseConfigFileTextToJson(filePath, configFileText);
+        if (result.error) {
+            const errorMessage = result.error.messageText.toString();
+            throw new _errors.WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+        }
+        const dirName = _nodepath.default.resolve(_nodepath.default.dirname(filePath));
+        const configParseResult = _typescript.default.parseJsonConfigFileContent(result.config, host, dirName);
+        return new Tsconfig({
+            compilerOptions: configParseResult.options,
+            errors: configParseResult.errors
+        });
+    }
+    static fileExistsSync(filePath) {
+        try {
+            return _nodefs.default.statSync(filePath).isFile();
+        } catch  {
+            return false;
+        }
+    }
+    constructor(data = {
+        compilerOptions: DEFAULT_COMPILER_OPTIONS
+    }){
+        Object.assign(this, data);
+    }
+    compilerOptions;
+    errors;
+}

package/commonjs/src/models/workspace-config.type.js

@@ -0,0 +1,7 @@
+/**
+ * Generic configuration for a workspace build profile.
+ * Concrete tools (e.g. @decohere/forge) extend this with tool-specific fields.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/commonjs/src/models/workspace.model.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Workspace", {
+    enumerable: true,
+    get: function() {
+        return Workspace;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _collections = require("@decohere/core/collections");
+const _extensibility = require("@decohere/core/extensibility");
+const _rxjs = require("rxjs");
+const _errors = require("../errors.js");
+const _haspackagejsonmixin = require("./has-package-json.mixin.js");
+const _hastsconfigmixin = require("./has-tsconfig.mixin.js");
+const _packagealiases = require("./package-aliases.js");
+const _packagejsonmodel = require("./package-json.model.js");
+const _projectmodel = require("./project.model.js");
+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 Workspace extends (0, _extensibility.mixwith)(_haspackagejsonmixin.HasPackageJson, _hastsconfigmixin.HasTsConfig) {
+    packageJson;
+    #name;
+    #config;
+    #projectSeeds = [];
+    #projectCache = new Map();
+    /**
+	 * Each project's source file paths as a set, so `findProject` is a lookup rather than a scan
+	 * of every file: the Vitest plugin asks once per transformed file (#517). Keyed by the list
+	 * `getAllFiles` returns, so a new list (after its cache is flushed) gets a new set.
+	 */ #sourcePaths = new WeakMap();
+    #projectFileChangedSubject = new _rxjs.Subject();
+    #projectWatchSubscriptions = new Map();
+    #watchedProjects = [];
+    constructor(options = {}){
+        super();
+        const { packageJson, config, projects } = options;
+        this.#name = packageJson?.name ?? "WORKSPACE";
+        this.packageJson = packageJson ?? new _packagejsonmodel.PackageJson();
+        this.#config = config ?? {};
+        this.#projectSeeds = projects ?? [];
+        this.validateWorkspace();
+    }
+    get name() {
+        return this.#name;
+    }
+    get projectSeeds() {
+        return this.#projectSeeds;
+    }
+    getProjects(configuration) {
+        const cached = this.#projectCache.get(configuration);
+        if (cached != null) {
+            return cached;
+        }
+        const projects = this.#projectSeeds.map((seed)=>new _projectmodel.Project(seed.name, seed.config ?? {}, configuration));
+        this.#projectCache.set(configuration, projects);
+        return projects;
+    }
+    get rootDir() {
+        return this.#config.rootDir ?? "./";
+    }
+    get packageJsonDirectory() {
+        return this.rootDir;
+    }
+    get tsConfigDirectory() {
+        return this.rootDir;
+    }
+    get fallbackTsConfigDirectory() {
+        return undefined;
+    }
+    /**
+	 * Package-name aliases for this configuration: workspace convention, then
+	 * workspace `tsconfig.json` `paths` overrides. Forge and Flux must use this
+	 * instead of assembling the map themselves.
+	 */ getPackageAliases(configuration) {
+        const tsconfig = this.findTsConfigPath() != null ? this.getTsConfigSync() : undefined;
+        const baseUrl = typeof tsconfig?.compilerOptions?.baseUrl === "string" && tsconfig.compilerOptions.baseUrl.length > 0 ? tsconfig.compilerOptions.baseUrl : this.rootDir;
+        return _packagealiases.packageAliases.build(this.getProjects(configuration), {
+            baseUrl,
+            tsconfigPaths: tsconfig?.compilerOptions?.paths
+        });
+    }
+    async watch(configuration) {
+        this.stopWatching();
+        const projects = this.getProjects(configuration);
+        this.#watchedProjects = projects;
+        for (const project of projects){
+            await project.watch(configuration);
+            const subscription = project.projectFileChanged$.subscribe((evt)=>this.#projectFileChangedSubject.next(evt));
+            this.#projectWatchSubscriptions.set(project.projectDirectory, subscription);
+        }
+    }
+    stopWatching() {
+        for (const subscription of this.#projectWatchSubscriptions.values()){
+            subscription.unsubscribe();
+        }
+        for (const project of this.#watchedProjects){
+            project.stopWatching();
+        }
+        this.#watchedProjects = [];
+        this.#projectWatchSubscriptions.clear();
+    }
+    [Symbol.dispose]() {
+        this.stopWatching();
+    }
+    get projectFileChanged$() {
+        return this.#projectFileChangedSubject.asObservable();
+    }
+    async findProject(filePath, buildConfig) {
+        for (const project of this.getProjects(buildConfig)){
+            if ((await this.sourcePathsOf(project)).has(filePath)) {
+                return project;
+            }
+        }
+        return undefined;
+    }
+    async sourcePathsOf(project) {
+        const files = await project.getAllFiles();
+        const cached = this.#sourcePaths.get(files);
+        if (cached != null) return cached;
+        const paths = new Set(files.map((file)=>file.fullPath));
+        this.#sourcePaths.set(files, paths);
+        return paths;
+    }
+    validateWorkspace() {
+        const errors = this.findDuplicateProjectSeeds(this.#projectSeeds);
+        if (errors.length > 0) {
+            throw new _errors.WorkspaceConfigurationError(errors.join("\n"));
+        }
+    }
+    findDuplicateProjectSeeds(seeds) {
+        const duplicates = _collections.collections.findDuplicatesByKey([
+            ...seeds
+        ], "name");
+        return duplicates.map(([name, group])=>`Duplicate project name "${name}" found at: ${group.map((seed)=>seed.config?.projectDir ?? name).join(", ")}`);
+    }
+}
+Workspace = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Partial === "undefined" ? Object : Partial
+    ])
+], Workspace);

package/es6/src/const.js

@@ -0,0 +1,36 @@
+export const TS_CONFIG = "tsconfig.json";
+export const PACKAGE_JSON = "package.json";
+export const NODE_MODULES = "node_modules";
+export const FIXTURES = "__fixtures__";
+export const WORKSPACE_CONFIG = ".decohere.js";
+export const PROJECTS_DIR = "projects";
+export 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/es6/src/errors.js

@@ -0,0 +1,2 @@
+export class WorkspaceConfigurationError extends Error {
+}

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

@@ -0,0 +1,34 @@
+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);
+}
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { cache } from "@decohere/core/caching";
+import { io } from "@decohere/core/io";
+import { WORKSPACE_CONFIG } from "../const.js";
+class ConfigFactory {
+    async getUserConfig(configFile) {
+        const file = configFile ?? WORKSPACE_CONFIG;
+        if (!file || !await io.fileExists(file)) {
+            return {};
+        }
+        const fileUrl = pathToFileURL(path.resolve(file)).href;
+        const conf = (await import(fileUrl)).default;
+        return conf;
+    }
+}
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ConfigFactory.prototype, "getUserConfig", null);
+export const UserConfigFactory = new ConfigFactory();

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

@@ -0,0 +1,26 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { PACKAGE_JSON, PROJECTS_DIR } from "../const.js";
+/**
+ * The workspace root for a command run from `startDir`: the nearest directory at or above
+ * it with a `package.json` and a `projects/` folder. Falls back to `startDir`, so running
+ * from a package directory (`projects/api`) still sees the whole workspace.
+ */ export function findWorkspaceRoot(startDir) {
+    const start = path.resolve(startDir);
+    let dir = start;
+    for(;;){
+        if (existsSync(path.join(dir, PACKAGE_JSON)) && isDirectory(path.join(dir, PROJECTS_DIR))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) return start;
+        dir = parent;
+    }
+}
+function isDirectory(fullPath) {
+    try {
+        return statSync(fullPath).isDirectory();
+    } catch  {
+        return false;
+    }
+}

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

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { io } from "@decohere/core/io";
+import { merge } from "@decohere/core/objects";
+import { WorkspaceConfigurationError } from "../errors.js";
+import { PackageJson } from "../models/package-json.model.js";
+import { Project } from "../models/project.model.js";
+export class ProjectFactory {
+    static async getProjectSeeds(config) {
+        const { includeProjects, ignoreProjects, rootDir } = config;
+        const cwd = rootDir ?? "./";
+        const discoveredPackageJsonFiles = await 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 = path.posix.dirname(relativePath);
+            let dir = path.posix.dirname(projectDir);
+            while(dir !== "." && dir !== "/"){
+                if (packageJsonSet.has(`${dir}/package.json`)) {
+                    return false;
+                }
+                dir = path.posix.dirname(dir);
+            }
+            return true;
+        });
+    }
+    static async getProjects(config, configuration) {
+        const seeds = await ProjectFactory.getProjectSeeds(config);
+        return seeds.map((seed)=>new Project(seed.name, seed.config, configuration));
+    }
+    static async projectFrom(file, config) {
+        const packageJsonData = await io.readJsonFile(file.fullPath).catch((error)=>{
+            throw new WorkspaceConfigurationError(`Error reading package.json ${file.fullPath}`, error);
+        });
+        const name = packageJsonData.name;
+        const packageJson = new PackageJson(packageJsonData);
+        const projectDir = path.dirname(file.relativePath);
+        const mergedConfig = merge.withOptions({
+            mergeArrays: false
+        }, config, config?.projects?.[name] ?? {}, {
+            projectDir,
+            packageJson
+        });
+        return {
+            name,
+            config: mergedConfig
+        };
+    }
+}

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

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { io } from "@decohere/core/io";
+import { merge } from "@decohere/core/objects";
+import { PACKAGE_JSON, WorkspaceDefaults } from "../const.js";
+import { PackageJson } from "../models/package-json.model.js";
+import { Workspace } from "../models/workspace.model.js";
+import { UserConfigFactory } from "./config.factory.js";
+import { ProjectFactory } from "./project.factory.js";
+class Factory {
+    async create(options = {}) {
+        const config = await this.getMergedConfig(options);
+        const projectSeeds = await ProjectFactory.getProjectSeeds(config);
+        const packageJson = await this.getPackageJson(config.rootDir ?? "./");
+        const workspace = new Workspace({
+            packageJson,
+            config,
+            projects: projectSeeds
+        });
+        return workspace;
+    }
+    async getMergedConfig(options) {
+        const { configFile, ...rest } = options;
+        const userConfig = await UserConfigFactory.getUserConfig(configFile);
+        return merge.withOptions({
+            mergeArrays: false
+        }, WorkspaceDefaults, userConfig, rest);
+    }
+    async getPackageJson(rootDir) {
+        const packageJsonPath = path.join(rootDir, PACKAGE_JSON);
+        if (!await io.fileExists(packageJsonPath)) return;
+        const data = await io.readJsonFile(packageJsonPath);
+        return new PackageJson(data);
+    }
+}
+export const WorkspaceFactory = new Factory();

package/es6/src/index.js

@@ -0,0 +1,14 @@
+export { WORKSPACE_CONFIG, WorkspaceDefaults } from "./const.js";
+export { WorkspaceConfigurationError } from "./errors.js";
+export { UserConfigFactory } from "./factories/config.factory.js";
+export { findWorkspaceRoot } from "./factories/find-workspace-root.js";
+export { ProjectFactory } from "./factories/project.factory.js";
+export { WorkspaceFactory } from "./factories/workspace.factory.js";
+export { HasPackageJson } from "./models/has-package-json.mixin.js";
+export { HasTsConfig } from "./models/has-tsconfig.mixin.js";
+export { packageAliases } from "./models/package-aliases.js";
+export { PackageJson } from "./models/package-json.model.js";
+export { Project } from "./models/project.model.js";
+export { sourceExtensions } from "./models/source-extensions.js";
+export { DEFAULT_COMPILER_OPTIONS, Tsconfig } from "./models/tsconfig.model.js";
+export { Workspace } from "./models/workspace.model.js";

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

@@ -0,0 +1,35 @@
+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);
+}
+import path from "node:path";
+import { invalidateMemoize, memoize } from "@decohere/core/caching";
+import { io } from "@decohere/core/io";
+import { PACKAGE_JSON } from "../const.js";
+import { PackageJson } from "./package-json.model.js";
+export class HasPackageJson {
+    async getPackageJson() {
+        return new PackageJson(await io.readJsonFile(path.join(this.packageJsonDirectory, PACKAGE_JSON)));
+    }
+    get packageJsonPath() {
+        return path.join(this.packageJsonDirectory, PACKAGE_JSON);
+    }
+    async getVersion() {
+        return (await this.getPackageJson()).version;
+    }
+    async persistPackageJson(packageJson) {
+        await io.writeFile(this.packageJsonPath, packageJson.toJSON());
+        invalidateMemoize.evict(this, HasPackageJson.prototype.getPackageJson);
+    }
+}
+_ts_decorate([
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], HasPackageJson.prototype, "getPackageJson", null);

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

@@ -0,0 +1,60 @@
+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);
+}
+import fs from "node:fs";
+import path from "node:path";
+import { memoize } from "@decohere/core/caching";
+import { io } from "@decohere/core/io";
+import { TS_CONFIG } from "../const.js";
+import { Tsconfig } from "./tsconfig.model.js";
+export class HasTsConfig {
+    async getTsConfig() {
+        for (const configPath of this.tsConfigPaths){
+            if (await io.fileExists(configPath)) return Tsconfig.parse(configPath);
+        }
+        return Tsconfig.default();
+    }
+    getTsConfigSync() {
+        const configPath = this.findTsConfigPath();
+        if (configPath != null) return Tsconfig.parseSync(configPath);
+        return Tsconfig.default();
+    }
+    /** First existing `tsconfig.json` on this object, if any. */ findTsConfigPath() {
+        return this.tsConfigPaths.find((configPath)=>HasTsConfig.fileExistsSync(configPath));
+    }
+    get tsConfigPaths() {
+        const paths = [
+            path.join(this.tsConfigDirectory, TS_CONFIG)
+        ];
+        const fallback = this.fallbackTsConfigDirectory;
+        if (fallback != null) {
+            paths.push(path.join(fallback, TS_CONFIG));
+        }
+        return paths;
+    }
+    static fileExistsSync(filePath) {
+        try {
+            return fs.statSync(filePath).isFile();
+        } catch  {
+            return false;
+        }
+    }
+}
+_ts_decorate([
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], HasTsConfig.prototype, "getTsConfig", null);
+_ts_decorate([
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], HasTsConfig.prototype, "getTsConfigSync", null);