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

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

@@ -1,34 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,58 +0,0 @@
-import path from "node:path";
-import { io } from "@decohere/core/io";
-import { findFiles } from "@decohere/devkit/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 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

@@ -1,35 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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);

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

@@ -1,97 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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
-        });
-    }
-    withPeerDependencies(peerDependencies) {
-        return new PackageJson({
-            ...this,
-            peerDependencies
-        });
-    }
-    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

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