@solaqua/gji 0.14.0 → 0.16.0

package/dist/domain/worktree/path-filter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builds a predicate that matches worktree paths against any of the absolute
+ * patterns. A pattern without glob characters matches that directory and
+ * anything inside it. A pattern with `*` (within one segment), `**` (across
+ * segments), or `?` (one character) must match the whole path. A backslash
+ * makes the next character literal, so `\*` and `\?` match themselves. No
+ * patterns match every path.
+ */
+export declare function createWorktreePathFilter(patterns: readonly string[]): (worktreePath: string) => boolean;
+/** Returns the index of the first unescaped glob character, or -1. */
+export declare function findGlobIndex(pattern: string): number;
+export declare function escapePathPattern(path: string): string;
+export declare function unescapePathPattern(pattern: string): string;

package/dist/domain/worktree/path-filter.js

@@ -0,0 +1,72 @@
+/**
+ * Builds a predicate that matches worktree paths against any of the absolute
+ * patterns. A pattern without glob characters matches that directory and
+ * anything inside it. A pattern with `*` (within one segment), `**` (across
+ * segments), or `?` (one character) must match the whole path. A backslash
+ * makes the next character literal, so `\*` and `\?` match themselves. No
+ * patterns match every path.
+ */
+export function createWorktreePathFilter(patterns) {
+    const matchers = patterns.map(createPathMatcher);
+    if (matchers.length === 0)
+        return () => true;
+    return (worktreePath) => matchers.some((matches) => matches(worktreePath));
+}
+/** Returns the index of the first unescaped glob character, or -1. */
+export function findGlobIndex(pattern) {
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === "\\")
+            index += 1;
+        else if (character === "*" || character === "?")
+            return index;
+    }
+    return -1;
+}
+export function escapePathPattern(path) {
+    return path.replace(/[\\*?]/g, "\\$&");
+}
+export function unescapePathPattern(pattern) {
+    return pattern.replace(/\\(.)/g, "$1");
+}
+function createPathMatcher(pattern) {
+    if (findGlobIndex(pattern) !== -1) {
+        const regExp = globToRegExp(pattern);
+        return (path) => regExp.test(path);
+    }
+    const literal = unescapePathPattern(pattern);
+    const prefix = literal === "/" ? "/" : `${literal}/`;
+    return (path) => path === literal || path.startsWith(prefix);
+}
+function globToRegExp(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        let character = pattern[index];
+        if (character === "*") {
+            if (pattern[index + 1] === "*") {
+                index += 1;
+                if (pattern[index + 1] === "/") {
+                    index += 1;
+                    source += "(?:.*/)?";
+                }
+                else {
+                    source += ".*";
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (character === "?") {
+            source += "[^/]";
+        }
+        else {
+            if (character === "\\" && index + 1 < pattern.length) {
+                index += 1;
+                character = pattern[index];
+            }
+            source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}

package/dist/domain/worktree/policy.d.ts

@@ -1,2 +1,3 @@
 export declare function resolveWorktreePath(repoRoot: string, branch: string, basePath?: string): string;
 export declare function validateBranchName(name: string): string | null;
+export declare function expandTildeInPath(path: string): string;

package/dist/domain/worktree/policy.js

@@ -49,7 +49,7 @@ export function validateBranchName(name) {
     }
     return null;
 }
-function expandTildeInPath(path) {
+export function expandTildeInPath(path) {
     if (path === "~")
         return homedir();
     if (path.startsWith("~/"))