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

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

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "HasTsConfig", {
-    enumerable: true,
-    get: function() {
-        return HasTsConfig;
-    }
-});
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _caching = require("@decohere/core/caching");
-const _io = require("@decohere/core/io");
-const _const = require("../const.js");
-const _tsconfigmodel = require("./tsconfig.model.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-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 HasTsConfig {
-    async getTsConfig() {
-        for (const configPath of this.tsConfigPaths){
-            if (await _io.io.fileExists(configPath)) return _tsconfigmodel.Tsconfig.parse(configPath);
-        }
-        return _tsconfigmodel.Tsconfig.default();
-    }
-    getTsConfigSync() {
-        const configPath = this.findTsConfigPath();
-        if (configPath != null) return _tsconfigmodel.Tsconfig.parseSync(configPath);
-        return _tsconfigmodel.Tsconfig.default();
-    }
-    /** First existing `tsconfig.json` on this object, if any. */ findTsConfigPath() {
-        return this.tsConfigPaths.find((configPath)=>HasTsConfig.fileExistsSync(configPath));
-    }
-    get tsConfigPaths() {
-        const paths = [
-            _nodepath.default.join(this.tsConfigDirectory, _const.TS_CONFIG)
-        ];
-        const fallback = this.fallbackTsConfigDirectory;
-        if (fallback != null) {
-            paths.push(_nodepath.default.join(fallback, _const.TS_CONFIG));
-        }
-        return paths;
-    }
-    static fileExistsSync(filePath) {
-        try {
-            return _nodefs.default.statSync(filePath).isFile();
-        } catch  {
-            return false;
-        }
-    }
-}
-_ts_decorate([
-    (0, _caching.memoize)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", Promise)
-], HasTsConfig.prototype, "getTsConfig", null);
-_ts_decorate([
-    (0, _caching.memoize)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", void 0)
-], HasTsConfig.prototype, "getTsConfigSync", null);

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

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "packageAliases", {
-    enumerable: true,
-    get: function() {
-        return packageAliases;
-    }
-});
-const _nodefs = require("node:fs");
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _sourceextensions = require("./source-extensions.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-/**
- * 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 = _nodepath.default.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 = _nodepath.default.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(_nodepath.default.resolve(resolvedBase, mappedRoot, subpath));
-        }
-        if (specifier === key) {
-            return toTsSourcePath(_nodepath.default.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 = _nodepath.default.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 = (0, _nodefs.existsSync)(entry);
-        if (hasEntry) aliases[name] = [
-            toPosixRelative(baseUrl, entry)
-        ];
-        const subpathRoot = hasEntry ? _nodepath.default.dirname(entry) : _nodepath.default.resolve(project.rootDir, project.projectDirectory, "src");
-        if ((0, _nodefs.existsSync)(subpathRoot)) {
-            aliases[`${name}/*`] = [
-                `${toPosixRelative(baseUrl, subpathRoot)}/*`
-            ];
-        }
-        // Subpaths the package exports, mapped to their sources: 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 = _nodepath.default.relative(from, to);
-    if (relative === "") return ".";
-    return relative.split(_nodepath.default.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.sourceExtensions.candidates(candidate);
-    const directory = candidate.replace(/\.([mc]?[jt]sx?)$/, "");
-    const indexes = _sourceextensions.sourceExtensions.candidates(_nodepath.default.join(directory, "index"));
-    return [
-        ...files,
-        ...indexes
-    ].find((file)=>(0, _nodefs.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.sourceExtensions.candidates(candidate)[0] ?? `${candidate}.ts`;
-}
-const packageAliases = {
-    build,
-    isBareSpecifier,
-    resolvePath
-};

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

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "PackageJson", {
-    enumerable: true,
-    get: function() {
-        return PackageJson;
-    }
-});
-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/commonjs/src/models/project-file-event.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});