@decohere/workspace 0.0.1-dev.116

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

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { io } from "@decohere/core/io";
+import ts from "typescript";
+import { WorkspaceConfigurationError } from "../errors.js";
+const host = ts.sys;
+host.readFile = (file)=>{
+    return fs.readFileSync(file, {
+        encoding: "utf8"
+    });
+};
+host.readDirectory = (directoryName)=>{
+    return fs.readdirSync(directoryName, {
+        withFileTypes: true
+    }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+};
+export const DEFAULT_COMPILER_OPTIONS = {
+    emitDeclarationOnly: true,
+    declaration: true,
+    baseUrl: "./"
+};
+export class Tsconfig {
+    static default() {
+        return new Tsconfig();
+    }
+    static async parse(filePath) {
+        if (!await io.fileExists(filePath)) {
+            throw new WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+        }
+        const configFileText = await io.readFile(filePath);
+        const result = ts.parseConfigFileTextToJson(filePath, configFileText);
+        if (result.error) {
+            const errorMessage = result.error.messageText.toString();
+            throw new WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+        }
+        const dirName = path.resolve(path.dirname(filePath));
+        const configParseResult = ts.parseJsonConfigFileContent(result.config, host, dirName);
+        return new Tsconfig({
+            compilerOptions: configParseResult.options,
+            errors: configParseResult.errors
+        });
+    }
+    static parseSync(filePath) {
+        if (!Tsconfig.fileExistsSync(filePath)) {
+            throw new WorkspaceConfigurationError(`TSConfig not found ${filePath}`);
+        }
+        const configFileText = fs.readFileSync(filePath, "utf8");
+        const result = ts.parseConfigFileTextToJson(filePath, configFileText);
+        if (result.error) {
+            const errorMessage = result.error.messageText.toString();
+            throw new WorkspaceConfigurationError(`Error parsing ${filePath}. ${errorMessage}`);
+        }
+        const dirName = path.resolve(path.dirname(filePath));
+        const configParseResult = ts.parseJsonConfigFileContent(result.config, host, dirName);
+        return new Tsconfig({
+            compilerOptions: configParseResult.options,
+            errors: configParseResult.errors
+        });
+    }
+    static fileExistsSync(filePath) {
+        try {
+            return fs.statSync(filePath).isFile();
+        } catch  {
+            return false;
+        }
+    }
+    constructor(data = {
+        compilerOptions: DEFAULT_COMPILER_OPTIONS
+    }){
+        Object.assign(this, data);
+    }
+    compilerOptions;
+    errors;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Generic configuration for a workspace build profile.
+ * Concrete tools (e.g. @decohere/forge) extend this with tool-specific fields.
+ */ export { };

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

@@ -0,0 +1,143 @@
+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 { injectable } from "@decohere/crucible/decorators";
+import { collections } from "@decohere/core/collections";
+import { mixwith } from "@decohere/core/extensibility";
+import { Subject } from "rxjs";
+import { WorkspaceConfigurationError } from "../errors.js";
+import { HasPackageJson } from "./has-package-json.mixin.js";
+import { HasTsConfig } from "./has-tsconfig.mixin.js";
+import { packageAliases } from "./package-aliases.js";
+import { PackageJson } from "./package-json.model.js";
+import { Project } from "./project.model.js";
+export class Workspace extends mixwith(HasPackageJson, 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 Subject();
+    #projectWatchSubscriptions = new Map();
+    #watchedProjects = [];
+    constructor(options = {}){
+        super();
+        const { packageJson, config, projects } = options;
+        this.#name = packageJson?.name ?? "WORKSPACE";
+        this.packageJson = packageJson ?? new 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 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.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 WorkspaceConfigurationError(errors.join("\n"));
+        }
+    }
+    findDuplicateProjectSeeds(seeds) {
+        const duplicates = 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([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Partial === "undefined" ? Object : Partial
+    ])
+], Workspace);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@decohere/workspace",
+  "version": "0.0.1-dev.116",
+  "description": "Workspace and project model primitives for monorepo tooling",
+  "keywords": [
+    "typescript",
+    "monorepo",
+    "workspace",
+    "project-model",
+    "tsconfig",
+    "decohere"
+  ],
+  "license": "ISC",
+  "author": "Typesmiths",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/src/index.d.ts",
+      "import": "./es6/src/index.js",
+      "require": "./commonjs/src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@decohere/core": "0.0.1-dev.116",
+    "@decohere/crucible": "0.0.1-dev.116",
+    "picomatch": "^4.0.4",
+    "rxjs": "^7.8.2",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {}
+}

package/types/src/const.d.ts

@@ -0,0 +1,8 @@
+export declare const TS_CONFIG = "tsconfig.json";
+export declare const PACKAGE_JSON = "package.json";
+export declare const NODE_MODULES = "node_modules";
+export declare const FIXTURES = "__fixtures__";
+export declare const WORKSPACE_CONFIG = ".decohere.js";
+export declare const PROJECTS_DIR = "projects";
+import type { WorkspaceOptions } from "./models/workspace-config.type.js";
+export declare const WorkspaceDefaults: WorkspaceOptions;

package/types/src/errors.d.ts

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

package/types/src/factories/config.factory.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspaceOptions } from "../models/workspace-config.type.js";
+declare class ConfigFactory {
+    getUserConfig(configFile?: string): Promise<Partial<WorkspaceOptions>>;
+}
+export declare const UserConfigFactory: ConfigFactory;
+export {};

package/types/src/factories/find-workspace-root.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 declare function findWorkspaceRoot(startDir: string): string;

package/types/src/factories/project.factory.d.ts

@@ -0,0 +1,8 @@
+import { Project, type ProjectSeed } from "../models/project.model.js";
+import type { WorkspaceOptions } from "../models/workspace-config.type.js";
+export declare class ProjectFactory {
+    static getProjectSeeds(config: WorkspaceOptions): Promise<ProjectSeed[]>;
+    private static filterNestedPackageJsonFiles;
+    static getProjects(config: WorkspaceOptions, configuration?: string): Promise<Project[]>;
+    private static projectFrom;
+}

package/types/src/factories/workspace.factory.d.ts

@@ -0,0 +1,9 @@
+import { Workspace } from "../models/workspace.model.js";
+import type { WorkspaceFactoryOptions, WorkspaceOptions } from "../models/workspace-config.type.js";
+declare class Factory {
+    create(options?: WorkspaceFactoryOptions & Partial<WorkspaceOptions>): Promise<Workspace>;
+    private getMergedConfig;
+    private getPackageJson;
+}
+export declare const WorkspaceFactory: Factory;
+export {};

package/types/src/index.d.ts

@@ -0,0 +1,18 @@
+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 { type PackageAliases, packageAliases } from "./models/package-aliases.js";
+export type { PackageExports, RepositoryReference } from "./models/package-json.model.js";
+export { PackageJson } from "./models/package-json.model.js";
+export type { ProjectConfig, ProjectSeed } from "./models/project.model.js";
+export { Project } from "./models/project.model.js";
+export { sourceExtensions } from "./models/source-extensions.js";
+export type { ProjectFileEvent } from "./models/project-file-event.js";
+export { DEFAULT_COMPILER_OPTIONS, Tsconfig } from "./models/tsconfig.model.js";
+export { Workspace } from "./models/workspace.model.js";
+export type { Configuration, ProjectOptions, UiConfig, WorkspaceFactoryOptions, WorkspaceOptions, } from "./models/workspace-config.type.js";

package/types/src/models/has-package-json.mixin.d.ts

@@ -0,0 +1,9 @@
+import { PackageJson } from "./package-json.model.js";
+export declare abstract class HasPackageJson {
+    protected abstract packageJson?: PackageJson;
+    protected abstract get packageJsonDirectory(): string;
+    getPackageJson(): Promise<PackageJson>;
+    get packageJsonPath(): string;
+    getVersion(): Promise<string>;
+    persistPackageJson(packageJson: PackageJson): Promise<void>;
+}

package/types/src/models/has-tsconfig.mixin.d.ts

@@ -0,0 +1,11 @@
+import { Tsconfig } from "./tsconfig.model.js";
+export declare abstract class HasTsConfig {
+    protected abstract get tsConfigDirectory(): string;
+    protected abstract get fallbackTsConfigDirectory(): string | undefined;
+    getTsConfig(): Promise<Tsconfig>;
+    getTsConfigSync(): Tsconfig;
+    /** First existing `tsconfig.json` on this object, if any. */
+    protected findTsConfigPath(): string | undefined;
+    private get tsConfigPaths();
+    private static fileExistsSync;
+}

package/types/src/models/package-aliases.d.ts

@@ -0,0 +1,28 @@
+import type { Project } from "./project.model.js";
+export type PackageAliases = {
+    /** Absolute base for SWC `jsc.paths` / specifier resolution. */
+    baseUrl: string;
+    /** Package-name and `name/*` keys, values relative to `baseUrl`. */
+    paths: Record<string, string[]>;
+};
+/**
+ * Convention aliases from workspace packages, then tsconfig `paths` for the same keys.
+ * Prefer `Workspace.getPackageAliases` when a workspace is available.
+ */
+declare function build(projects: readonly Project[], options: {
+    baseUrl: string;
+    tsconfigPaths?: Record<string, string[]>;
+}): PackageAliases;
+/** Bare import specifier that is not relative, absolute, or a node/file URL. */
+declare function isBareSpecifier(specifier: string): boolean;
+/**
+ * Resolve a bare specifier through package aliases (SWC-style `paths`
+ * relative to `baseUrl`) to an absolute `.ts` path. Longest key wins.
+ */
+declare function resolvePath(specifier: string, paths: Record<string, string[]>, baseUrl: string): string | null;
+export declare const packageAliases: {
+    build: typeof build;
+    isBareSpecifier: typeof isBareSpecifier;
+    resolvePath: typeof resolvePath;
+};
+export {};

package/types/src/models/package-json.model.d.ts

@@ -0,0 +1,39 @@
+export type RepositoryReference = string | {
+    type?: string;
+    url?: string;
+    directory?: string;
+};
+export type PackageExports = string | {
+    [key: string]: PackageExports;
+};
+export declare class PackageJson {
+    private static readonly PACKAGE_JSON_KEY_ORDER;
+    constructor(data?: Partial<PackageJson>);
+    sort(): this;
+    withVersion(version: string): PackageJson;
+    withDependencies(dependencies: Record<string, string>): PackageJson;
+    withDevDependencies(devDependencies: Record<string, string>): PackageJson;
+    toJSON(): string;
+    getRepositoryOwner(): string;
+    getRepositoryName(): string;
+    getRepositoryFullName(): string;
+    private sortDependencyMap;
+    private sortPackageJsonKeys;
+    private toSortedPackageJsonRecord;
+    private repositoryReferenceToString;
+    private parseRepository;
+    private parseRepositoryFromUrl;
+    private sanitizeRepositoryName;
+    readonly name: string;
+    version: string;
+    readonly repository?: RepositoryReference;
+    readonly main: string;
+    /** `exports` as written in package.json: a path, or a map of subpaths (values may be condition maps). */
+    readonly exports?: PackageExports;
+    readonly peerDependencies?: Record<string, string>;
+    readonly optionalDependencies?: Record<string, string>;
+    readonly scripts: Record<string, string>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    readonly private?: boolean;
+}

package/types/src/models/project-file-event.d.ts

@@ -0,0 +1,8 @@
+import type { FileEx, io } from "@decohere/core/io";
+import type { Project } from "./project.model.js";
+export type ProjectFileEvent = {
+    eventName: io.WatchEventName;
+    project: Project;
+    configuration: string;
+    file: FileEx;
+};

package/types/src/models/project.model.d.ts

@@ -0,0 +1,64 @@
+import { type FileEx, type Watcher } from "@decohere/core/io";
+import { HasPackageJson } from "./has-package-json.mixin.js";
+import { HasTsConfig } from "./has-tsconfig.mixin.js";
+import { PackageJson } from "./package-json.model.js";
+import type { ProjectFileEvent } from "./project-file-event.js";
+import type { Configuration, WorkspaceOptions } from "./workspace-config.type.js";
+export type ProjectConfig = {
+    projectDir?: string;
+    packageJson?: PackageJson;
+} & WorkspaceOptions;
+export type ProjectSeed = {
+    name: string;
+    config?: ProjectConfig;
+};
+declare const Project_base: abstract new (...args: unknown[]) => HasPackageJson & HasTsConfig;
+export declare class Project extends Project_base {
+    #private;
+    protected packageJson?: PackageJson;
+    constructor(name: string, config?: ProjectConfig, selectedConfigurationName?: string);
+    get name(): string;
+    get isPrivate(): boolean;
+    toString(): string;
+    get projectDirectory(): string;
+    get projectRoot(): string;
+    get configuration(): Configuration;
+    protected get packageJsonDirectory(): string;
+    protected get tsConfigDirectory(): string;
+    protected get fallbackTsConfigDirectory(): string | undefined;
+    get rootDir(): string;
+    get include(): string[];
+    get ignore(): string[];
+    get copyFiles(): string[];
+    get dockerConfig(): import("./workspace-config.type.js").DockerConfig;
+    get uiConfig(): import("./workspace-config.type.js").UiConfig;
+    get configurations(): Configuration[];
+    get projectFileChanged$(): import("rxjs").Observable<ProjectFileEvent>;
+    getAllFiles(): Promise<FileEx[]>;
+    isSourceFile(file: FileEx): boolean;
+    watch(configuration: string): Promise<Watcher>;
+    stopWatching(): void;
+    getRootOut(): string;
+    getOutDir(target?: string): string;
+    getConfiguration(name: string): Configuration;
+    /**
+     * The package's entry source file. A TypeScript `main` (the workspace convention,
+     * `src/index.ts`) is used as written. A `main` or `exports["."]` that describes the published
+     * layout (`index.js`, `./es6/src/index.js`) is mapped back to the source it was built from,
+     * falling back to `src/index.ts` (#518).
+     */
+    getSourceEntryPath(): string;
+    /**
+     * The source file each subpath in package.json `exports` names, such as `./auth` →
+     * `<project>/src/auth/auth.extensions.ts` (#518). Exports point at the release layout
+     * (`./es6/src/auth/auth.extensions.js`); the source is the part from `src/`, with its
+     * TypeScript extension. Wildcard subpaths, and targets with no such source file, are left out.
+     */
+    getSourceExports(): Record<string, string>;
+    [Symbol.dispose](): void;
+    private getWorkspaceOut;
+    private updateSourceFileCache;
+    private matchesSourcePattern;
+    private resolveConfiguration;
+}
+export {};

package/types/src/models/source-extensions.d.ts

@@ -0,0 +1,22 @@
+/** Whether a path is a TypeScript source (not a declaration file). */
+declare function isSource(file: string): boolean;
+/**
+ * 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.
+ */
+declare function candidates(file: string): string[];
+/** The extension a source builds to: `.mts` to `.mjs`, `.cts` to `.cjs`, the rest to `.js`. */
+declare function outputExtension(file: string): string;
+/** The path a source builds to: `a.mts` to `a.mjs`, `a.cts` to `a.cjs`, `a.ts` and `a.tsx` to `a.js`. */
+declare function outputPath(file: string): string;
+/** Whether a source is CommonJS (`.cts`); everything else compiles as an ES module. */
+declare function isCommonJs(file: string): boolean;
+export declare const sourceExtensions: {
+    SOURCE: readonly [".ts", ".tsx", ".mts", ".cts"];
+    isSource: typeof isSource;
+    candidates: typeof candidates;
+    outputExtension: typeof outputExtension;
+    outputPath: typeof outputPath;
+    isCommonJs: typeof isCommonJs;
+};
+export {};

package/types/src/models/tsconfig.model.d.ts

@@ -0,0 +1,11 @@
+import ts, { type CompilerOptions } from "typescript";
+export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
+export declare class Tsconfig {
+    static default(): Tsconfig;
+    static parse(filePath: string): Promise<Tsconfig>;
+    static parseSync(filePath: string): Tsconfig;
+    private static fileExistsSync;
+    constructor(data?: Partial<Tsconfig>);
+    readonly compilerOptions: CompilerOptions;
+    readonly errors: readonly ts.Diagnostic[];
+}

package/types/src/models/workspace-config.type.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Generic configuration for a workspace build profile.
+ * Concrete tools (e.g. @decohere/forge) extend this with tool-specific fields.
+ */
+export type Configuration = {
+    name: string;
+    include?: string[];
+    ignore?: string[];
+    /** Extra globs to copy into the configuration outDir (non-transpiled assets). */
+    copyFiles?: string[];
+    /** If true, the output is packed into a folder per project directory. */
+    pack?: boolean;
+};
+export type DockerConfig = {
+    image?: string;
+    dockerfile?: string;
+    buildArgs?: Record<string, string>;
+    secrets?: Record<string, string>;
+    tags?: string[];
+    push?: boolean;
+};
+/**
+ * The UI a deployable serves from its API (`withStatic` in `@decohere/http`). `forge package` copies the
+ * UI project's build output into the deployable's `.package/` folder.
+ */
+export type UiConfig = {
+    /** Package name of the UI project, e.g. `@app/shop.web`. */
+    project: string;
+    /** The UI project's build output folder, relative to that project. Defaults to `dist`. */
+    output?: string;
+    /** Where it lands inside `.package/`, which is also the folder the API serves. Defaults to `ui`. */
+    to?: string;
+};
+export type WorkspaceFactoryOptions = {
+    rootDir?: string;
+    configFile?: string;
+};
+export type ProjectOptions = {
+    include?: string[];
+    ignore?: string[];
+    copyFiles: string[];
+    configurations: Configuration[];
+    docker?: DockerConfig;
+    ui?: UiConfig;
+};
+export type WorkspaceOptions = {
+    rootDir?: string;
+    outDir: string;
+    includeProjects: string[];
+    ignoreProjects: string[];
+    projects?: Record<string, Partial<ProjectOptions>>;
+} & ProjectOptions;

package/types/src/models/workspace.model.d.ts

@@ -0,0 +1,40 @@
+import { HasPackageJson } from "./has-package-json.mixin.js";
+import { HasTsConfig } from "./has-tsconfig.mixin.js";
+import { type PackageAliases } from "./package-aliases.js";
+import { PackageJson } from "./package-json.model.js";
+import { Project, type ProjectSeed } from "./project.model.js";
+import type { ProjectFileEvent } from "./project-file-event.js";
+import type { WorkspaceOptions } from "./workspace-config.type.js";
+export type WorkspaceInitOptions = {
+    packageJson?: PackageJson;
+    config: Partial<WorkspaceOptions>;
+    projects: ProjectSeed[];
+};
+declare const Workspace_base: abstract new (...args: unknown[]) => HasPackageJson & HasTsConfig;
+export declare class Workspace extends Workspace_base {
+    #private;
+    protected packageJson?: PackageJson;
+    constructor(options?: Partial<WorkspaceInitOptions>);
+    get name(): string;
+    protected get projectSeeds(): readonly ProjectSeed[];
+    getProjects(configuration: string): readonly Project[];
+    get rootDir(): string;
+    get packageJsonDirectory(): string;
+    protected get tsConfigDirectory(): string;
+    protected get fallbackTsConfigDirectory(): string | 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: string): PackageAliases;
+    watch(configuration: string): Promise<void>;
+    stopWatching(): void;
+    [Symbol.dispose](): void;
+    get projectFileChanged$(): import("rxjs").Observable<ProjectFileEvent>;
+    findProject(filePath: string, buildConfig: string): Promise<Project | undefined>;
+    private sourcePathsOf;
+    private validateWorkspace;
+    private findDuplicateProjectSeeds;
+}
+export {};