@decohere/workspace 0.0.1-dev.116

package/es6/src/models/package-aliases.js

@@ -0,0 +1,97 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { sourceExtensions } from "./source-extensions.js";
+/**
+ * Convention aliases from workspace packages, then tsconfig `paths` for the same keys.
+ * Prefer `Workspace.getPackageAliases` when a workspace is available.
+ */ function build(projects, options) {
+    const baseUrl = path.resolve(options.baseUrl);
+    const paths = {
+        ...conventionAliasPaths(projects, baseUrl),
+        ...options.tsconfigPaths
+    };
+    return {
+        baseUrl,
+        paths
+    };
+}
+/** Bare import specifier that is not relative, absolute, or a node/file URL. */ function isBareSpecifier(specifier) {
+    return specifier.length > 0 && !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("file:") && !specifier.startsWith("data:") && !specifier.startsWith("#");
+}
+/**
+ * Resolve a bare specifier through package aliases (SWC-style `paths`
+ * relative to `baseUrl`) to an absolute `.ts` path. Longest key wins.
+ */ function resolvePath(specifier, paths, baseUrl) {
+    if (!isBareSpecifier(specifier)) return null;
+    const resolvedBase = path.resolve(baseUrl);
+    const keys = Object.keys(paths).sort((a, b)=>b.length - a.length);
+    for (const key of keys){
+        const target = paths[key]?.[0];
+        if (target == null) continue;
+        if (key.endsWith("/*")) {
+            const prefix = key.slice(0, -1);
+            if (!specifier.startsWith(prefix)) continue;
+            const mappedRoot = target.endsWith("/*") ? target.slice(0, -2) : target;
+            const subpath = specifier.slice(prefix.length);
+            return subpathSource(path.resolve(resolvedBase, mappedRoot, subpath));
+        }
+        if (specifier === key) {
+            return toTsSourcePath(path.resolve(resolvedBase, target.replace(/\*$/, "")));
+        }
+    }
+    return null;
+}
+function conventionAliasPaths(projects, baseUrl) {
+    const aliases = {};
+    for (const project of projects){
+        const name = project.name;
+        if (name.length === 0) continue;
+        const entry = path.resolve(project.getSourceEntryPath());
+        // A package with no root entry (only subpaths, like core) gets no bare alias, and its
+        // subpaths resolve under `src/`.
+        const hasEntry = existsSync(entry);
+        if (hasEntry) aliases[name] = [
+            toPosixRelative(baseUrl, entry)
+        ];
+        const subpathRoot = hasEntry ? path.dirname(entry) : path.resolve(project.rootDir, project.projectDirectory, "src");
+        if (existsSync(subpathRoot)) {
+            aliases[`${name}/*`] = [
+                `${toPosixRelative(baseUrl, subpathRoot)}/*`
+            ];
+        }
+        // Subpaths the package exports, mapped to their sources (#518): these can name any file,
+        // not just `<sub>.ts` or `<sub>/index.ts` under the entry's directory.
+        for (const [subpath, source] of Object.entries(project.getSourceExports())){
+            aliases[`${name}/${subpath.slice(2)}`] = [
+                toPosixRelative(baseUrl, source)
+            ];
+        }
+    }
+    return aliases;
+}
+function toPosixRelative(from, to) {
+    const relative = path.relative(from, to);
+    if (relative === "") return ".";
+    return relative.split(path.sep).join("/");
+}
+/**
+ * The source file a wildcard subpath names: `<sub>` with a source extension (`.ts`, `.tsx`, or
+ * `.mts`/`.cts` for `.mjs`/`.cjs`), else the `index` source of the directory it names (as
+ * `@pkg/models` is `src/models/index.ts`), else `<sub>.ts` for the caller to report missing.
+ */ function subpathSource(candidate) {
+    const files = sourceExtensions.candidates(candidate);
+    const directory = candidate.replace(/\.([mc]?[jt]sx?)$/, "");
+    const indexes = sourceExtensions.candidates(path.join(directory, "index"));
+    return [
+        ...files,
+        ...indexes
+    ].find((file)=>existsSync(file)) ?? toTsSourcePath(candidate);
+}
+/** A target as a source path: itself when it is one, else its first source candidate. */ function toTsSourcePath(candidate) {
+    return sourceExtensions.candidates(candidate)[0] ?? `${candidate}.ts`;
+}
+export const packageAliases = {
+    build,
+    isBareSpecifier,
+    resolvePath
+};

package/es6/src/models/package-json.model.js

@@ -0,0 +1,186 @@
+export class PackageJson {
+    static 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"
+    ];
+    constructor(data){
+        Object.assign(this, data);
+        this.dependencies = this.dependencies ?? {};
+        this.devDependencies = this.devDependencies ?? {};
+    }
+    sort() {
+        const sorted = this.toSortedPackageJsonRecord();
+        Object.assign(this, sorted);
+        return this;
+    }
+    withVersion(version) {
+        return new PackageJson({
+            ...this,
+            version
+        });
+    }
+    withDependencies(dependencies) {
+        return new PackageJson({
+            ...this,
+            dependencies
+        });
+    }
+    withDevDependencies(devDependencies) {
+        return new PackageJson({
+            ...this,
+            devDependencies
+        });
+    }
+    toJSON() {
+        return `${JSON.stringify(this.toSortedPackageJsonRecord(), null, 2)}\n`;
+    }
+    getRepositoryOwner() {
+        return this.parseRepository()?.owner;
+    }
+    getRepositoryName() {
+        return this.parseRepository()?.name;
+    }
+    getRepositoryFullName() {
+        const parsed = this.parseRepository();
+        if (parsed == null) {
+            return undefined;
+        }
+        return `${parsed.owner}/${parsed.name}`;
+    }
+    sortDependencyMap(input) {
+        return Object.fromEntries(Object.entries(input).sort(([left], [right])=>left.localeCompare(right, "en")));
+    }
+    sortPackageJsonKeys(source) {
+        const sorted = Object.create(null);
+        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)).sort();
+        for (const key of remainingKeys){
+            sorted[key] = source[key];
+        }
+        return sorted;
+    }
+    toSortedPackageJsonRecord() {
+        const clone = {
+            ...this
+        };
+        if (clone.dependencies) {
+            clone.dependencies = this.sortDependencyMap(clone.dependencies);
+        }
+        if (clone.devDependencies) {
+            clone.devDependencies = this.sortDependencyMap(clone.devDependencies);
+        }
+        return this.sortPackageJsonKeys(clone);
+    }
+    repositoryReferenceToString(repository) {
+        if (typeof repository === "string") {
+            return repository;
+        }
+        if (repository == null) {
+            return "";
+        }
+        return String(repository.url ?? "");
+    }
+    parseRepository() {
+        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;
+    }
+    parseRepositoryFromUrl(repository) {
+        const normalized = repository.replace(/^git\+/, "");
+        let 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
+        };
+    }
+    sanitizeRepositoryName(name) {
+        return name.replace(/\.git$/i, "").toLowerCase();
+    }
+    name;
+    version;
+    repository;
+    main;
+    /** `exports` as written in package.json: a path, or a map of subpaths (values may be condition maps). */ exports;
+    peerDependencies;
+    optionalDependencies;
+    scripts;
+    dependencies = {};
+    devDependencies = {};
+    private;
+}

package/es6/src/models/project-file-event.js

@@ -0,0 +1 @@
+export { };

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

@@ -0,0 +1,301 @@
+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 { existsSync } from "node:fs";
+import path from "node:path";
+import { cache, memoize } from "@decohere/core/caching";
+import { mixwith } from "@decohere/core/extensibility";
+import { io } 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 { PackageJson } from "./package-json.model.js";
+import { sourceExtensions } from "./source-extensions.js";
+export class Project extends mixwith(HasPackageJson, HasTsConfig) {
+    packageJson;
+    #projectFileChangedSubject = new Subject();
+    #sourceFiles = new Map();
+    #projectConfig;
+    #name;
+    #projectDirectory;
+    #selectedConfiguration;
+    #hasLoadedSourceFiles = false;
+    #watcher;
+    constructor(name, config = {}, selectedConfigurationName){
+        super();
+        this.#name = name;
+        this.#projectDirectory = config?.projectDir ?? name;
+        this.#projectConfig = config;
+        this.#selectedConfiguration = this.resolveConfiguration(selectedConfigurationName);
+        this.packageJson = config.packageJson ?? new PackageJson();
+    }
+    get name() {
+        return this.#name;
+    }
+    get isPrivate() {
+        return this.packageJson?.private === true;
+    }
+    toString() {
+        return `Project(${this.#name})`;
+    }
+    get projectDirectory() {
+        return this.#projectDirectory;
+    }
+    get projectRoot() {
+        return path.resolve(this.#projectConfig.rootDir ?? "./", this.#projectDirectory);
+    }
+    get configuration() {
+        return this.#selectedConfiguration;
+    }
+    get packageJsonDirectory() {
+        return this.#absoluteProjectDir;
+    }
+    get tsConfigDirectory() {
+        return this.#absoluteProjectDir;
+    }
+    get fallbackTsConfigDirectory() {
+        return this.#projectConfig.rootDir;
+    }
+    get rootDir() {
+        return this.#projectConfig.rootDir ?? "./";
+    }
+    get #absoluteProjectDir() {
+        return this.projectRoot;
+    }
+    get include() {
+        return this.#selectedConfiguration.include ?? this.#projectConfig.include ?? [];
+    }
+    get ignore() {
+        const baseIgnore = this.#projectConfig.ignore ?? [];
+        const selectedIgnore = this.#selectedConfiguration.ignore ?? [];
+        return [
+            ...baseIgnore,
+            ...selectedIgnore
+        ];
+    }
+    get copyFiles() {
+        const base = this.#projectConfig.copyFiles ?? [];
+        const selected = this.#selectedConfiguration.copyFiles ?? [];
+        return [
+            ...base,
+            ...selected
+        ];
+    }
+    get dockerConfig() {
+        return this.#projectConfig.docker;
+    }
+    get uiConfig() {
+        return this.#projectConfig.ui;
+    }
+    get configurations() {
+        return this.#projectConfig.configurations ?? [];
+    }
+    get projectFileChanged$() {
+        return this.#projectFileChangedSubject.asObservable();
+    }
+    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;
+    }
+    isSourceFile(file) {
+        return this.#sourceFiles.has(file.relativePath);
+    }
+    async watch(configuration) {
+        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;
+            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;
+            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;
+            this.updateSourceFileCache(io.WatchEvents.unlink, fileEx);
+            this.#projectFileChangedSubject.next({
+                project: this,
+                configuration,
+                eventName: io.WatchEvents.unlink,
+                file: fileEx
+            });
+        });
+        return watcher;
+    }
+    stopWatching() {
+        this.#watcher?.close();
+        this.#watcher = undefined;
+    }
+    getRootOut() {
+        return path.join(this.getWorkspaceOut(), this.#selectedConfiguration.name);
+    }
+    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;
+    }
+    getConfiguration(name) {
+        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).
+	 */ getSourceEntryPath() {
+        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.
+	 */ getSourceExports() {
+        const exports = this.packageJson?.exports;
+        if (exports == null || typeof exports === "string") return {};
+        const projectRoot = path.join(this.rootDir, this.projectDirectory);
+        const sources = {};
+        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;
+    }
+    [Symbol.dispose]() {
+        this.stopWatching();
+    }
+    getWorkspaceOut() {
+        const out = path.join(this.#projectConfig.rootDir ?? "./", this.#projectConfig.outDir);
+        return out;
+    }
+    updateSourceFileCache(eventName, file) {
+        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;
+        }
+    }
+    matchesSourcePattern(relativePath) {
+        if (picomatch.isMatch(relativePath, this.ignore)) {
+            return false;
+        }
+        return picomatch.isMatch(relativePath, this.include);
+    }
+    resolveConfiguration(configurationName) {
+        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;
+    }
+}
+_ts_decorate([
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], Project.prototype, "getAllFiles", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", void 0)
+], Project.prototype, "getRootOut", null);
+_ts_decorate([
+    cache(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        void 0
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], Project.prototype, "getOutDir", null);
+/** The first path an exports value gives, preferring the conditions that name runtime code. */ function firstExportTarget(value) {
+    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) {
+    // 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/es6/src/models/source-extensions.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+/** 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 = 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) {
+    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 = 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) {
+    return file.endsWith(".cts");
+}
+export const sourceExtensions = {
+    SOURCE,
+    isSource,
+    candidates,
+    outputExtension,
+    outputPath,
+    isCommonJs
+};