@dbx-tools/path 0.3.44 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * as find from "./src/find.js";
+export * as ignore from "./src/ignore.js";
+export * as match from "./src/match.js";
+export * as pattern from "./src/pattern.js";
+export * as scan from "./src/scan.js";
+export * as watch from "./src/watch.js";
+export { findFiles } from "./src/find.js";
+export type { FileFindOptions } from "./src/find.js";
+export { ignorePatterns, ignorePathMatcher } from "./src/ignore.js";
+export type { IgnorePatternOptions } from "./src/ignore.js";
+export { pathMatchTests, toPathMatcher } from "./src/match.js";
+export type { PathMatchPredicate, PathMatcher, PathMatchInput } from "./src/match.js";
+export { directoryNamePattern, fileExtensionPattern } from "./src/pattern.js";
+export { FOLLOW_SYMLINKS_DEFAULT } from "./src/scan.js";
+export type { FileScanOptions, FileScanIgnoreOptions } from "./src/scan.js";
+export { watchFiles } from "./src/watch.js";
+export type { FileWatchOptions } from "./src/watch.js";

package/lib/index.js

@@ -0,0 +1,16 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as find from "./src/find.js";
+export * as ignore from "./src/ignore.js";
+export * as match from "./src/match.js";
+export * as pattern from "./src/pattern.js";
+export * as scan from "./src/scan.js";
+export * as watch from "./src/watch.js";
+export { findFiles } from "./src/find.js";
+export { ignorePatterns, ignorePathMatcher } from "./src/ignore.js";
+export { pathMatchTests, toPathMatcher } from "./src/match.js";
+export { directoryNamePattern, fileExtensionPattern } from "./src/pattern.js";
+export { FOLLOW_SYMLINKS_DEFAULT } from "./src/scan.js";
+export { watchFiles } from "./src/watch.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/find.d.ts

@@ -0,0 +1,17 @@
+import { type Sequence } from "@dbx-tools/shared-core";
+import { IgnoreLike, type GlobOptionsWithFileTypesUnset } from "glob";
+import { PathMatchInput } from "./match.js";
+import { FileScanOptions } from "./scan.js";
+type FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;
+export interface FileFindOptions extends Omit<GlobOptionsWithFileTypesUnset, "ignore" | "follow" | "dot" | "cwd" | "includeChildMatches">, Omit<FileScanOptions, "ignore" | "cwd"> {
+    cwd?: string | URL;
+    ignore?: FileFindIgnore;
+}
+/**
+ * Recursively lists files matching `pattern`, ignoring the shared default groups
+ * plus any caller `ignore` patterns (unless `ignore` is a lone predicate function,
+ * in which case only that predicate applies). The ignore list mirrors what
+ * {@link watchFiles} feeds through its matchers.
+ */
+export declare function findFiles(pattern: string | string[], options?: FileFindOptions): Sequence<string>;
+export {};

package/lib/src/find.js

@@ -0,0 +1,108 @@
+import { object } from "@dbx-tools/shared-core";
+import { globIterateSync } from "glob";
+import { ignorePathMatcher } from "./ignore.js";
+import { pathMatchTests, toPathMatcher } from "./match.js";
+import { FOLLOW_SYMLINKS_DEFAULT } from "./scan.js";
+/**
+ * Recursively lists files matching `pattern`, ignoring the shared default groups
+ * plus any caller `ignore` patterns (unless `ignore` is a lone predicate function,
+ * in which case only that predicate applies). The ignore list mirrors what
+ * {@link watchFiles} feeds through its matchers.
+ */
+export function findFiles(pattern, options) {
+    return object.sequence(globIterateSync(pattern, toGlobOptions(options)));
+}
+function toGlobOptions(options) {
+    const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};
+    return {
+        ...restOptions,
+        cwd: cwd ?? process.cwd(),
+        follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,
+        ignore: normalizeIgnore(ignore, ignoreOptions),
+    };
+}
+const IGNORE_LIKE_FIELDS = [
+    "ignored",
+    "childrenIgnored",
+    "add",
+];
+function isIgnoreLike(value) {
+    if (Array.isArray(value))
+        return false;
+    if (typeof value === "object" && value !== null) {
+        for (const field of IGNORE_LIKE_FIELDS) {
+            if (field in value && typeof value[field] !== "function") {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Builds the {@link IgnoreLike} object {@link findFiles} hands to `glob`.
+ *
+ * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted
+ * first - its `ignored`/`childrenIgnored` win - after which the shared
+ * {@link ignorePathMatcher} (the same matcher {@link watchFiles} uses) decides based on the
+ * package-relative path. `cacheDirectoryStats` is enabled because glob probes
+ * many paths per directory. Caller string/array patterns are merged into the
+ * matcher, and `add` forwards to both the caller object and the matcher.
+ */
+function normalizeIgnore(ignore, ignoreOptions) {
+    const ignoreLike = isIgnoreLike(ignore) ? ignore : undefined;
+    const ignorePathMatcherInputs = ignore === undefined || ignoreLike ? undefined : Array.isArray(ignore) ? [...ignore] : [ignore];
+    const predicateOnly = ignorePathMatcherInputs?.length === 1 && typeof ignorePathMatcherInputs[0] === "function";
+    let ignoreMatcher = predicateOnly
+        ? toPathMatcher(ignorePathMatcherInputs[0])
+        : ignorePathMatcher(ignoreOptions);
+    if (ignorePathMatcherInputs && !predicateOnly) {
+        ignoreMatcher = ignoreMatcher.or(...pathMatchTests(...ignorePathMatcherInputs));
+    }
+    return {
+        ignored(path) {
+            if (ignoreLike?.ignored?.(path))
+                return true;
+            const patheRelative = path.relative();
+            const ignore = ignoreMatcher(patheRelative);
+            return ignore;
+        },
+        childrenIgnored(path) {
+            if (ignoreLike?.childrenIgnored?.(path))
+                return true;
+            const patheRelative = path.relative();
+            if (patheRelative) {
+                if (ignoreMatcher(patheRelative)) {
+                    return true;
+                }
+                else if (ignoreMatcher(patheRelative + "/")) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        add(ignore) {
+            ignoreLike?.add?.(ignore);
+            ignoreMatcher = ignoreMatcher.and(...pathMatchTests(ignore));
+        },
+    };
+}
+// Manual demo: run this file directly (e.g. `tsx src/find.ts`) to print the
+// files findFiles keeps for this package under the given ignore options.
+if (import.meta.main) {
+    const startTime = performance.now();
+    const cwd = process.cwd();
+    console.log(`Scanning: ${cwd}`);
+    const files = findFiles("**/*.*", {
+        ignore: ["**/index.ts", "**/example/**", "**/*.md"],
+        ignoreOptions: {
+            test: true,
+        },
+    });
+    for (const file of files) {
+        console.log(file);
+    }
+    const elapsed = performance.now() - startTime;
+    console.log(`Elapsed: ${elapsed}ms`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find.js","sourceRoot":"","sources":["../../src/find.ts"],"names":[],"mappings":"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","sourcesContent":["import { object, type Sequence } from \"@dbx-tools/shared-core\";\nimport { globIterateSync, IgnoreLike, type GlobOptionsWithFileTypesUnset } from \"glob\";\nimport { ignorePathMatcher } from \"./ignore\";\nimport { PathMatcher, PathMatchInput, pathMatchTests, toPathMatcher } from \"./match\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan\";\n\ntype FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;\n\nexport interface FileFindOptions\n  extends\n    Omit<\n      GlobOptionsWithFileTypesUnset,\n      \"ignore\" | \"follow\" | \"dot\" | \"cwd\" | \"includeChildMatches\"\n    >,\n    Omit<FileScanOptions, \"ignore\" | \"cwd\"> {\n  cwd?: string | URL;\n  ignore?: FileFindIgnore;\n}\n/**\n * Recursively lists files matching `pattern`, ignoring the shared default groups\n * plus any caller `ignore` patterns (unless `ignore` is a lone predicate function,\n * in which case only that predicate applies). The ignore list mirrors what\n * {@link watchFiles} feeds through its matchers.\n */\nexport function findFiles(pattern: string | string[], options?: FileFindOptions): Sequence<string> {\n  return object.sequence(globIterateSync(pattern, toGlobOptions(options)));\n}\n\nfunction toGlobOptions(options: FileFindOptions | undefined): GlobOptionsWithFileTypesUnset {\n  const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};\n  return {\n    ...restOptions,\n    cwd: cwd ?? process.cwd(),\n    follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ignore: normalizeIgnore(ignore, ignoreOptions),\n  };\n}\n\nconst IGNORE_LIKE_FIELDS = [\n  \"ignored\",\n  \"childrenIgnored\",\n  \"add\",\n] as const satisfies readonly (keyof IgnoreLike)[];\n\nfunction isIgnoreLike(value: unknown): value is IgnoreLike {\n  if (Array.isArray(value)) return false;\n  if (typeof value === \"object\" && value !== null) {\n    for (const field of IGNORE_LIKE_FIELDS) {\n      if (field in value && typeof (value as any)[field] !== \"function\") {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n/**\n * Builds the {@link IgnoreLike} object {@link findFiles} hands to `glob`.\n *\n * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted\n * first - its `ignored`/`childrenIgnored` win - after which the shared\n * {@link ignorePathMatcher} (the same matcher {@link watchFiles} uses) decides based on the\n * package-relative path. `cacheDirectoryStats` is enabled because glob probes\n * many paths per directory. Caller string/array patterns are merged into the\n * matcher, and `add` forwards to both the caller object and the matcher.\n */\nfunction normalizeIgnore(\n  ignore: FileFindIgnore | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n): IgnoreLike {\n  const ignoreLike: IgnoreLike | undefined = isIgnoreLike(ignore) ? ignore : undefined;\n  const ignorePathMatcherInputs: PathMatchInput[] | undefined =\n    ignore === undefined || ignoreLike ? undefined : Array.isArray(ignore) ? [...ignore] : [ignore];\n\n  const predicateOnly =\n    ignorePathMatcherInputs?.length === 1 && typeof ignorePathMatcherInputs[0] === \"function\";\n\n  let ignoreMatcher: PathMatcher = predicateOnly\n    ? toPathMatcher(ignorePathMatcherInputs[0])\n    : ignorePathMatcher(ignoreOptions);\n  if (ignorePathMatcherInputs && !predicateOnly) {\n    ignoreMatcher = ignoreMatcher.or(...pathMatchTests(...ignorePathMatcherInputs));\n  }\n  return {\n    ignored(path) {\n      if (ignoreLike?.ignored?.(path)) return true;\n      const patheRelative = path.relative();\n      const ignore = ignoreMatcher(patheRelative);\n      return ignore;\n    },\n    childrenIgnored(path) {\n      if (ignoreLike?.childrenIgnored?.(path)) return true;\n      const patheRelative = path.relative();\n      if (patheRelative) {\n        if (ignoreMatcher(patheRelative)) {\n          return true;\n        } else if (ignoreMatcher(patheRelative + \"/\")) {\n          return true;\n        }\n      }\n      return false;\n    },\n    add(ignore) {\n      ignoreLike?.add?.(ignore);\n      ignoreMatcher = ignoreMatcher.and(...pathMatchTests(ignore));\n    },\n  };\n}\n\n// Manual demo: run this file directly (e.g. `tsx src/find.ts`) to print the\n// files findFiles keeps for this package under the given ignore options.\nif (import.meta.main) {\n  const startTime = performance.now();\n  const cwd = process.cwd();\n  console.log(`Scanning: ${cwd}`);\n\n  const files = findFiles(\"**/*.*\", {\n    ignore: [\"**/index.ts\", \"**/example/**\", \"**/*.md\"],\n    ignoreOptions: {\n      test: true,\n    },\n  });\n  for (const file of files) {\n    console.log(file);\n  }\n  const elapsed = performance.now() - startTime;\n  console.log(`Elapsed: ${elapsed}ms`);\n}\n"]}

package/lib/src/ignore.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Built-in ignore glob patterns for file scanning and watching.
+ *
+ * This module owns the pattern catalog and option toggles only. Each group is
+ * compiled into {@link PathMatchPredicate} instances via {@link toPathMatcher};
+ * composition (`and`/`or`/`negate`) lives in {@link ./match}.
+ *
+ * Consumers:
+ * - {@link ignorePatterns} - yields the enabled glob strings (for projen
+ *   prettier/gitignore). Pass `{ test: false }` there: the `test` group is for
+ *   filesystem scanning only (skip test dirs when discovering packages /
+ *   watching), not for VCS or formatter ignore files.
+ * - {@link ignorePathMatcher} - returns a single {@link PathMatcher} for
+ *   {@link findFiles} and {@link watchFiles} (keeps `test: true` by default).
+ *
+ * @module
+ */
+import { type Sequence } from "@dbx-tools/shared-core";
+import { PathMatcher } from "./match.js";
+/** Toggles for each built-in ignore group; omitted flags default to `true`. */
+export type IgnorePatternOptions = {
+    /** Build artifacts, dependency dirs, caches, logs, and OS junk files. */
+    defaults?: boolean;
+    /** Hidden dot-files and dot-directories (`.git`, `.vscode`, `.gitignore`, etc.). */
+    dot?: boolean;
+    /** Temporary directories (`tmp`, `.tmp`, `scratch`, etc.). */
+    temp?: boolean;
+    /**
+     * Test directories and `*.test.*` / `*.spec.*` naming conventions.
+     * Scanning/watch default on; omit (`false`) when emitting `.gitignore` /
+     * `.prettierignore` so tests stay tracked and formatable.
+     */
+    test?: boolean;
+    /**
+     * Lockfile ignore group (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`,
+     * `bun.lockb`, etc.).
+     *
+     * - `true` - always ignore lockfiles.
+     * - `false` - never ignore lockfiles.
+     * - `"auto"` (default) - ignore when the active npm registry is not the public
+     *   npm registry (`registry.npmjs.org`), e.g. a company-internal registry.
+     */
+    lock?: boolean | "auto";
+};
+/**
+ * Yields the glob strings for each enabled built-in ignore group.
+ *
+ * Useful when a consumer needs literal patterns (e.g. projen `.gitignore` /
+ * `.prettierignore`) rather than a compiled {@link PathMatcher}. For those
+ * file emitters pass `{ test: false }` - the test group belongs to scanning
+ * only ({@link ignorePathMatcher}), not VCS/formatter ignores.
+ *
+ * @param options - Group toggles; omitted flags default to enabled.
+ */
+export declare function ignorePatterns(options?: IgnorePatternOptions): Sequence<string>;
+/**
+ * Returns a {@link PathMatcher} for paths ignored by the enabled built-in groups.
+ *
+ * Matchers for each group are compiled once at module load; `options` only
+ * selects which groups participate. The lock group is included when
+ * {@link lockIgnoreMatchersEnabled} returns `true`.
+ *
+ * @param options - Group toggles; omitted flags default to enabled.
+ */
+export declare function ignorePathMatcher(options?: IgnorePatternOptions): PathMatcher;

package/lib/src/ignore.js

@@ -0,0 +1,147 @@
+/**
+ * Built-in ignore glob patterns for file scanning and watching.
+ *
+ * This module owns the pattern catalog and option toggles only. Each group is
+ * compiled into {@link PathMatchPredicate} instances via {@link toPathMatcher};
+ * composition (`and`/`or`/`negate`) lives in {@link ./match}.
+ *
+ * Consumers:
+ * - {@link ignorePatterns} - yields the enabled glob strings (for projen
+ *   prettier/gitignore). Pass `{ test: false }` there: the `test` group is for
+ *   filesystem scanning only (skip test dirs when discovering packages /
+ *   watching), not for VCS or formatter ignore files.
+ * - {@link ignorePathMatcher} - returns a single {@link PathMatcher} for
+ *   {@link findFiles} and {@link watchFiles} (keeps `test: true` by default).
+ *
+ * @module
+ */
+import { project } from "@dbx-tools/core";
+import { functionModule, object } from "@dbx-tools/shared-core";
+import { toPathMatcher } from "./match.js";
+import { directoryNamePattern, fileExtensionPattern } from "./pattern.js";
+/** Host of the public npm registry; anything else is treated as private. */
+const PUBLIC_NPM_REGISTRY_HOST = "registry.npmjs.org";
+/**
+ * Memoized probe for {@link IgnorePatternOptions.lock} `"auto"`.
+ *
+ * Resolves the active registry through `@dbx-tools/core`'s
+ * {@link project.npmRegistry} and returns `true` when it is not the public npm
+ * registry - a lockfile produced against a private mirror pins URLs that other
+ * machines cannot reach, so it should not be committed.
+ */
+const lockIgnoreMatchersAutoEnabled = functionModule.memoize(() => {
+    const registry = project.npmRegistry();
+    return registry !== undefined && registry.hostname !== PUBLIC_NPM_REGISTRY_HOST;
+});
+/** Resolves whether the lockfile ignore group is enabled for the given options. */
+function lockIgnoreMatchersEnabled(options) {
+    const value = options?.lock ?? "auto";
+    if (value === "auto") {
+        return lockIgnoreMatchersAutoEnabled();
+    }
+    return value;
+}
+/**
+ * Compiles glob strings into a `{ [glob]: PathMatchPredicate }` map.
+ *
+ * Keying by the source glob de-dupes and keeps each matcher beside its pattern.
+ */
+function compileMatchers(patterns) {
+    return Object.fromEntries(patterns.map((glob) => [glob, toPathMatcher(glob)]));
+}
+/** Build artifacts, dependency directories, caches, logs, and OS files. */
+const defaultIgnoreMatchers = compileMatchers([
+    "**/.DS_Store",
+    "**/Thumbs.db",
+    "**/Desktop.ini",
+    ...["log", "tsbuildinfo"].map((ext) => fileExtensionPattern(ext)),
+    "**/*-debug.log*",
+    "**/yarn-error.log*",
+    ...[
+        "node_modules",
+        "bower_components",
+        "jspm_packages",
+        "dist",
+        "lib",
+        "build",
+        "out",
+        "coverage",
+        ".cache",
+        ".parcel-cache",
+        ".turbo",
+        ".next",
+        ".nuxt",
+        ".svelte-kit",
+        ".pnpm-store",
+        ".nyc_output",
+    ].map((name) => directoryNamePattern(name)),
+]);
+/** Hidden dot-files and dot-directories such as `.git`, `.vscode`, `.idea`, etc. */
+const dotIgnoreMatchers = compileMatchers([".*"].flatMap((glob) => [`**/${glob}`, directoryNamePattern(glob, false)]));
+/** Temporary directories, including hidden variants (`.tmp`, etc.). */
+const tempIgnoreMatchers = compileMatchers(["temp", "tmp", "temps", "scratch"]
+    .flatMap((name) => [name, `.${name}`])
+    .map((name) => directoryNamePattern(name)));
+/** Test directories and common test-file naming conventions. */
+const testIgnoreMatchers = compileMatchers([
+    ...["test", "tests", "__tests__", "__snapshots__"]
+        .flatMap((name) => [name, `.${name}`])
+        .map((name) => directoryNamePattern(name)),
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/test.*",
+    "**/spec.*",
+]);
+/** Lockfiles (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`, `bun.lockb`, …). */
+const lockIgnoreMatchers = compileMatchers([
+    "**/bun.lockb",
+    ...["json", "yaml", "yml"].map((ext) => `**/*-lock.${ext}`),
+    ...["lock"].map((ext) => fileExtensionPattern(ext)),
+]);
+/**
+ * Collects the pre-compiled matcher maps for each enabled built-in group.
+ *
+ * Group toggles come from `options`; the lock group also respects
+ * {@link lockIgnoreMatchersEnabled} (`lock: "auto"` probes the npm registry).
+ */
+function ignoreMatchPredicates(options) {
+    const ignoreMatchRecords = [];
+    if (options?.defaults ?? true)
+        ignoreMatchRecords.push(defaultIgnoreMatchers);
+    if (options?.temp ?? true)
+        ignoreMatchRecords.push(tempIgnoreMatchers);
+    if (options?.test ?? true)
+        ignoreMatchRecords.push(testIgnoreMatchers);
+    if (options?.dot ?? true)
+        ignoreMatchRecords.push(dotIgnoreMatchers);
+    if (lockIgnoreMatchersEnabled(options))
+        ignoreMatchRecords.push(lockIgnoreMatchers);
+    return ignoreMatchRecords;
+}
+/**
+ * Yields the glob strings for each enabled built-in ignore group.
+ *
+ * Useful when a consumer needs literal patterns (e.g. projen `.gitignore` /
+ * `.prettierignore`) rather than a compiled {@link PathMatcher}. For those
+ * file emitters pass `{ test: false }` - the test group belongs to scanning
+ * only ({@link ignorePathMatcher}), not VCS/formatter ignores.
+ *
+ * @param options - Group toggles; omitted flags default to enabled.
+ */
+export function ignorePatterns(options) {
+    return object.sequence(ignoreMatchPredicates(options)).flatMap(Object.keys).distinct();
+}
+/**
+ * Returns a {@link PathMatcher} for paths ignored by the enabled built-in groups.
+ *
+ * Matchers for each group are compiled once at module load; `options` only
+ * selects which groups participate. The lock group is included when
+ * {@link lockIgnoreMatchersEnabled} returns `true`.
+ *
+ * @param options - Group toggles; omitted flags default to enabled.
+ */
+export function ignorePathMatcher(options) {
+    const predicates = ignoreMatchPredicates(options).flatMap(Object.values);
+    return toPathMatcher(...predicates);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ignore.js","sourceRoot":"","sources":["../../src/ignore.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Built-in ignore glob patterns for file scanning and watching.\n *\n * This module owns the pattern catalog and option toggles only. Each group is\n * compiled into {@link PathMatchPredicate} instances via {@link toPathMatcher};\n * composition (`and`/`or`/`negate`) lives in {@link ./match}.\n *\n * Consumers:\n * - {@link ignorePatterns} - yields the enabled glob strings (for projen\n *   prettier/gitignore). Pass `{ test: false }` there: the `test` group is for\n *   filesystem scanning only (skip test dirs when discovering packages /\n *   watching), not for VCS or formatter ignore files.\n * - {@link ignorePathMatcher} - returns a single {@link PathMatcher} for\n *   {@link findFiles} and {@link watchFiles} (keeps `test: true` by default).\n *\n * @module\n */\n\nimport { project } from \"@dbx-tools/core\";\nimport { functionModule, object, type Sequence } from \"@dbx-tools/shared-core\";\nimport { PathMatcher, PathMatchPredicate, toPathMatcher } from \"./match\";\nimport { directoryNamePattern, fileExtensionPattern } from \"./pattern\";\n\n/** Toggles for each built-in ignore group; omitted flags default to `true`. */\nexport type IgnorePatternOptions = {\n  /** Build artifacts, dependency dirs, caches, logs, and OS junk files. */\n  defaults?: boolean;\n  /** Hidden dot-files and dot-directories (`.git`, `.vscode`, `.gitignore`, etc.). */\n  dot?: boolean;\n  /** Temporary directories (`tmp`, `.tmp`, `scratch`, etc.). */\n  temp?: boolean;\n  /**\n   * Test directories and `*.test.*` / `*.spec.*` naming conventions.\n   * Scanning/watch default on; omit (`false`) when emitting `.gitignore` /\n   * `.prettierignore` so tests stay tracked and formatable.\n   */\n  test?: boolean;\n  /**\n   * Lockfile ignore group (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`,\n   * `bun.lockb`, etc.).\n   *\n   * - `true` - always ignore lockfiles.\n   * - `false` - never ignore lockfiles.\n   * - `\"auto\"` (default) - ignore when the active npm registry is not the public\n   *   npm registry (`registry.npmjs.org`), e.g. a company-internal registry.\n   */\n  lock?: boolean | \"auto\";\n};\n\n/** Host of the public npm registry; anything else is treated as private. */\nconst PUBLIC_NPM_REGISTRY_HOST = \"registry.npmjs.org\";\n\n/**\n * Memoized probe for {@link IgnorePatternOptions.lock} `\"auto\"`.\n *\n * Resolves the active registry through `@dbx-tools/core`'s\n * {@link project.npmRegistry} and returns `true` when it is not the public npm\n * registry - a lockfile produced against a private mirror pins URLs that other\n * machines cannot reach, so it should not be committed.\n */\nconst lockIgnoreMatchersAutoEnabled = functionModule.memoize(() => {\n  const registry = project.npmRegistry();\n  return registry !== undefined && registry.hostname !== PUBLIC_NPM_REGISTRY_HOST;\n});\n\n/** Resolves whether the lockfile ignore group is enabled for the given options. */\nfunction lockIgnoreMatchersEnabled(options?: IgnorePatternOptions): boolean {\n  const value = options?.lock ?? \"auto\";\n  if (value === \"auto\") {\n    return lockIgnoreMatchersAutoEnabled();\n  }\n  return value;\n}\n\n/**\n * Compiles glob strings into a `{ [glob]: PathMatchPredicate }` map.\n *\n * Keying by the source glob de-dupes and keeps each matcher beside its pattern.\n */\nfunction compileMatchers(patterns: readonly string[]): Record<string, PathMatchPredicate> {\n  return Object.fromEntries(patterns.map((glob) => [glob, toPathMatcher(glob)]));\n}\n\n/** Build artifacts, dependency directories, caches, logs, and OS files. */\nconst defaultIgnoreMatchers = compileMatchers([\n  \"**/.DS_Store\",\n  \"**/Thumbs.db\",\n  \"**/Desktop.ini\",\n  ...[\"log\", \"tsbuildinfo\"].map((ext) => fileExtensionPattern(ext)),\n  \"**/*-debug.log*\",\n  \"**/yarn-error.log*\",\n  ...[\n    \"node_modules\",\n    \"bower_components\",\n    \"jspm_packages\",\n    \"dist\",\n    \"lib\",\n    \"build\",\n    \"out\",\n    \"coverage\",\n    \".cache\",\n    \".parcel-cache\",\n    \".turbo\",\n    \".next\",\n    \".nuxt\",\n    \".svelte-kit\",\n    \".pnpm-store\",\n    \".nyc_output\",\n  ].map((name) => directoryNamePattern(name)),\n]);\n\n/** Hidden dot-files and dot-directories such as `.git`, `.vscode`, `.idea`, etc. */\nconst dotIgnoreMatchers = compileMatchers(\n  [\".*\"].flatMap((glob) => [`**/${glob}`, directoryNamePattern(glob, false)]),\n);\n\n/** Temporary directories, including hidden variants (`.tmp`, etc.). */\nconst tempIgnoreMatchers = compileMatchers(\n  [\"temp\", \"tmp\", \"temps\", \"scratch\"]\n    .flatMap((name) => [name, `.${name}`])\n    .map((name) => directoryNamePattern(name)),\n);\n\n/** Test directories and common test-file naming conventions. */\nconst testIgnoreMatchers = compileMatchers([\n  ...[\"test\", \"tests\", \"__tests__\", \"__snapshots__\"]\n    .flatMap((name) => [name, `.${name}`])\n    .map((name) => directoryNamePattern(name)),\n  \"**/*.test.*\",\n  \"**/*.spec.*\",\n  \"**/test.*\",\n  \"**/spec.*\",\n]);\n\n/** Lockfiles (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`, `bun.lockb`, …). */\nconst lockIgnoreMatchers = compileMatchers([\n  \"**/bun.lockb\",\n  ...[\"json\", \"yaml\", \"yml\"].map((ext) => `**/*-lock.${ext}`),\n  ...[\"lock\"].map((ext) => fileExtensionPattern(ext)),\n]);\n\n/**\n * Collects the pre-compiled matcher maps for each enabled built-in group.\n *\n * Group toggles come from `options`; the lock group also respects\n * {@link lockIgnoreMatchersEnabled} (`lock: \"auto\"` probes the npm registry).\n */\nfunction ignoreMatchPredicates(\n  options?: IgnorePatternOptions,\n): Record<string, PathMatchPredicate>[] {\n  const ignoreMatchRecords: Record<string, PathMatchPredicate>[] = [];\n  if (options?.defaults ?? true) ignoreMatchRecords.push(defaultIgnoreMatchers);\n  if (options?.temp ?? true) ignoreMatchRecords.push(tempIgnoreMatchers);\n  if (options?.test ?? true) ignoreMatchRecords.push(testIgnoreMatchers);\n  if (options?.dot ?? true) ignoreMatchRecords.push(dotIgnoreMatchers);\n  if (lockIgnoreMatchersEnabled(options)) ignoreMatchRecords.push(lockIgnoreMatchers);\n  return ignoreMatchRecords;\n}\n\n/**\n * Yields the glob strings for each enabled built-in ignore group.\n *\n * Useful when a consumer needs literal patterns (e.g. projen `.gitignore` /\n * `.prettierignore`) rather than a compiled {@link PathMatcher}. For those\n * file emitters pass `{ test: false }` - the test group belongs to scanning\n * only ({@link ignorePathMatcher}), not VCS/formatter ignores.\n *\n * @param options - Group toggles; omitted flags default to enabled.\n */\nexport function ignorePatterns(options?: IgnorePatternOptions): Sequence<string> {\n  return object.sequence(ignoreMatchPredicates(options)).flatMap(Object.keys).distinct();\n}\n\n/**\n * Returns a {@link PathMatcher} for paths ignored by the enabled built-in groups.\n *\n * Matchers for each group are compiled once at module load; `options` only\n * selects which groups participate. The lock group is included when\n * {@link lockIgnoreMatchersEnabled} returns `true`.\n *\n * @param options - Group toggles; omitted flags default to enabled.\n */\nexport function ignorePathMatcher(options?: IgnorePatternOptions): PathMatcher {\n  const predicates = ignoreMatchPredicates(options).flatMap(Object.values);\n  return toPathMatcher(...predicates);\n}\n"]}

package/lib/src/match.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Path matching and predicate composition for file scanning and watching.
+ *
+ * {@link toPathMatcher} compiles globs into {@link Predicate} values from
+ * shared-core (`and` / `or` / `negate`) for use by {@link findFiles} and
+ * {@link watchFiles}.
+ *
+ * @module
+ */
+import { type Predicate, type PredicateFunction } from "@dbx-tools/shared-core";
+export type PathMatchPredicate = PredicateFunction<string>;
+/** A composable path test (`true` == match). */
+export type PathMatcher = Predicate<string>;
+/**
+ * Anything {@link toPathMatcher} accepts: a glob string (compiled with
+ * `dot: true`), or a custom `(path) => boolean`.
+ */
+export type PathMatchInput = PathMatchPredicate | string;
+/** Compiles path match inputs to predicate functions for `.and()` / `.or()`. */
+export declare function pathMatchTests(...inputs: readonly (PathMatchInput | null | undefined)[]): readonly PathMatchPredicate[];
+/**
+ * Combines one or more patterns into a single {@link PathMatcher} (OR'd).
+ * Strings are compiled with `dot: true`; predicates are used as-is;
+ * `null`/`undefined` entries are skipped. With no matching patterns the result
+ * always returns `false`.
+ *
+ * @param patterns - Globs and/or predicates to OR together.
+ */
+export declare function toPathMatcher(...inputs: readonly (PathMatchInput | null | undefined)[]): PathMatcher;

package/lib/src/match.js

@@ -0,0 +1,48 @@
+/**
+ * Path matching and predicate composition for file scanning and watching.
+ *
+ * {@link toPathMatcher} compiles globs into {@link Predicate} values from
+ * shared-core (`and` / `or` / `negate`) for use by {@link findFiles} and
+ * {@link watchFiles}.
+ *
+ * @module
+ */
+import { object, predicate } from "@dbx-tools/shared-core";
+import { Minimatch } from "minimatch";
+import { ignorePathMatcher } from "./ignore.js";
+/** Normalizes a {@link PathMatchInput} to a plain path test. */
+function toTest(pattern) {
+    if (typeof pattern === "string") {
+        const matcher = new Minimatch(pattern, { dot: true });
+        return (path) => matcher.match(path);
+    }
+    return pattern;
+}
+/** Compiles path match inputs to predicate functions for `.and()` / `.or()`. */
+export function pathMatchTests(...inputs) {
+    return object.sequence(inputs).nonNull().map(toTest).toArray();
+}
+/**
+ * Combines one or more patterns into a single {@link PathMatcher} (OR'd).
+ * Strings are compiled with `dot: true`; predicates are used as-is;
+ * `null`/`undefined` entries are skipped. With no matching patterns the result
+ * always returns `false`.
+ *
+ * @param patterns - Globs and/or predicates to OR together.
+ */
+export function toPathMatcher(...inputs) {
+    const tests = pathMatchTests(...inputs);
+    if (tests.length === 0)
+        return predicate.create(() => false);
+    return tests
+        .slice(1)
+        .reduce((acc, test) => acc.or(test), predicate.create(tests[0]));
+}
+if (import.meta.main) {
+    const matcher = ignorePathMatcher({ test: true })
+        .negate()
+        .and(...pathMatchTests("**/cool.ts", "**/wow.ts"));
+    console.log(matcher("packages/node/file-scan/src/cool.ts"));
+    console.log(matcher("packages/node/file-scan/.src/cool.ts"));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWF0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBMEMsTUFBTSx3QkFBd0IsQ0FBQztBQUNuRyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQWE3QyxnRUFBZ0U7QUFDaEUsU0FBUyxNQUFNLENBQUMsT0FBdUI7SUFDckMsSUFBSSxPQUFPLE9BQU8sS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUNoQyxNQUFNLE9BQU8sR0FBRyxJQUFJLFNBQVMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN0RCxPQUFPLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFDRCxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDO0FBRUQsZ0ZBQWdGO0FBQ2hGLE1BQU0sVUFBVSxjQUFjLENBQzVCLEdBQUcsTUFBc0Q7SUFFekQsT0FBTyxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztBQUNqRSxDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxhQUFhLENBQzNCLEdBQUcsTUFBc0Q7SUFFekQsTUFBTSxLQUFLLEdBQUcsY0FBYyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUM7SUFDeEMsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUM7UUFBRSxPQUFPLFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDN0QsT0FBTyxLQUFLO1NBQ1QsS0FBSyxDQUFDLENBQUMsQ0FBQztTQUNSLE1BQU0sQ0FBYyxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEVBQUUsU0FBUyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ25GLENBQUM7QUFFRCxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDckIsTUFBTSxPQUFPLEdBQUcsaUJBQWlCLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUM7U0FDOUMsTUFBTSxFQUFFO1NBQ1IsR0FBRyxDQUFDLEdBQUcsY0FBYyxDQUFDLFlBQVksRUFBRSxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBQ3JELE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLHFDQUFxQyxDQUFDLENBQUMsQ0FBQztJQUM1RCxPQUFPLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDLENBQUM7QUFDL0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUGF0aCBtYXRjaGluZyBhbmQgcHJlZGljYXRlIGNvbXBvc2l0aW9uIGZvciBmaWxlIHNjYW5uaW5nIGFuZCB3YXRjaGluZy5cbiAqXG4gKiB7QGxpbmsgdG9QYXRoTWF0Y2hlcn0gY29tcGlsZXMgZ2xvYnMgaW50byB7QGxpbmsgUHJlZGljYXRlfSB2YWx1ZXMgZnJvbVxuICogc2hhcmVkLWNvcmUgKGBhbmRgIC8gYG9yYCAvIGBuZWdhdGVgKSBmb3IgdXNlIGJ5IHtAbGluayBmaW5kRmlsZXN9IGFuZFxuICoge0BsaW5rIHdhdGNoRmlsZXN9LlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQgeyBvYmplY3QsIHByZWRpY2F0ZSwgdHlwZSBQcmVkaWNhdGUsIHR5cGUgUHJlZGljYXRlRnVuY3Rpb24gfSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtY29yZVwiO1xuaW1wb3J0IHsgTWluaW1hdGNoIH0gZnJvbSBcIm1pbmltYXRjaFwiO1xuaW1wb3J0IHsgaWdub3JlUGF0aE1hdGNoZXIgfSBmcm9tIFwiLi9pZ25vcmVcIjtcblxuZXhwb3J0IHR5cGUgUGF0aE1hdGNoUHJlZGljYXRlID0gUHJlZGljYXRlRnVuY3Rpb248c3RyaW5nPjtcblxuLyoqIEEgY29tcG9zYWJsZSBwYXRoIHRlc3QgKGB0cnVlYCA9PSBtYXRjaCkuICovXG5leHBvcnQgdHlwZSBQYXRoTWF0Y2hlciA9IFByZWRpY2F0ZTxzdHJpbmc+O1xuXG4vKipcbiAqIEFueXRoaW5nIHtAbGluayB0b1BhdGhNYXRjaGVyfSBhY2NlcHRzOiBhIGdsb2Igc3RyaW5nIChjb21waWxlZCB3aXRoXG4gKiBgZG90OiB0cnVlYCksIG9yIGEgY3VzdG9tIGAocGF0aCkgPT4gYm9vbGVhbmAuXG4gKi9cbmV4cG9ydCB0eXBlIFBhdGhNYXRjaElucHV0ID0gUGF0aE1hdGNoUHJlZGljYXRlIHwgc3RyaW5nO1xuXG4vKiogTm9ybWFsaXplcyBhIHtAbGluayBQYXRoTWF0Y2hJbnB1dH0gdG8gYSBwbGFpbiBwYXRoIHRlc3QuICovXG5mdW5jdGlvbiB0b1Rlc3QocGF0dGVybjogUGF0aE1hdGNoSW5wdXQpOiBQYXRoTWF0Y2hQcmVkaWNhdGUge1xuICBpZiAodHlwZW9mIHBhdHRlcm4gPT09IFwic3RyaW5nXCIpIHtcbiAgICBjb25zdCBtYXRjaGVyID0gbmV3IE1pbmltYXRjaChwYXR0ZXJuLCB7IGRvdDogdHJ1ZSB9KTtcbiAgICByZXR1cm4gKHBhdGgpID0+IG1hdGNoZXIubWF0Y2gocGF0aCk7XG4gIH1cbiAgcmV0dXJuIHBhdHRlcm47XG59XG5cbi8qKiBDb21waWxlcyBwYXRoIG1hdGNoIGlucHV0cyB0byBwcmVkaWNhdGUgZnVuY3Rpb25zIGZvciBgLmFuZCgpYCAvIGAub3IoKWAuICovXG5leHBvcnQgZnVuY3Rpb24gcGF0aE1hdGNoVGVzdHMoXG4gIC4uLmlucHV0czogcmVhZG9ubHkgKFBhdGhNYXRjaElucHV0IHwgbnVsbCB8IHVuZGVmaW5lZClbXVxuKTogcmVhZG9ubHkgUGF0aE1hdGNoUHJlZGljYXRlW10ge1xuICByZXR1cm4gb2JqZWN0LnNlcXVlbmNlKGlucHV0cykubm9uTnVsbCgpLm1hcCh0b1Rlc3QpLnRvQXJyYXkoKTtcbn1cblxuLyoqXG4gKiBDb21iaW5lcyBvbmUgb3IgbW9yZSBwYXR0ZXJucyBpbnRvIGEgc2luZ2xlIHtAbGluayBQYXRoTWF0Y2hlcn0gKE9SJ2QpLlxuICogU3RyaW5ncyBhcmUgY29tcGlsZWQgd2l0aCBgZG90OiB0cnVlYDsgcHJlZGljYXRlcyBhcmUgdXNlZCBhcy1pcztcbiAqIGBudWxsYC9gdW5kZWZpbmVkYCBlbnRyaWVzIGFyZSBza2lwcGVkLiBXaXRoIG5vIG1hdGNoaW5nIHBhdHRlcm5zIHRoZSByZXN1bHRcbiAqIGFsd2F5cyByZXR1cm5zIGBmYWxzZWAuXG4gKlxuICogQHBhcmFtIHBhdHRlcm5zIC0gR2xvYnMgYW5kL29yIHByZWRpY2F0ZXMgdG8gT1IgdG9nZXRoZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b1BhdGhNYXRjaGVyKFxuICAuLi5pbnB1dHM6IHJlYWRvbmx5IChQYXRoTWF0Y2hJbnB1dCB8IG51bGwgfCB1bmRlZmluZWQpW11cbik6IFBhdGhNYXRjaGVyIHtcbiAgY29uc3QgdGVzdHMgPSBwYXRoTWF0Y2hUZXN0cyguLi5pbnB1dHMpO1xuICBpZiAodGVzdHMubGVuZ3RoID09PSAwKSByZXR1cm4gcHJlZGljYXRlLmNyZWF0ZSgoKSA9PiBmYWxzZSk7XG4gIHJldHVybiB0ZXN0c1xuICAgIC5zbGljZSgxKVxuICAgIC5yZWR1Y2U8UGF0aE1hdGNoZXI+KChhY2MsIHRlc3QpID0+IGFjYy5vcih0ZXN0KSwgcHJlZGljYXRlLmNyZWF0ZSh0ZXN0c1swXSEpKTtcbn1cblxuaWYgKGltcG9ydC5tZXRhLm1haW4pIHtcbiAgY29uc3QgbWF0Y2hlciA9IGlnbm9yZVBhdGhNYXRjaGVyKHsgdGVzdDogdHJ1ZSB9KVxuICAgIC5uZWdhdGUoKVxuICAgIC5hbmQoLi4ucGF0aE1hdGNoVGVzdHMoXCIqKi9jb29sLnRzXCIsIFwiKiovd293LnRzXCIpKTtcbiAgY29uc29sZS5sb2cobWF0Y2hlcihcInBhY2thZ2VzL25vZGUvZmlsZS1zY2FuL3NyYy9jb29sLnRzXCIpKTtcbiAgY29uc29sZS5sb2cobWF0Y2hlcihcInBhY2thZ2VzL25vZGUvZmlsZS1zY2FuLy5zcmMvY29vbC50c1wiKSk7XG59XG4iXX0=

package/lib/src/pattern.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Glob pattern builders shared by ignore groups and matchers.
+ *
+ * @module
+ */
+/**
+ * Returns a glob matching all descendants of directories named `name`.
+ *
+ * By default, glob metacharacters in `name` are escaped so it is treated
+ * literally. Pass `false` for `escape` when `name` intentionally contains glob
+ * syntax.
+ *
+ * @param name - Directory base name (e.g. `node_modules`).
+ * @param escape - When `true` (default), escape glob metacharacters in `name`.
+ */
+export declare function directoryNamePattern(name: string, escape?: boolean): string;
+/**
+ * Returns a glob matching files with extension `extension` at any depth.
+ *
+ * @param extension - Extension with or without a leading dot (e.g. `log` or `.log`).
+ * @param escape - When `true` (default), escape glob metacharacters in `extension`.
+ */
+export declare function fileExtensionPattern(extension: string, escape?: boolean): string;

package/lib/src/pattern.js

@@ -0,0 +1,31 @@
+/**
+ * Glob pattern builders shared by ignore groups and matchers.
+ *
+ * @module
+ */
+/** Glob metacharacters; escaped so a directory or file name is matched literally. */
+const ESCAPE_GLOB_REGEXP = /([*?[\]{}()!+@\\])/g;
+/**
+ * Returns a glob matching all descendants of directories named `name`.
+ *
+ * By default, glob metacharacters in `name` are escaped so it is treated
+ * literally. Pass `false` for `escape` when `name` intentionally contains glob
+ * syntax.
+ *
+ * @param name - Directory base name (e.g. `node_modules`).
+ * @param escape - When `true` (default), escape glob metacharacters in `name`.
+ */
+export function directoryNamePattern(name, escape = true) {
+    return `**/${escape ? name.replace(ESCAPE_GLOB_REGEXP, "\\$1") : name}/**`;
+}
+/**
+ * Returns a glob matching files with extension `extension` at any depth.
+ *
+ * @param extension - Extension with or without a leading dot (e.g. `log` or `.log`).
+ * @param escape - When `true` (default), escape glob metacharacters in `extension`.
+ */
+export function fileExtensionPattern(extension, escape = true) {
+    const bare = extension.startsWith(".") ? extension.slice(1) : extension;
+    return `**/*.${escape ? bare.replace(ESCAPE_GLOB_REGEXP, "\\$1") : bare}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/scan.d.ts

@@ -0,0 +1,30 @@
+import { IgnorePatternOptions } from "./ignore.js";
+import { PathMatchInput } from "./match.js";
+export declare const FOLLOW_SYMLINKS_DEFAULT = false;
+export interface FileScanOptions {
+    /**
+     * Base directory used to resolve relative paths.
+     */
+    cwd?: string;
+    /**
+     * Ignore files or directories matching these patterns or predicates.
+     */
+    ignore?: PathMatchInput | readonly PathMatchInput[];
+    ignoreOptions?: FileScanIgnoreOptions;
+    /**
+     * Follow symbolic links.
+     *
+     * Maps to:
+     *   glob: follow
+     *   chokidar: followSymlinks
+     */
+    followSymlinks?: boolean;
+    /**
+     * Abort an in-progress operation.
+     *
+     * Ignored by chokidar after the watcher has been created.
+     */
+    signal?: AbortSignal;
+}
+/** Options controlling the generated ignore pattern list. */
+export type FileScanIgnoreOptions = IgnorePatternOptions;

package/lib/src/scan.js

@@ -0,0 +1,2 @@
+export const FOLLOW_SYMLINKS_DEFAULT = false;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nhbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zY2FuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLEtBQUssQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElnbm9yZVBhdHRlcm5PcHRpb25zIH0gZnJvbSBcIi4vaWdub3JlXCI7XG5pbXBvcnQgeyBQYXRoTWF0Y2hJbnB1dCB9IGZyb20gXCIuL21hdGNoXCI7XG5cbmV4cG9ydCBjb25zdCBGT0xMT1dfU1lNTElOS1NfREVGQVVMVCA9IGZhbHNlO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZpbGVTY2FuT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBCYXNlIGRpcmVjdG9yeSB1c2VkIHRvIHJlc29sdmUgcmVsYXRpdmUgcGF0aHMuXG4gICAqL1xuICBjd2Q/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIElnbm9yZSBmaWxlcyBvciBkaXJlY3RvcmllcyBtYXRjaGluZyB0aGVzZSBwYXR0ZXJucyBvciBwcmVkaWNhdGVzLlxuICAgKi9cbiAgaWdub3JlPzogUGF0aE1hdGNoSW5wdXQgfCByZWFkb25seSBQYXRoTWF0Y2hJbnB1dFtdO1xuICBpZ25vcmVPcHRpb25zPzogRmlsZVNjYW5JZ25vcmVPcHRpb25zO1xuICAvKipcbiAgICogRm9sbG93IHN5bWJvbGljIGxpbmtzLlxuICAgKlxuICAgKiBNYXBzIHRvOlxuICAgKiAgIGdsb2I6IGZvbGxvd1xuICAgKiAgIGNob2tpZGFyOiBmb2xsb3dTeW1saW5rc1xuICAgKi9cbiAgZm9sbG93U3ltbGlua3M/OiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBBYm9ydCBhbiBpbi1wcm9ncmVzcyBvcGVyYXRpb24uXG4gICAqXG4gICAqIElnbm9yZWQgYnkgY2hva2lkYXIgYWZ0ZXIgdGhlIHdhdGNoZXIgaGFzIGJlZW4gY3JlYXRlZC5cbiAgICovXG4gIHNpZ25hbD86IEFib3J0U2lnbmFsO1xufVxuXG4vKiogT3B0aW9ucyBjb250cm9sbGluZyB0aGUgZ2VuZXJhdGVkIGlnbm9yZSBwYXR0ZXJuIGxpc3QuICovXG5leHBvcnQgdHlwZSBGaWxlU2Nhbklnbm9yZU9wdGlvbnMgPSBJZ25vcmVQYXR0ZXJuT3B0aW9ucztcbiJdfQ==

package/lib/src/watch.d.ts

@@ -0,0 +1,11 @@
+import { ChokidarOptions, MatchFunction } from "chokidar";
+import { FileScanOptions } from "./scan.js";
+export interface FileWatchOptions extends Omit<ChokidarOptions, "ignored">, Omit<FileScanOptions, "ignore"> {
+    ignore?: string | string[] | MatchFunction | MatchFunction[];
+}
+/**
+ * Watches files and directories for real-time changes, applying the shared
+ * ignore groups so it prunes the same paths {@link findFiles} skips for the
+ * same patterns.
+ */
+export declare function watchFiles(paths: string | string[], options?: FileWatchOptions): import("chokidar").FSWatcher;

package/lib/src/watch.js

@@ -0,0 +1,137 @@
+import { isAbsolute, relative, resolve } from "path";
+import { watch } from "chokidar";
+import { hasMagic } from "glob";
+import { findFiles } from "./find.js";
+import { ignorePathMatcher } from "./ignore.js";
+import { pathMatchTests } from "./match.js";
+import { FOLLOW_SYMLINKS_DEFAULT } from "./scan.js";
+/**
+ * Watches files and directories for real-time changes, applying the shared
+ * ignore groups so it prunes the same paths {@link findFiles} skips for the
+ * same patterns.
+ */
+export function watchFiles(paths, options) {
+    const normalized = toNormalizedFileWatchOptions(options);
+    const { ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;
+    const { paths: literals, globs } = partitionPaths(paths);
+    let watchPaths;
+    if (globs.length > 0) {
+        const distinctWatchPaths = new Set(literals);
+        for (const path of findFiles(globs, toFindFilesOptions(normalized))) {
+            distinctWatchPaths.add(path);
+        }
+        watchPaths = [...distinctWatchPaths];
+    }
+    else {
+        watchPaths = literals;
+    }
+    return watch(watchPaths, {
+        ...chokidarOptions,
+        cwd,
+        followSymlinks,
+        ignored,
+    });
+}
+function partitionPaths(paths) {
+    const globs = [];
+    const literals = [];
+    for (const path of Array.isArray(paths) ? paths : [paths]) {
+        (hasMagic(path) ? globs : literals).push(path);
+    }
+    return { paths: literals, globs };
+}
+/**
+ * Builds {@link NormalizedFileWatchOptions} first: all caller ignore inputs and
+ * built-in groups are consolidated into one chokidar {@link MatchFunction}. When
+ * `stats` marks a directory, the matcher also tests `path + "/"` for pruning.
+ */
+function toNormalizedFileWatchOptions(options) {
+    const { cwd, ignore, followSymlinks, ignoreOptions, ...chokidarOptions } = options ?? {};
+    return {
+        ...chokidarOptions,
+        cwd: cwd ?? process.cwd(),
+        followSymlinks: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,
+        ignored: toWatchMatchFunction(ignore, ignoreOptions, cwd ?? process.cwd()),
+    };
+}
+/** Glob expansion reuses the normalized ignore matcher as a cwd-relative path predicate. */
+function toFindFilesOptions(normalized) {
+    const { ignored, cwd, followSymlinks } = normalized;
+    return {
+        cwd,
+        followSymlinks,
+        ignore: (path) => ignored(path, undefined),
+    };
+}
+/**
+ * Consolidates built-in ignore groups, caller glob patterns, and caller
+ * {@link MatchFunction}s into one ignore test. Directory pruning uses `stats`
+ * when chokidar supplies it; glob expansion passes `undefined`.
+ */
+function toWatchMatchFunction(ignore, ignoreOptions, cwd) {
+    const patterns = [];
+    const functions = [];
+    if (ignore !== undefined) {
+        for (const item of Array.isArray(ignore) ? ignore : [ignore]) {
+            if (typeof item === "string")
+                patterns.push(item);
+            else
+                functions.push(item);
+        }
+    }
+    let matcher = ignorePathMatcher(ignoreOptions);
+    if (patterns.length > 0)
+        matcher = matcher.or(...pathMatchTests(...patterns));
+    const matchPath = (path, stats) => {
+        const rel = toCwdRelativePath(path, cwd);
+        if (matcher(rel))
+            return true;
+        for (const fn of functions) {
+            if (fn(rel, stats))
+                return true;
+        }
+        if (stats?.isDirectory()) {
+            const directoryPath = rel + "/";
+            if (matcher(directoryPath))
+                return true;
+            for (const fn of functions) {
+                if (fn(directoryPath, stats))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return matchPath;
+}
+/** Aligns chokidar paths with the cwd-relative form {@link findFiles} uses. */
+function toCwdRelativePath(path, cwd) {
+    if (!isAbsolute(path))
+        return path;
+    const rel = relative(cwd, path);
+    return rel === "" ? "." : rel;
+}
+// Manual demo: run this file directly (e.g. `tsx src/watch.ts`) to watch this
+// package and log every file event as it happens.
+if (import.meta.main) {
+    const dir = import.meta.dirname;
+    console.log("--- Starting File Watcher ---");
+    let cwd = resolve(dir, "..");
+    cwd = "/Users/reggie.pierce/Projects/github-reggie-db/dbx-tools";
+    console.log(`Working Directory: ${cwd}`);
+    const watcher = watchFiles("**/src/**", {
+        cwd,
+        ignoreInitial: false,
+        ignore: ["**/index.ts", "**/core/**"],
+        ignoreOptions: {
+            temp: false,
+        },
+    });
+    watcher.on("all", (event, path) => {
+        console.log(`[${event.toUpperCase()}] ${path}`);
+    });
+    watcher.on("error", (error) => {
+        console.error("Watcher error:", error);
+    });
+    console.log("Watcher started");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch.js","sourceRoot":"","sources":["../../src/watch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stats } from \"fs\";\nimport { isAbsolute, relative, resolve } from \"path\";\nimport { ChokidarOptions, MatchFunction, watch } from \"chokidar\";\nimport { hasMagic } from \"glob\";\nimport { findFiles, type FileFindOptions } from \"./find\";\nimport { ignorePathMatcher } from \"./ignore\";\nimport { pathMatchTests } from \"./match\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan\";\n\nexport interface FileWatchOptions\n  extends Omit<ChokidarOptions, \"ignored\">, Omit<FileScanOptions, \"ignore\"> {\n  ignore?: string | string[] | MatchFunction | MatchFunction[];\n}\n\ninterface NormalizedFileWatchOptions extends Omit<FileWatchOptions, \"ignore\" | \"ignoreOptions\"> {\n  ignored: MatchFunction;\n}\n\n/**\n * Watches files and directories for real-time changes, applying the shared\n * ignore groups so it prunes the same paths {@link findFiles} skips for the\n * same patterns.\n */\nexport function watchFiles(paths: string | string[], options?: FileWatchOptions) {\n  const normalized = toNormalizedFileWatchOptions(options);\n  const { ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;\n  const { paths: literals, globs } = partitionPaths(paths);\n\n  let watchPaths: string[];\n  if (globs.length > 0) {\n    const distinctWatchPaths = new Set(literals);\n    for (const path of findFiles(globs, toFindFilesOptions(normalized))) {\n      distinctWatchPaths.add(path);\n    }\n    watchPaths = [...distinctWatchPaths];\n  } else {\n    watchPaths = literals;\n  }\n\n  return watch(watchPaths, {\n    ...chokidarOptions,\n    cwd,\n    followSymlinks,\n    ignored,\n  });\n}\n\nfunction partitionPaths(paths: string | string[]): { paths: string[]; globs: string[] } {\n  const globs: string[] = [];\n  const literals: string[] = [];\n  for (const path of Array.isArray(paths) ? paths : [paths]) {\n    (hasMagic(path) ? globs : literals).push(path);\n  }\n  return { paths: literals, globs };\n}\n\n/**\n * Builds {@link NormalizedFileWatchOptions} first: all caller ignore inputs and\n * built-in groups are consolidated into one chokidar {@link MatchFunction}. When\n * `stats` marks a directory, the matcher also tests `path + \"/\"` for pruning.\n */\nfunction toNormalizedFileWatchOptions(options?: FileWatchOptions): NormalizedFileWatchOptions & {\n  cwd: string;\n  followSymlinks: boolean;\n} {\n  const { cwd, ignore, followSymlinks, ignoreOptions, ...chokidarOptions } = options ?? {};\n  return {\n    ...chokidarOptions,\n    cwd: cwd ?? process.cwd(),\n    followSymlinks: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ignored: toWatchMatchFunction(ignore, ignoreOptions, cwd ?? process.cwd()),\n  };\n}\n\n/** Glob expansion reuses the normalized ignore matcher as a cwd-relative path predicate. */\nfunction toFindFilesOptions(\n  normalized: NormalizedFileWatchOptions & { cwd: string; followSymlinks: boolean },\n): FileFindOptions {\n  const { ignored, cwd, followSymlinks } = normalized;\n  return {\n    cwd,\n    followSymlinks,\n    ignore: (path) => ignored(path, undefined),\n  };\n}\n\n/**\n * Consolidates built-in ignore groups, caller glob patterns, and caller\n * {@link MatchFunction}s into one ignore test. Directory pruning uses `stats`\n * when chokidar supplies it; glob expansion passes `undefined`.\n */\nfunction toWatchMatchFunction(\n  ignore: FileWatchOptions[\"ignore\"] | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n  cwd: string,\n): MatchFunction {\n  const patterns: string[] = [];\n  const functions: MatchFunction[] = [];\n\n  if (ignore !== undefined) {\n    for (const item of Array.isArray(ignore) ? ignore : [ignore]) {\n      if (typeof item === \"string\") patterns.push(item);\n      else functions.push(item);\n    }\n  }\n\n  let matcher = ignorePathMatcher(ignoreOptions);\n  if (patterns.length > 0) matcher = matcher.or(...pathMatchTests(...patterns));\n\n  const matchPath = (path: string, stats?: Stats): boolean => {\n    const rel = toCwdRelativePath(path, cwd);\n    if (matcher(rel)) return true;\n    for (const fn of functions) {\n      if (fn(rel, stats)) return true;\n    }\n    if (stats?.isDirectory()) {\n      const directoryPath = rel + \"/\";\n      if (matcher(directoryPath)) return true;\n      for (const fn of functions) {\n        if (fn(directoryPath, stats)) return true;\n      }\n    }\n    return false;\n  };\n\n  return matchPath;\n}\n\n/** Aligns chokidar paths with the cwd-relative form {@link findFiles} uses. */\nfunction toCwdRelativePath(path: string, cwd: string): string {\n  if (!isAbsolute(path)) return path;\n  const rel = relative(cwd, path);\n  return rel === \"\" ? \".\" : rel;\n}\n\n// Manual demo: run this file directly (e.g. `tsx src/watch.ts`) to watch this\n// package and log every file event as it happens.\nif (import.meta.main) {\n  const dir = import.meta.dirname;\n  console.log(\"--- Starting File Watcher ---\");\n  let cwd = resolve(dir, \"..\");\n  cwd = \"/Users/reggie.pierce/Projects/github-reggie-db/dbx-tools\";\n  console.log(`Working Directory: ${cwd}`);\n\n  const watcher = watchFiles(\"**/src/**\", {\n    cwd,\n    ignoreInitial: false,\n    ignore: [\"**/index.ts\", \"**/core/**\"],\n    ignoreOptions: {\n      temp: false,\n    },\n  });\n  watcher.on(\"all\", (event: string, path: string) => {\n    console.log(`[${event.toUpperCase()}] ${path}`);\n  });\n  watcher.on(\"error\", (error) => {\n    console.error(\"Watcher error:\", error);\n  });\n  console.log(\"Watcher started\");\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/find.ts","../src/ignore.ts","../src/match.ts","../src/pattern.ts","../src/scan.ts","../src/watch.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -14,24 +14,28 @@
     "chokidar": "^4.0.3",
     "glob": "^13.0.6",
     "minimatch": "^10.2.5",
-    "@dbx-tools/core": "0.3.44",
-    "@dbx-tools/shared-core": "0.3.44"
+    "@dbx-tools/core": "0.4.0",
+    "@dbx-tools/shared-core": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [