@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/text/glob.js

@@ -0,0 +1,194 @@
+/**
+ * Glob patterns over paths in two forms. The configured form (the configuration, convention
+ * rows, bundler entries, workspace member patterns) has `*` and `?` within a segment, `**`
+ * across segments and brace lists. A `.gitignore` line has git's form: bracket expressions
+ * and backslash escapes, no brace lists (https://git-scm.com/docs/gitignore#_pattern_format).
+ * A configured root is not a glob: it names a symbol reference, and is read where it is used.
+ */
+/**
+ * One character of a pattern as the expression syntax reads it literally. The set escaped
+ * is closed: under the unicode flag an escape of any other character is refused outright.
+ */
+function quoted(character) {
+    return /[.*+?^${}()|[\]\\/]/u.test(character) ? `\\${character}` : character;
+}
+/**
+ * The ASCII ranges each POSIX class a bracket expression may name holds, as git's own
+ * character table reads them, each range written as its first and last character.
+ */
+const CLASSES = new Map([
+    ["alnum", "09AZaz"],
+    ["alpha", "AZaz"],
+    ["blank", "\t\t  "],
+    ["cntrl", "\0\x1f\x7f\x7f"],
+    ["digit", "09"],
+    ["graph", "!~"],
+    ["lower", "az"],
+    ["print", " ~"],
+    ["punct", "!/:@[`{~"],
+    ["space", "\t\n\r\r  "],
+    ["upper", "AZ"],
+    ["xdigit", "09AFaf"],
+]);
+/** What a pattern git cannot read matches: nothing, as git aborts the whole match. */
+const NOTHING = "(?!)";
+/** One code point as a member of an expression class. */
+function member(point) {
+    return `\\u{${point.toString(16)}}`;
+}
+/**
+ * The class a bracket expression opening at `open` denotes, and the index past its `]`,
+ * read as git's wildmatch reads it: a leading `!` or `^` negates it, a `]` first is a
+ * member, `\` escapes one character, `x-y` is a range (one whose `y` is below `x` holds
+ * `x` alone) and `[:name:]` a POSIX class. An unclosed bracket or an unknown class name
+ * matches nothing. Neither form matches the solidus.
+ */
+function bracket(pattern, open) {
+    let at = open + 1;
+    const negated = pattern[at] === "!" || pattern[at] === "^";
+    if (negated) {
+        at += 1;
+    }
+    const next = () => {
+        const point = pattern.codePointAt(at);
+        at += point !== undefined && point > 0xffff ? 2 : 1;
+        return point;
+    };
+    let members = "";
+    let low;
+    for (let first = true;; first = false) {
+        let point = next();
+        if (point === undefined) {
+            return { source: NOTHING, end: pattern.length };
+        }
+        if (point === 0x5d && !first) {
+            return { source: negated ? `[^/${members}]` : `(?!/)[${members}]`, end: at };
+        }
+        if (point === 0x2d && low !== undefined && at < pattern.length && pattern[at] !== "]") {
+            let high = next();
+            if (high === 0x5c) {
+                high = next();
+            }
+            if (high === undefined) {
+                return { source: NOTHING, end: pattern.length };
+            }
+            members += high >= low ? `${member(low)}-${member(high)}` : "";
+            low = undefined;
+            continue;
+        }
+        if (point === 0x5b && pattern[at] === ":") {
+            const close = pattern.indexOf("]", at + 1);
+            if (close < 0) {
+                return { source: NOTHING, end: pattern.length };
+            }
+            if (close > at + 1 && pattern[close - 1] === ":") {
+                const ranges = CLASSES.get(pattern.slice(at + 1, close - 1));
+                if (ranges === undefined) {
+                    return { source: NOTHING, end: pattern.length };
+                }
+                for (let one = 0; one < ranges.length; one += 2) {
+                    members += `${member(ranges.charCodeAt(one))}-${member(ranges.charCodeAt(one + 1))}`;
+                }
+                low = undefined;
+                at = close + 1;
+                continue;
+            }
+        }
+        if (point === 0x5c) {
+            point = next();
+            if (point === undefined) {
+                return { source: NOTHING, end: pattern.length };
+            }
+        }
+        members += member(point);
+        low = point;
+    }
+}
+/** The expression source of one pattern with no brace list. */
+function source(pattern, form) {
+    let text = "";
+    let at = 0;
+    while (at < pattern.length) {
+        if (pattern.startsWith("**/", at)) {
+            text += "(?:[^/]*/)*";
+            at += 3;
+            continue;
+        }
+        if (pattern.startsWith("**", at)) {
+            text += ".*";
+            at += 2;
+            continue;
+        }
+        const character = pattern[at] ?? "";
+        if (form === "gitignore" && character === "[") {
+            const read = bracket(pattern, at);
+            text += read.source;
+            at = read.end;
+            continue;
+        }
+        if (form === "gitignore" && character === "\\" && at + 1 < pattern.length) {
+            text += quoted(pattern[at + 1] ?? "");
+            at += 2;
+            continue;
+        }
+        at += 1;
+        text += character === "*" ? "[^/]*" : character === "?" ? "[^/]" : quoted(character);
+    }
+    return text;
+}
+/** A pattern with every brace list expanded into its alternatives; a lone `{` stands for itself. */
+export function braceExpanded(pattern) {
+    const open = pattern.indexOf("{");
+    const close = open < 0 ? -1 : pattern.indexOf("}", open);
+    if (close < 0) {
+        return [pattern];
+    }
+    const before = pattern.slice(0, open);
+    const after = pattern.slice(close + 1);
+    return pattern
+        .slice(open + 1, close)
+        .split(",")
+        .flatMap((member) => braceExpanded(before + member + after));
+}
+/** The expression one whole-path pattern of the configured form denotes. */
+export function globExpression(pattern) {
+    const alternatives = braceExpanded(pattern).map((one) => source(one, "configured"));
+    return new RegExp(`^(?:${alternatives.join("|")})$`, "u");
+}
+/** The expression one `.gitignore` pattern denotes over a path below its file's directory. */
+export function gitignoreExpression(pattern) {
+    return new RegExp(`^${source(pattern, "gitignore")}$`, "u");
+}
+const SEGMENTS = new Map();
+/**
+ * Whether one directory name matches one segment of a workspace's member pattern, its brace
+ * lists already expanded. Neither `*` nor `?` matches a leading dot, as npm's workspaces read
+ * them: https://docs.npmjs.com/cli/using-npm/workspaces
+ */
+export function segmentMatches(segment, name) {
+    if (name.startsWith(".") && !segment.startsWith(".")) {
+        return false;
+    }
+    let expression = SEGMENTS.get(segment);
+    if (expression === undefined) {
+        expression = globExpression(segment);
+        SEGMENTS.set(segment, expression);
+    }
+    return expression.test(name);
+}
+/**
+ * Whether one path's segments match a member pattern's, `**` standing for any run of segments
+ * that starts with no dot.
+ */
+export function pathMatches(pattern, path) {
+    const [head, ...rest] = pattern;
+    if (head === undefined) {
+        return path.length === 0;
+    }
+    if (head === "**") {
+        return (pathMatches(rest, path) ||
+            (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1))));
+    }
+    const [name, ...below] = path;
+    return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
+}

package/dist/src/text/named-files.js

@@ -0,0 +1,298 @@
+/** Layer 3 of the command reader: the files its words name, and the package names a command's text names. */
+import { PART } from "../commands/shell.js";
+import { APPENDED_EXTENSIONS, extensionOf } from "../extensions.js";
+import { dirnamePath, normalizePath, relativePath } from "../paths.js";
+/** The extensions a name of a file drops: a source's, an emitted file's, and a declaration's (roots.13). */
+const NAMED_EXTENSIONS = [...APPENDED_EXTENSIONS, ".d.ts", ".d.mts", ".d.cts"];
+/** A character a package's or a command's name may hold, so one beside a name makes it part of a longer one. */
+const NAME_CHARACTER = /[\w.@-]/u;
+const SEPARATOR = /[/\\]/u;
+/**
+ * The names whose appearance as a path in a text holds one path below `dir`: its last segment
+ * without the extension, or whole where nothing else is left or it has none, and for an
+ * `index` file its directory's last segment, and `.` too where that is `dir`. Every spelling
+ * of the path that writes it as a path holds one of them (roots.13). None is empty, because
+ * an empty name is in every text.
+ */
+function namesOf(path, dir) {
+    const last = path.slice(path.lastIndexOf("/") + 1);
+    const bare = last.slice(0, last.length - (extensionOf(last, NAMED_EXTENSIONS)?.length ?? 0));
+    const own = bare === "" || bare === last ? { text: last, kind: "segment" } : { text: bare, kind: "stem" };
+    if (own.text !== "index") {
+        return [own];
+    }
+    const parent = dirnamePath(path);
+    const directory = parent.slice(parent.lastIndexOf("/") + 1);
+    return [
+        own,
+        ...(directory === "" ? [] : [{ text: directory, kind: "directory" }]),
+        ...(parent === normalizePath(dir) ? [{ text: ".", kind: "root" }] : []),
+    ];
+}
+/**
+ * Whether a name that ends at `end` ends there as a path: no name character follows, nor a
+ * separator, which goes on to a path below it, nor a part, whose text goes on with the name,
+ * nor a `.` that a word character or a part follows, which goes on to another extension.
+ */
+function endsAt(text, end) {
+    const next = text.charAt(end);
+    const after = text.charAt(end + 1);
+    return (!/[\w@/\\-]/u.test(next) &&
+        next !== PART &&
+        !(next === "." && (/\w/u.test(after) || after === PART)));
+}
+/** A character a word that writes a path may hold, a part only its run knows among them. */
+const PATH_CHARACTER = new RegExp(`[\\w.@+/\\\\${PART}-]`, "u");
+/** A run of {@link PATH_CHARACTER}s: a word as {@link noFileEnd} reads one. */
+const PATH_WORD = new RegExp(`${PATH_CHARACTER.source}+`, "gu");
+const SCOPED_PACKAGE = /^@[\w-][\w.-]*\/[\w-][\w.-]*(?:@[\w.-]*)?$/u;
+/**
+ * The end of what `text` writes from `start`, where `word` starts, that names an image or a
+ * package and never a file, or `start` where it names none (roots.13): a value of a `docker:`
+ * that starts no longer name, and a scoped package's name, which no part goes on with, since
+ * a part beside it may make it a path.
+ */
+function noFileEnd(text, start, word) {
+    const end = start + word.length;
+    const image = word.startsWith("//") &&
+        start >= 7 &&
+        text.startsWith("docker:", start - 7) &&
+        !NAME_CHARACTER.test(text.charAt(start - 8));
+    return image || (SCOPED_PACKAGE.test(word) && !holdsExtension(word)) ? end : start;
+}
+/** Each place of `text` that {@link noFileEnd} rules out, as a 1. */
+function placesNamingNoFile(text) {
+    const ruledOut = new Uint8Array(text.length);
+    for (const { 0: word, index: start } of text.matchAll(PATH_WORD)) {
+        ruledOut.fill(1, start, noFileEnd(text, start, word));
+    }
+    return ruledOut;
+}
+/** The place after the separators `text` holds from `at`. */
+function pastSeparators(text, at) {
+    let after = at;
+    while (SEPARATOR.test(text.charAt(after))) {
+        after += 1;
+    }
+    return after;
+}
+/** Whether `name`, found in `text` at `at`, appears there as a path (roots.13). */
+function appearsAsPath(text, at, name) {
+    const before = text.charAt(at - 1);
+    const end = at + name.text.length;
+    if (before === PART) {
+        return false;
+    }
+    if (name.kind === "root") {
+        const after = pastSeparators(text, end);
+        return ([before, text.charAt(after)].every((one) => !NAME_CHARACTER.test(one) && !SEPARATOR.test(one)) && text.charAt(after) !== PART);
+    }
+    if (NAME_CHARACTER.test(before)) {
+        return false;
+    }
+    const after = pastSeparators(text, end);
+    if (name.kind === "directory" && after > end && endsAt(text, after)) {
+        return true;
+    }
+    if ((SEPARATOR.test(before) || (name.kind === "segment" && name.text.indexOf(".", 1) > 0)) &&
+        endsAt(text, end)) {
+        return true;
+    }
+    return (name.kind === "stem" &&
+        NAMED_EXTENSIONS.some((extension) => text.startsWith(extension, end) && endsAt(text, end + extension.length)));
+}
+/** Whether some text holds one of the extensions as a whole. */
+function holdsExtension(written) {
+    return NAMED_EXTENSIONS.some((extension) => new RegExp(`${extension.replaceAll(".", "\\.")}(?!\\w)`, "u").test(written));
+}
+/** Whether a word's segment writes path text: text beside its parts other than `.` and `..`. */
+function writesPath(segment) {
+    return segment.split(PART).some((piece) => piece !== "" && piece !== "." && piece !== "..");
+}
+/**
+ * Each run of path characters of `word`, at `start`, whose last segment holds a part, read as
+ * roots.13 reads one from past its last segment before the last that writes no path: one that
+ * writes none names nothing and is `unwritten` where the word may write the file a command runs,
+ * where a bare one names a file too. The word stands `depth` segments below the target root,
+ * whose own directories no checkout names alike: a leading `..` past it writes none, and an
+ * absolute run reads from its last segment that writes a path, `unwritten` where more is left.
+ */
+function dynamicWords(word, start, ruledOut, depth) {
+    const { text, runs } = word;
+    const found = [];
+    let unwritten = false;
+    const read = (from, next) => {
+        const entry = next < 0;
+        // A `.` the word ends with ends a sentence, as endsAt reads one after a name.
+        const run = entry ? text : text.slice(from, next).replace(/\.+$/u, "");
+        const all = run.replaceAll("\\", "/").split("/");
+        const directory = all.length > 1 && all.at(-1) === "";
+        const written = all.filter((segment) => segment !== "" && segment !== ".");
+        const last = (written.at(-1) ?? "").split(PART);
+        // A runtime's entry is a path whatever it looks like, a scoped package's name among them.
+        if (!entry && (last.length < 2 || ruledOut[start + from] === 1)) {
+            return;
+        }
+        const climbs = written.findIndex((segment) => segment !== "..");
+        const above = Math.max(0, (climbs < 0 ? written.length : climbs) - depth);
+        const segments = written.filter((_, at) => at < climbs || at >= climbs + above);
+        if (!segments.some(writesPath)) {
+            unwritten ||= runs && (!entry || above > 0);
+        }
+        else if (all.length > 1 || holdsExtension(last.join("")) || runs) {
+            const kept = directory ? segments.length : segments.length - 1;
+            const anyDirectory = segments.slice(0, kept).findLastIndex((one) => !writesPath(one));
+            const absolute = all[0] === "" && all.length > 1 && anyDirectory < 0;
+            const from = absolute ? segments.findLastIndex(writesPath) : anyDirectory + 1;
+            unwritten ||= runs && absolute && from < segments.length - 1;
+            const glob = segments.slice(from).join("/");
+            found.push({ glob: glob === "" ? ["", ""] : glob.split(PART), directory });
+        }
+    };
+    if (runs && !text.includes(PART)) {
+        read(0, -1);
+    }
+    let at = text.indexOf(PART);
+    while (at >= 0) {
+        let from = at;
+        while (from > 0 && PATH_CHARACTER.test(text.charAt(from - 1))) {
+            from -= 1;
+        }
+        let next = at;
+        while (next < text.length && PATH_CHARACTER.test(text.charAt(next))) {
+            next += 1;
+        }
+        read(from, next);
+        at = text.indexOf(PART, Math.max(next, at + 1));
+    }
+    return { found, unwritten };
+}
+/** Whether `segment` is the text `glob` writes, any text standing between two of its parts. */
+function standsFor(glob, segment) {
+    const first = glob[0] ?? "";
+    const last = glob.at(-1) ?? "";
+    if (glob.length === 1) {
+        return segment === first;
+    }
+    if (!segment.startsWith(first) ||
+        !segment.endsWith(last) ||
+        first.length + last.length > segment.length) {
+        return false;
+    }
+    let at = first.length;
+    const end = segment.length - last.length;
+    for (const middle of glob.slice(1, -1)) {
+        const found = segment.indexOf(middle, at);
+        if (found < 0 || found + middle.length > end) {
+            return false;
+        }
+        at = found + middle.length;
+    }
+    return true;
+}
+/** Whether a word's glob may write `path` or the end of it after a `/`. */
+function mayStandFor(glob, path) {
+    let at = 0;
+    while (!standsFor(glob, path.slice(at))) {
+        const slash = path.indexOf("/", at);
+        if (slash < 0) {
+            return false;
+        }
+        at = slash + 1;
+    }
+    return true;
+}
+/**
+ * Each spelling of one path below `dir` a word may write the end of: the whole path from `root`,
+ * so a word may write the directories between them too, but no checkout's own, without its
+ * extension, and without its `/index` part, which alone is a directory's spelling.
+ */
+function spellingsBelow(path, dir, root) {
+    const fromRoot = relativePath(root, path);
+    if (relativePath(dir, path) === undefined || fromRoot === undefined) {
+        return { file: [], directory: [] };
+    }
+    const whole = `/${fromRoot}`;
+    const extension = extensionOf(whole, NAMED_EXTENSIONS);
+    const bare = extension === undefined ? whole : whole.slice(0, -extension.length);
+    const directory = bare.endsWith("/index") ? [bare.slice(0, -"/index".length)] : [];
+    return { file: [whole, bare, ...directory], directory };
+}
+/**
+ * Every file of `files` below `dir` that `words` name: one of whose {@link namesOf} a path of it
+ * has appears in a word as a path, or a spelling of one of whose paths a word that writes a
+ * path with a part only its run knows may stand for, and whether a word that may write the
+ * file a command runs writes no path text. A file the words do not name may be named too, and
+ * no file a word writes as a path outside an image's or a package's name is missed.
+ */
+export function spelledFiles(words, dir, root, files) {
+    const byName = new Map();
+    for (const { file, paths } of files) {
+        const [own] = paths;
+        if (own === undefined || relativePath(dir, own) === undefined) {
+            continue;
+        }
+        const seen = new Set();
+        for (const name of paths.flatMap((path) => namesOf(path, dir))) {
+            const key = `${name.kind}\u0000${name.text}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                byName.set(name.text, [...(byName.get(name.text) ?? []), { file, name }]);
+            }
+        }
+    }
+    const found = new Set();
+    const text = words.map((word) => word.text).join("\n");
+    const ruledOut = placesNamingNoFile(text);
+    // One pass per name length: each place of the text is looked up once for every length.
+    for (const length of new Set([...byName.keys()].map((name) => name.length))) {
+        for (let at = 0; at + length <= text.length; at += 1) {
+            for (const { file, name } of byName.get(text.slice(at, at + length)) ?? []) {
+                if (!found.has(file) && ruledOut[at] !== 1 && appearsAsPath(text, at, name)) {
+                    found.add(file);
+                }
+            }
+        }
+    }
+    const dynamic = [];
+    let unwritten = false;
+    let start = 0;
+    const depth = normalizePath(dir) === normalizePath(root)
+        ? 0
+        : (relativePath(root, dir)?.split("/").length ?? 0);
+    for (const word of words) {
+        const read = dynamicWords(word, start, ruledOut, depth);
+        dynamic.push(...read.found);
+        unwritten ||= read.unwritten;
+        start += word.text.length + 1;
+    }
+    if (dynamic.length > 0) {
+        for (const { file, paths } of files) {
+            const spellings = paths.map((path) => spellingsBelow(path, dir, root));
+            if (!found.has(file) &&
+                dynamic.some((word) => spellings.some((spelled) => (word.directory ? spelled.directory : spelled.file).some((one) => mayStandFor(word.glob, one))))) {
+                found.add(file);
+            }
+        }
+    }
+    return { files: [...found], unwritten };
+}
+/**
+ * Each of `names`, a package's or a command's name, that `text` holds with no name character
+ * before it and no character after it but one a path or a version may go on with, `/`, `.` or
+ * `@` among them: `module-alias/register` holds `module-alias`, and `tsxx` holds no `tsx`.
+ */
+export function heldNames(text, names) {
+    const found = new Set();
+    for (const name of names) {
+        for (let at = text.indexOf(name); at >= 0 && name !== ""; at = text.indexOf(name, at + 1)) {
+            const before = text.charAt(at - 1);
+            const after = text.charAt(at + name.length);
+            if (!NAME_CHARACTER.test(before) && !/[\w-]/u.test(after)) {
+                found.add(name);
+                break;
+            }
+        }
+    }
+    return found;
+}