@fynpo/base 1.1.23 → 2.0.0

package/dist/fynpo-dep-graph.js

@@ -1,21 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FynpoDepGraph = exports.PackageRef = void 0;
-exports.getDepSection = getDepSection;
-exports.makeDepStep = makeDepStep;
-exports.pkgId = pkgId;
-exports.pkgInfoId = pkgInfoId;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const fs_1 = require("fs");
-const filter_scan_dir_1 = require("filter-scan-dir");
-const minimatch_1 = tslib_1.__importDefault(require("minimatch"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const semver_1 = tslib_1.__importDefault(require("semver"));
-const minimatch_group_1 = require("./minimatch-group");
-const util_1 = require("./util");
-const is_path_inside_1 = tslib_1.__importDefault(require("is-path-inside"));
+import assert from "assert";
+import Path from "path";
+import { promises as Fs } from "fs";
+import { filterScanDir } from "filter-scan-dir";
+import { Minimatch } from "minimatch";
+import _ from "lodash";
+import Semver from "semver";
+import { groupMM } from "./minimatch-group.js";
+import { posixify } from "./util.js";
+import { resolvePackagesConfig, scanPatterns, includeFilter } from "./packages-config.js";
+import { makeGitignoreMatcher } from "./gitignore.js";
+/**
+ * Check that `childPath` is inside `parentPath`.
+ *
+ * Local replacement for the `is-path-inside` package, mirroring its exact
+ * semantics: based on `path.relative`, so on win32 it inherits node's
+ * case-insensitive drive/path comparison. A path is not inside itself.
+ */
+function isPathInside(childPath, parentPath) {
+    const relation = Path.relative(parentPath, childPath);
+    return Boolean(relation &&
+        relation !== ".." &&
+        !relation.startsWith(`..${Path.sep}`) &&
+        relation !== Path.resolve(childPath));
+}
 const DepSectionMap = {
     dependencies: "dep",
     devDependencies: "dev",
@@ -32,7 +39,7 @@ const DepSectionMap = {
  * @param fullName - full name from package.json dep section
  * @returns dep section
  */
-function getDepSection(fullName) {
+export function getDepSection(fullName) {
     return DepSectionMap[fullName] || "dep";
 }
 /**
@@ -43,7 +50,7 @@ function getDepSection(fullName) {
  * @param sec section it's specified as a dep package
  * @returns step string
  */
-function makeDepStep(name, version, sec) {
+export function makeDepStep(name, version, sec) {
     return `${pkgId(name, version)}(${sec})`;
 }
 /**
@@ -51,7 +58,7 @@ function makeDepStep(name, version, sec) {
  *
  * Supports RegExp or minimatch (for path)
  */
-class PackageRef {
+export class PackageRef {
     constructor(ref) {
         this.parseRef(ref);
     }
@@ -96,7 +103,7 @@ class PackageRef {
             }
         }
         else if (this.type === "path") {
-            this.mm = new minimatch_1.default.Minimatch(this.value);
+            this.mm = new Minimatch(this.value);
         }
     }
     match(pkgInfo) {
@@ -113,7 +120,6 @@ class PackageRef {
         }
     }
 }
-exports.PackageRef = PackageRef;
 /**
  * Create a package ID by joining name and version into a single string with `@`
  *
@@ -121,7 +127,7 @@ exports.PackageRef = PackageRef;
  * @param version package version
  * @returns
  */
-function pkgId(name, version) {
+export function pkgId(name, version) {
     /* istanbul ignore next */
     const ver = version ? `@${version}` : "";
     return `${name}${ver}`;
@@ -137,7 +143,7 @@ function pkgId(name, version) {
  * @returns package info
  */
 function resolvePackage(semver, packages, fallbackToFirst = true) {
-    const found = packages.find((pkg) => semver_1.default.satisfies(pkg.version, semver));
+    const found = packages.find((pkg) => Semver.satisfies(pkg.version, semver));
     if (found) {
         return found;
     }
@@ -152,13 +158,13 @@ function resolvePackage(semver, packages, fallbackToFirst = true) {
  * @param info package basic info
  * @returns
  */
-function pkgInfoId(info) {
+export function pkgInfoId(info) {
     return pkgId(info.name, info.version);
 }
 /**
  * fynpo dep graph manager
  */
-class FynpoDepGraph {
+export class FynpoDepGraph {
     constructor(options = {}) {
         this._options = { cwd: process.cwd(), ...options };
         this.depMapByPath = Object.create(null);
@@ -175,7 +181,7 @@ class FynpoDepGraph {
      * @param indirects - set true to resolve indirect deps also
      */
     async resolve(indirects = false) {
-        if (lodash_1.default.isEmpty(this.packages.byName)) {
+        if (_.isEmpty(this.packages.byName)) {
             await this.readPackages();
         }
         this.resolveDirectDeps();
@@ -301,23 +307,36 @@ class FynpoDepGraph {
     async readPackages() {
         const { patterns, cwd } = this._options;
         let groups;
-        // no patterns => setup to search for all package.json
-        const autoSearch = lodash_1.default.isEmpty(patterns);
+        //
+        // Discovery is driven by the `packages` config, resolved the same way readFynpoPackages
+        // resolves it so the two paths cannot drift again (FPO-17). Explicit `patterns` passed to
+        // the constructor still win, for callers that already decided.
+        //
+        const pkgConfig = resolvePackagesConfig(this._options.packages);
+        const resolved = _.isEmpty(patterns) ? scanPatterns(pkgConfig) : patterns;
+        // `include` filters what the scan found - it does not replace the scan (FPO-17)
+        const includeMms = (_.isEmpty(patterns) ? includeFilter(pkgConfig) : []).map((p) => new Minimatch(p));
+        const isIncluded = (path) => includeMms.length === 0 || includeMms.some((m) => m.match(posixify(path)));
+        const autoSearch = resolved === null;
         this.autoSearched = autoSearch;
         const autoSearchFound = [];
+        const gitignore = makeGitignoreMatcher(cwd);
+        const excludeMms = pkgConfig.exclude.map((p) => new Minimatch(p));
+        const isExcluded = (path) => Boolean(path) && excludeMms.some((m) => m.match(path.split(Path.sep).join("/")));
+        const skipForAutoSearch = (path) => autoSearch && pkgConfig.autoSearch.respectGitignore && gitignore.ignores(path);
         if (autoSearch) {
             groups = { ".": null };
         }
         else {
-            const mms = patterns.map((p) => new minimatch_1.default.Minimatch(p));
-            groups = (0, minimatch_group_1.groupMM)(mms, {});
+            const mms = resolved.map((p) => new Minimatch(p));
+            groups = groupMM(mms, {});
         }
         const foundInAutoSearch = (path) => {
             if (!autoSearch) {
                 return false;
             }
             for (const e of autoSearchFound) {
-                if ((0, is_path_inside_1.default)(path, e)) {
+                if (isPathInside(path, e)) {
                     return true;
                 }
             }
@@ -325,12 +344,15 @@ class FynpoDepGraph {
         };
         const files = [];
         for (const prefix in groups) {
-            const scanned = await (0, filter_scan_dir_1.filterScanDir)({
+            const scanned = await filterScanDir({
                 cwd,
                 prefix,
                 concurrency: 500,
                 filter: (file, path, extras) => {
                     if (path && path !== "." && file === "package.json") {
+                        if (isExcluded(path) || skipForAutoSearch(path)) {
+                            return false;
+                        }
                         if (extras.files.includes("fynpo.json") || foundInAutoSearch(path)) {
                             //
                             // We ignore dir with package.json if:
@@ -347,7 +369,7 @@ class FynpoDepGraph {
                 },
                 filterDir: (dir, path, extras) => {
                     if (dir !== "node_modules") {
-                        if (foundInAutoSearch(path)) {
+                        if (foundInAutoSearch(path) || isExcluded(path) || skipForAutoSearch(path)) {
                             return false;
                         }
                         return prefix === "." && groups[prefix] === null
@@ -359,7 +381,9 @@ class FynpoDepGraph {
             });
             files.push(scanned);
         }
-        const allFiles = [].concat(...files).sort();
+        const allFiles = [].concat(...files)
+            .filter((f) => isIncluded(Path.dirname(f)))
+            .sort();
         // Read each package.json and generate PackageInfo for it
         for (const pkgFile of allFiles) {
             await this.addPackageByFile(pkgFile);
@@ -373,9 +397,9 @@ class FynpoDepGraph {
      * @param pkgFile - path to the package.json file
      */
     async addPackageByFile(pkgFile) {
-        const pkgStr = await fs_1.promises.readFile(path_1.default.join(this._options.cwd, pkgFile), "utf-8");
+        const pkgStr = await Fs.readFile(Path.join(this._options.cwd, pkgFile), "utf-8");
         const pkgJson = JSON.parse(pkgStr);
-        this.addPackage(pkgJson, path_1.default.dirname(pkgFile), pkgStr);
+        this.addPackage(pkgJson, Path.dirname(pkgFile), pkgStr);
     }
     /**
      * Add a package to the graph using the data from its package.json
@@ -389,17 +413,17 @@ class FynpoDepGraph {
         if (pkgJson.fynpo === false) {
             return;
         }
-        (0, assert_1.default)(pkgJson.name, `package at ${pkgPath} doesn't have name`);
+        assert(pkgJson.name, `package at ${pkgPath} doesn't have name`);
         // check for npm scope
         const pkgDir = pkgJson.name[0] === "@" && (pkgPath.endsWith(`/${pkgJson.name}`) || pkgPath === pkgJson.name)
             ? pkgJson.name
-            : path_1.default.basename(pkgPath);
+            : Path.basename(pkgPath);
         const pkgInfo = {
             name: pkgJson.name,
             version: pkgJson.version,
             path: pkgPath,
             pkgDir,
-            ...lodash_1.default.pick(pkgJson, [
+            ..._.pick(pkgJson, [
                 "private",
                 "dependencies",
                 "devDependencies",
@@ -441,7 +465,7 @@ class FynpoDepGraph {
             });
             // sort package with multiple versions from latest to oldest
             if (byName[name].length > 1) {
-                byName[name].sort((a, b) => semver_1.default.compare(b.version, a.version));
+                byName[name].sort((a, b) => Semver.compare(b.version, a.version));
             }
         }
     }
@@ -459,6 +483,38 @@ class FynpoDepGraph {
         }
         return undefined;
     }
+    /**
+     * Check if a dependency should NOT be resolved as a local package.
+     *
+     * Checks both:
+     * 1. Monorepo-wide `noFynLocal` option
+     * 2. Per-package `fyn.dependencies[name]` setting (false or "no-fyn-local")
+     *
+     * @param pkgInfo - the package that has the dependency
+     * @param depName - name of the dependency to check
+     * @returns true if the dependency should NOT be resolved locally
+     */
+    checkNoFynLocal(pkgInfo, depName) {
+        var _a, _b;
+        // Check monorepo-wide noFynLocal list
+        if ((_a = this._options.noFynLocal) === null || _a === void 0 ? void 0 : _a.includes(depName)) {
+            return true;
+        }
+        // Check per-package fyn.dependencies setting
+        const fynConfig = (_b = pkgInfo.pkgJson) === null || _b === void 0 ? void 0 : _b.fyn;
+        if (fynConfig) {
+            for (const section of ["dependencies", "devDependencies", "optionalDependencies"]) {
+                const deps = fynConfig[section];
+                if (deps) {
+                    const val = deps[depName];
+                    if (val === false || (typeof val === "string" && val.includes("no-fyn-local"))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
     /**
      * Figure out all the packages' direct dependencies on other local packages
      *
@@ -468,12 +524,16 @@ class FynpoDepGraph {
         const depMapByPath = this.depMapByPath;
         const doResolve = (depData, deps, section) => {
             const { pkgInfo } = depData;
-            lodash_1.default.each(deps, (semver, name) => {
+            _.each(deps, (semver, name) => {
                 // dep is not a local package in the monorepo, nothing to do
                 /* istanbul ignore if */
                 if (!byName[name]) {
                     return;
                 }
+                // check if this dep should not be resolved as local package
+                if (this.checkNoFynLocal(pkgInfo, name)) {
+                    return;
+                }
                 const semId = pkgId(name, semver);
                 const resolveId = this.resolvedCache[semId];
                 const depPkg = (resolveId && byId[resolveId]) || resolvePackage(semver, byName[name]);
@@ -551,7 +611,7 @@ class FynpoDepGraph {
             }
             return true;
         }
-        return !lodash_1.default.isEmpty(dataDep.pathOfCirculars);
+        return !_.isEmpty(dataDep.pathOfCirculars);
     }
     /**
      * Add depdencies from a list of dep relations
@@ -605,7 +665,7 @@ class FynpoDepGraph {
      * @param dir - directory of package to get
      */
     getPackageAtDir(dir) {
-        const path = (0, util_1.posixify)(path_1.default.isAbsolute(dir) ? path_1.default.relative(this._options.cwd, dir) : dir);
+        const path = posixify(Path.isAbsolute(dir) ? Path.relative(this._options.cwd, dir) : dir);
         return this.packages.byPath[path];
     }
     /**
@@ -614,7 +674,7 @@ class FynpoDepGraph {
      * @returns
      */
     getPackageByName(name) {
-        return lodash_1.default.first(this.packages.byName[name]);
+        return _.first(this.packages.byName[name]);
     }
     /**
      * Figure out all the packages' indirect dependencies on other local packages
@@ -628,7 +688,7 @@ class FynpoDepGraph {
         const doResolve = (dataPkg, localDeps, steps, section) => {
             const { pkgInfo } = dataPkg;
             // go through all found deps
-            lodash_1.default.each(localDeps, (depRef) => {
+            _.each(localDeps, (depRef) => {
                 const sec = section || depRef.depSection;
                 const depInfo = byPath[depRef.path];
                 const dataDep = depMapByPath[depRef.path];
@@ -654,10 +714,8 @@ class FynpoDepGraph {
             doResolve(depData, depData.localDepsByPath, [pkgInfoId(depData.pkgInfo)]);
         }
         if (change > 0) {
-            (0, assert_1.default)(nestedLevel < 50, "FynpoDepGraph.resolveIndirectDeps nested too deep - there may be circular deps that's not detected");
+            assert(nestedLevel < 50, "FynpoDepGraph.resolveIndirectDeps nested too deep - there may be circular deps that's not detected");
             this.resolveIndirectDeps(nestedLevel + 1);
         }
     }
 }
-exports.FynpoDepGraph = FynpoDepGraph;
-//# sourceMappingURL=fynpo-dep-graph.js.map

package/dist/gitignore.d.ts

@@ -0,0 +1,17 @@
+/** matches paths against a repo's gitignore rules */
+export type GitignoreMatcher = {
+    /** true if the given repo-relative path is ignored by git */
+    ignores(relPath: string): boolean;
+    /** true if any rule was actually loaded - false means every check is a no-op */
+    hasRules: boolean;
+};
+/**
+ * Build a gitignore matcher for a repo root.
+ *
+ * Never throws for a missing or unreadable ignore file - a repo with no rules simply matches
+ * nothing.
+ *
+ * @param cwd - repo root to read ignore rules from
+ * @returns a matcher; {@link GitignoreMatcher.hasRules} is false when nothing was loaded
+ */
+export declare function makeGitignoreMatcher(cwd: string): GitignoreMatcher;

package/dist/gitignore.js

@@ -0,0 +1,67 @@
+import Fs from "fs";
+import Path from "path";
+import ignore from "ignore";
+//
+// Gitignore matching, used for two separate things (FPO-17):
+//
+// 1. `packages.autoSearch.respectGitignore` - opt-in, default off. When on, auto-search skips
+//    gitignored paths.
+// 2. The publish veto - ALWAYS on. A gitignored package is never in publish jurisdiction, even
+//    when respectGitignore is off and even if `publishInclude` names it. A gitignored package
+//    is typically a nested clone of some other repo; publishing it from here is never right.
+//
+// Because of (2) the matcher is built regardless of the flag. In a directory with no gitignore
+// rules - or no git at all - nothing matches and both behaviors are no-ops.
+//
+// Scope: the repo root `.gitignore` and `.git/info/exclude`. Nested `.gitignore` files deeper
+// in the tree are NOT consulted, nor is the user's global excludesfile. That covers the case
+// this exists for (a top-level ignored directory holding cloned repos) without shelling out to
+// git, at the cost of missing rules declared further down.
+//
+const IGNORE_SOURCES = [".gitignore", Path.join(".git", "info", "exclude")];
+const NO_RULES = {
+    ignores: () => false,
+    hasRules: false,
+};
+const readIfPresent = (file) => {
+    try {
+        return Fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if ((err === null || err === void 0 ? void 0 : err.code) !== "ENOENT" && (err === null || err === void 0 ? void 0 : err.code) !== "ENOTDIR") {
+            throw err;
+        }
+        return undefined;
+    }
+};
+/**
+ * Build a gitignore matcher for a repo root.
+ *
+ * Never throws for a missing or unreadable ignore file - a repo with no rules simply matches
+ * nothing.
+ *
+ * @param cwd - repo root to read ignore rules from
+ * @returns a matcher; {@link GitignoreMatcher.hasRules} is false when nothing was loaded
+ */
+export function makeGitignoreMatcher(cwd) {
+    const sources = IGNORE_SOURCES.map((f) => readIfPresent(Path.join(cwd, f))).filter(Boolean);
+    if (sources.length === 0) {
+        return NO_RULES;
+    }
+    const ig = ignore().add(sources.join("\n"));
+    return {
+        hasRules: true,
+        ignores(relPath) {
+            // `ignore` rejects absolute paths and anything outside the root, and refuses "."
+            if (!relPath || relPath === "." || Path.isAbsolute(relPath)) {
+                return false;
+            }
+            // it wants posix separators relative to the root
+            const normalized = relPath.split(Path.sep).join("/").replace(/^\.\//, "");
+            if (!normalized || normalized.startsWith("..")) {
+                return false;
+            }
+            return ig.ignores(normalized);
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export * from "./fynpo-dep-graph";
-export * from "./fynpo-config";
-export * from "./util";
-export * as caching from "./caching";
+export * from "./fynpo-dep-graph.js";
+export * from "./fynpo-config.js";
+export * from "./packages-config.js";
+export * from "./gitignore.js";
+export * from "./util.js";
+export * as caching from "./caching.js";
 /**
  * Information about a package within the mono-repo
  */
@@ -57,12 +59,19 @@ export type PackageInfo = {
 /**
  * Read the packages of a fynpo mono-repo
  *
- * @param patterns - array of minimatch patterns.  default: `["packages/*"]`
+ * Honors the same `packages` config as {@link FynpoDepGraph}, so both discovery paths agree.
+ * Passing `patterns` directly still works and takes precedence, for callers that already know
+ * what they want.
+ *
+ * @param patterns - explicit minimatch patterns. Overrides whatever `packages` config says.
+ * @param cwd - repo root
+ * @param packages - raw `packages` config, resolved via {@link resolvePackagesConfig}
  * @returns - packages from the fynpo mono-repo
  */
-export declare function readFynpoPackages({ patterns, cwd, }?: {
+export declare function readFynpoPackages({ patterns, cwd, packages, }?: {
     patterns?: string[];
     cwd?: string;
+    packages?: unknown;
 }): Promise<Record<string, PackageInfo>>;
 /**
  * calculate dep graphs for packages under the mono-repo
@@ -73,7 +82,9 @@ export declare function readFynpoPackages({ patterns, cwd, }?: {
  */
 export declare function makePkgDeps(packages: any, opts: any): {
     packages: any;
-    depMap: any;
+    depMap: {
+        [x: string]: Pick<any, string>;
+    };
     circulars: any[];
     warnings: any[];
     only: any;