@decohere/workspace 0.0.1-dev.126 → 0.0.1-dev.5

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

@@ -0,0 +1,231 @@
+export type RepositoryReference =
+	| string
+	| {
+			type?: string;
+			url?: string;
+			directory?: string;
+	  };
+
+export type PackageExports = string | { [key: string]: PackageExports };
+
+type ParsedRepository = {
+	owner: string;
+	name: string;
+};
+
+export class PackageJson {
+	private static readonly PACKAGE_JSON_KEY_ORDER = [
+		"$schema",
+		"name",
+		"displayName",
+		"version",
+		"description",
+		"keywords",
+		"homepage",
+		"bugs",
+		"repository",
+		"license",
+		"author",
+		"contributors",
+		"funding",
+		"type",
+		"main",
+		"module",
+		"types",
+		"exports",
+		"files",
+		"bin",
+		"man",
+		"directories",
+		"scripts",
+		"dependencies",
+		"devDependencies",
+		"peerDependencies",
+		"peerDependenciesMeta",
+		"optionalDependencies",
+		"bundledDependencies",
+		"engines",
+		"os",
+		"cpu",
+		"private",
+		"publishConfig",
+		"workspaces",
+		"packageManager",
+		"forge",
+	] as const;
+
+	public constructor(data?: Partial<PackageJson>) {
+		Object.assign(this, data);
+		this.dependencies = this.dependencies ?? {};
+		this.devDependencies = this.devDependencies ?? {};
+	}
+
+	public sort(): this {
+		const sorted = this.toSortedPackageJsonRecord();
+		Object.assign(this, sorted);
+		return this;
+	}
+
+	public withVersion(version: string): PackageJson {
+		return new PackageJson({ ...this, version });
+	}
+
+	public withDependencies(dependencies: Record<string, string>): PackageJson {
+		return new PackageJson({ ...this, dependencies });
+	}
+
+	public withDevDependencies(devDependencies: Record<string, string>): PackageJson {
+		return new PackageJson({ ...this, devDependencies });
+	}
+
+	public toJSON(): string {
+		return `${JSON.stringify(this.toSortedPackageJsonRecord(), null, 2)}\n`;
+	}
+
+	public getRepositoryOwner() {
+		return this.parseRepository()?.owner;
+	}
+
+	public getRepositoryName() {
+		return this.parseRepository()?.name;
+	}
+
+	public getRepositoryFullName() {
+		const parsed = this.parseRepository();
+		if (parsed == null) {
+			return undefined;
+		}
+
+		return `${parsed.owner}/${parsed.name}`;
+	}
+
+	private sortDependencyMap(input: Record<string, string>) {
+		return Object.fromEntries(
+			Object.entries(input).sort(([left], [right]) => left.localeCompare(right, "en")),
+		);
+	}
+
+	private sortPackageJsonKeys(source: Record<string, unknown>) {
+		const sorted = Object.create(null) as Record<string, unknown>;
+
+		for (const key of PackageJson.PACKAGE_JSON_KEY_ORDER) {
+			if (key in source) {
+				sorted[key] = source[key];
+			}
+		}
+
+		const remainingKeys = Object.keys(source)
+			.filter((key) => !PackageJson.PACKAGE_JSON_KEY_ORDER.includes(key as never))
+			.sort();
+
+		for (const key of remainingKeys) {
+			sorted[key] = source[key];
+		}
+
+		return sorted;
+	}
+
+	private toSortedPackageJsonRecord() {
+		const clone = { ...this } as Record<string, unknown>;
+		if (clone.dependencies) {
+			clone.dependencies = this.sortDependencyMap(
+				clone.dependencies as Record<string, string>,
+			);
+		}
+		if (clone.devDependencies) {
+			clone.devDependencies = this.sortDependencyMap(
+				clone.devDependencies as Record<string, string>,
+			);
+		}
+		return this.sortPackageJsonKeys(clone);
+	}
+
+	private repositoryReferenceToString(repository?: RepositoryReference) {
+		if (typeof repository === "string") {
+			return repository;
+		}
+
+		if (repository == null) {
+			return "";
+		}
+
+		return String(repository.url ?? "");
+	}
+
+	private parseRepository(): ParsedRepository | undefined {
+		const repositoryValue = this.repositoryReferenceToString(this.repository);
+		if (repositoryValue === "") {
+			return undefined;
+		}
+
+		const trimmed = repositoryValue.trim();
+
+		if (!trimmed.includes("://") && !trimmed.startsWith("git@")) {
+			const shorthand = /^(?:[a-z0-9-]+:)?([^/\s]+)\/([^\s]+)$/i.exec(trimmed);
+			if (shorthand) {
+				return {
+					owner: shorthand[1].toLowerCase(),
+					name: this.sanitizeRepositoryName(shorthand[2]),
+				};
+			}
+		}
+
+		const ssh = /^git@[^:]+:([^/\s]+)\/([^\s]+)$/i.exec(trimmed);
+		if (ssh) {
+			return {
+				owner: ssh[1].toLowerCase(),
+				name: this.sanitizeRepositoryName(ssh[2]),
+			};
+		}
+
+		const urlRepository = this.parseRepositoryFromUrl(trimmed);
+		if (urlRepository != null) {
+			return urlRepository;
+		}
+
+		return undefined;
+	}
+
+	private parseRepositoryFromUrl(repository: string): ParsedRepository | undefined {
+		const normalized = repository.replace(/^git\+/, "");
+		let url: URL;
+		try {
+			url = new URL(normalized);
+		} catch {
+			return undefined;
+		}
+
+		const segments = url.pathname.split("/").filter(Boolean);
+		if (segments.length < 2) {
+			return undefined;
+		}
+
+		const owner = segments[0]?.toLowerCase();
+		const name = this.sanitizeRepositoryName(segments[1] ?? "");
+		if (owner == null || owner === "" || name === "") {
+			return undefined;
+		}
+
+		return {
+			owner,
+			name,
+		};
+	}
+
+	private sanitizeRepositoryName(name: string) {
+		return name.replace(/\.git$/i, "").toLowerCase();
+	}
+
+	public readonly name: string;
+	public version: string;
+	public readonly repository?: RepositoryReference;
+	public readonly main: string;
+	/** `exports` as written in package.json: a path, or a map of subpaths (values may be condition maps). */
+	public readonly exports?: PackageExports;
+	public readonly peerDependencies?: Record<string, string>;
+	public readonly optionalDependencies?: Record<string, string>;
+	public readonly scripts: Record<string, string>;
+	public dependencies: Record<string, string> = {};
+	public devDependencies: Record<string, string> = {};
+	public readonly private?: boolean;
+}

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

@@ -0,0 +1,9 @@
+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/src/models/project.model.ts

@@ -0,0 +1,340 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { cache, memoize } from "@decohere/core/caching";
+import { mixwith } from "@decohere/core/extensibility";
+import { type FileEx, io, type Watcher } from "@decohere/core/io";
+import picomatch from "picomatch";
+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 { type PackageExports, PackageJson } from "./package-json.model.js";
+import type { ProjectFileEvent } from "./project-file-event.js";
+import { sourceExtensions } from "./source-extensions.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;
+};
+
+export class Project extends mixwith(HasPackageJson, HasTsConfig) {
+	protected packageJson?: PackageJson;
+	readonly #projectFileChangedSubject = new Subject<ProjectFileEvent>();
+	readonly #sourceFiles = new Map<string, FileEx>();
+	readonly #projectConfig: ProjectConfig;
+	readonly #name: string;
+	readonly #projectDirectory: string;
+	readonly #selectedConfiguration: Configuration;
+	#hasLoadedSourceFiles = false;
+	#watcher?: Watcher;
+
+	public constructor(
+		name: string,
+		config: ProjectConfig = {} as ProjectConfig,
+		selectedConfigurationName?: string,
+	) {
+		super();
+		this.#name = name;
+		this.#projectDirectory = config?.projectDir ?? name;
+		this.#projectConfig = config;
+		this.#selectedConfiguration = this.resolveConfiguration(selectedConfigurationName);
+		this.packageJson = config.packageJson ?? new PackageJson();
+	}
+
+	public get name() {
+		return this.#name;
+	}
+
+	public get isPrivate() {
+		return this.packageJson?.private === true;
+	}
+
+	public toString() {
+		return `Project(${this.#name})`;
+	}
+
+	public get projectDirectory() {
+		return this.#projectDirectory;
+	}
+
+	public get projectRoot() {
+		return path.resolve(this.#projectConfig.rootDir ?? "./", this.#projectDirectory);
+	}
+
+	public get configuration() {
+		return this.#selectedConfiguration;
+	}
+
+	protected get packageJsonDirectory(): string {
+		return this.#absoluteProjectDir;
+	}
+
+	protected get tsConfigDirectory(): string {
+		return this.#absoluteProjectDir;
+	}
+
+	protected get fallbackTsConfigDirectory(): string | undefined {
+		return this.#projectConfig.rootDir;
+	}
+
+	public get rootDir(): string {
+		return this.#projectConfig.rootDir ?? "./";
+	}
+
+	get #absoluteProjectDir(): string {
+		return this.projectRoot;
+	}
+
+	public get include() {
+		return this.#selectedConfiguration.include ?? this.#projectConfig.include ?? [];
+	}
+
+	public get ignore() {
+		const baseIgnore = this.#projectConfig.ignore ?? [];
+		const selectedIgnore = this.#selectedConfiguration.ignore ?? [];
+		return [...baseIgnore, ...selectedIgnore];
+	}
+
+	public get copyFiles() {
+		const base = this.#projectConfig.copyFiles ?? [];
+		const selected = this.#selectedConfiguration.copyFiles ?? [];
+		return [...base, ...selected];
+	}
+
+	public get dockerConfig() {
+		return this.#projectConfig.docker;
+	}
+
+	public get uiConfig() {
+		return this.#projectConfig.ui;
+	}
+
+	public get configurations(): Configuration[] {
+		return this.#projectConfig.configurations ?? [];
+	}
+
+	public get projectFileChanged$() {
+		return this.#projectFileChangedSubject.asObservable();
+	}
+
+	@memoize()
+	public async getAllFiles() {
+		const files = await io.findFiles(this.include, {
+			cwd: this.#absoluteProjectDir,
+			ignore: this.ignore,
+		});
+
+		this.#sourceFiles.clear();
+		for (const file of files) {
+			this.#sourceFiles.set(file.relativePath, file);
+		}
+		this.#hasLoadedSourceFiles = true;
+		return files;
+	}
+
+	public isSourceFile(file: FileEx) {
+		return this.#sourceFiles.has(file.relativePath);
+	}
+
+	public async watch(configuration: string) {
+		if (this.#watcher != null) {
+			return this.#watcher;
+		}
+
+		if (!this.#hasLoadedSourceFiles) {
+			await this.getAllFiles();
+		}
+
+		const watcher = io.watch(this.#absoluteProjectDir, { ignoreInitial: true });
+		this.#watcher = watcher;
+
+		watcher.on(io.WatchEvents.add, (file) => {
+			const fileEx = file as FileEx;
+			this.updateSourceFileCache(io.WatchEvents.add, fileEx);
+			this.#projectFileChangedSubject.next({
+				project: this,
+				configuration,
+				eventName: io.WatchEvents.add,
+				file: fileEx,
+			});
+		});
+
+		watcher.on(io.WatchEvents.change, (file) => {
+			const fileEx = file as FileEx;
+			this.updateSourceFileCache(io.WatchEvents.change, fileEx);
+			this.#projectFileChangedSubject.next({
+				project: this,
+				configuration,
+				eventName: io.WatchEvents.change,
+				file: fileEx,
+			});
+		});
+
+		watcher.on(io.WatchEvents.unlink, (file) => {
+			const fileEx = file as FileEx;
+			this.updateSourceFileCache(io.WatchEvents.unlink, fileEx);
+			this.#projectFileChangedSubject.next({
+				project: this,
+				configuration,
+				eventName: io.WatchEvents.unlink,
+				file: fileEx,
+			});
+		});
+
+		return watcher;
+	}
+
+	public stopWatching() {
+		this.#watcher?.close();
+		this.#watcher = undefined;
+	}
+
+	@cache()
+	public getRootOut() {
+		return path.join(this.getWorkspaceOut(), this.#selectedConfiguration.name);
+	}
+
+	@cache()
+	public getOutDir(target = "") {
+		const targetDir = this.#selectedConfiguration.pack
+			? path.join(this.projectDirectory, target)
+			: path.join(this.projectDirectory);
+
+		const out = path.join(this.getRootOut(), targetDir);
+		return out;
+	}
+
+	public getConfiguration(name: string) {
+		return this.configurations.find((b) => b.name === name);
+	}
+
+	/**
+	 * 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).
+	 */
+	public getSourceEntryPath(): string {
+		const projectRoot = path.join(this.rootDir, this.projectDirectory);
+		const main = this.packageJson?.main;
+		if (main != null && sourceExtensions.isSource(main)) {
+			return path.join(projectRoot, main);
+		}
+		const exports = this.packageJson?.exports;
+		const root =
+			exports == null
+				? undefined
+				: typeof exports === "string"
+					? exports
+					: (exports["."] ??
+						(Object.keys(exports).some((k) => k.startsWith(".")) ? undefined : exports));
+		for (const built of [root == null ? undefined : firstExportTarget(root), main]) {
+			const fromSrc = built?.match(/(?:^|\/)(src\/.+)$/)?.[1];
+			const source =
+				fromSrc == null ? undefined : sourceFileFor(path.join(projectRoot, fromSrc));
+			if (source != null) return source;
+		}
+		const conventional = path.join(projectRoot, "src/index.ts");
+		if (main == null || existsSync(conventional)) return conventional;
+		return path.join(projectRoot, main);
+	}
+
+	/**
+	 * 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.
+	 */
+	public getSourceExports(): Record<string, string> {
+		const exports = this.packageJson?.exports;
+		if (exports == null || typeof exports === "string") return {};
+		const projectRoot = path.join(this.rootDir, this.projectDirectory);
+		const sources: Record<string, string> = {};
+		for (const [subpath, target] of Object.entries(exports)) {
+			if (!subpath.startsWith("./") || subpath.includes("*")) continue;
+			const built = firstExportTarget(target);
+			const fromSrc = built?.match(/(?:^|\/)(src\/.+)$/)?.[1];
+			if (fromSrc == null) continue;
+			const source = sourceFileFor(path.join(projectRoot, fromSrc));
+			if (source != null) sources[subpath] = source;
+		}
+		return sources;
+	}
+
+	public [Symbol.dispose]() {
+		this.stopWatching();
+	}
+
+	private getWorkspaceOut() {
+		const out = path.join(this.#projectConfig.rootDir ?? "./", this.#projectConfig.outDir);
+		return out;
+	}
+
+	private updateSourceFileCache(eventName: io.WatchEventName, file: FileEx) {
+		if (!this.#hasLoadedSourceFiles) {
+			return;
+		}
+
+		switch (eventName) {
+			case io.WatchEvents.unlink:
+				this.#sourceFiles.delete(file.relativePath);
+				return;
+			case io.WatchEvents.add:
+			case io.WatchEvents.change:
+				if (this.matchesSourcePattern(file.relativePath)) {
+					this.#sourceFiles.set(file.relativePath, file);
+					return;
+				}
+
+				this.#sourceFiles.delete(file.relativePath);
+				return;
+		}
+	}
+
+	private matchesSourcePattern(relativePath: string) {
+		if (picomatch.isMatch(relativePath, this.ignore)) {
+			return false;
+		}
+
+		return picomatch.isMatch(relativePath, this.include);
+	}
+
+	private resolveConfiguration(configurationName?: string): Configuration {
+		const resolvedConfigurationName = configurationName ?? "debug";
+
+		const configuration = this.configurations.find(
+			(c) => c.name === resolvedConfigurationName,
+		);
+		if (configuration == null) {
+			throw new WorkspaceConfigurationError(
+				`Configuration "${resolvedConfigurationName}" was not found for project "${this.name}"`,
+			);
+		}
+
+		return configuration;
+	}
+}
+
+/** The first path an exports value gives, preferring the conditions that name runtime code. */
+function firstExportTarget(value: PackageExports): string | undefined {
+	if (typeof value === "string") return value;
+	for (const condition of ["import", "default", "require", "node", "types"]) {
+		const nested = value[condition];
+		if (nested != null) return firstExportTarget(nested);
+	}
+	return undefined;
+}
+
+/** The TypeScript source a built or declaration path came from, if it exists. */
+function sourceFileFor(builtPath: string): string | undefined {
+	// A declaration names the file its JavaScript sits next to: `x.d.ts` is `x.js`.
+	const declaration = builtPath.match(/^(.*)\.d\.([mc]?)ts$/);
+	const built = declaration == null ? builtPath : `${declaration[1]}.${declaration[2]}js`;
+	return sourceExtensions.candidates(built).find((candidate) => existsSync(candidate));
+}

package/src/models/source-extensions.ts

@@ -0,0 +1,59 @@
+import path from "node:path";
+
+/** TypeScript source extensions a workspace compiles (#518). */
+const SOURCE = [".ts", ".tsx", ".mts", ".cts"] as const;
+
+/** The sources an import's extension can name: `./a.js` is `a.ts` or `a.tsx`, `./a.mjs` is `a.mts`. */
+const SOURCES_FOR: Record<string, readonly string[]> = {
+	".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: string): boolean {
+	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: string): string[] {
+	if (isSource(file)) return [file];
+	const ext = path.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: string): string {
+	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: string): string {
+	const ext = path.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: string): boolean {
+	return file.endsWith(".cts");
+}
+
+export const sourceExtensions = {
+	SOURCE,
+	isSource,
+	candidates,
+	outputExtension,
+	outputPath,
+	isCommonJs,
+};