@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

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,54 @@
+/**
+ * The files a command's text names, read as plain text: the text is searched for each file's
+ * names, which every spelling of its path contains, so no part of it is split, unquoted or
+ * skipped first.
+ */
+import { dirnamePath, normalizePath, relativePath } from "../paths.js";
+/** The extension a source or an emitted file carries: a JavaScript or TypeScript one, or a declaration's. */
+const SOURCE_EXTENSION = /\.(?:d\.[cm]?ts|[cm]?[jt]s|[jt]sx)$/u;
+/**
+ * The names whose presence in a text holds one path below `dir`: its last name without the
+ * extension, or with it where nothing else is left, and for an `index` file its directory's
+ * last name, and `.` too where that is `dir`. Every spelling of the path relative to `dir`,
+ * with or without `./`, `/` or `\`, its extension or its `/index` part, and every longer path
+ * ending in one, holds one of them. None is empty, because an empty name is in every text.
+ */
+function stemsOf(path, dir) {
+    const last = path.slice(path.lastIndexOf("/") + 1);
+    const bare = last.replace(SOURCE_EXTENSION, "");
+    const name = bare === "" ? last : bare;
+    if (name !== "index") {
+        return [name];
+    }
+    const parent = dirnamePath(path);
+    return [
+        name,
+        parent.slice(parent.lastIndexOf("/") + 1),
+        ...(parent === normalizePath(dir) ? ["."] : []),
+    ].filter((stem) => stem !== "");
+}
+/**
+ * Every file of `files` below `dir` that `text` names: one whose {@link stemsOf} a path of it
+ * spells appears anywhere in the text. A file the text does not name may be held too, and no
+ * file it names is missed.
+ */
+export function spelledFiles(text, dir, files) {
+    const byStem = new Map();
+    for (const { file, paths } of files) {
+        const [own] = paths;
+        if (own === undefined || relativePath(dir, own) === undefined) {
+            continue;
+        }
+        for (const stem of new Set(paths.flatMap((path) => stemsOf(path, dir)))) {
+            byStem.set(stem, [...(byStem.get(stem) ?? []), file]);
+        }
+    }
+    const found = new Set();
+    // One pass per stem length: each place of the text is looked up once for every length.
+    for (const length of new Set([...byStem.keys()].map((stem) => stem.length))) {
+        for (let at = 0; at + length <= text.length; at += 1) {
+            byStem.get(text.slice(at, at + length))?.forEach((file) => found.add(file));
+        }
+    }
+    return [...found];
+}

package/dist/src/text/shell.js

@@ -0,0 +1,159 @@
+/**
+ * Shell command lines read as text, never run: the commands a line runs, the tokens the
+ * Contract splits a command into, and the words POSIX token recognition reads.
+ */
+/**
+ * The shell's list and pipeline operators, each of which ends one command. An `&` beside a
+ * redirection's `<` or `>` (`2>&1`, and bash's `&>log`) is part of the redirection.
+ */
+const COMMAND_OPERATORS = /&&|\|\||;|\||(?<![<>])&(?!>)/u;
+/** Where a command splits into tokens: white space and the operators the Contract names. */
+const TOKEN_SEPARATORS = /\s+|&&|\|\||;|\|/u;
+/** A text written inside one pair of quotes. */
+const QUOTED = /^(["'])(.*)\1$/su;
+/** The commands one line runs, the text between two of the shell's list and pipeline operators. */
+export function commandsOf(line) {
+    return line.split(COMMAND_OPERATORS);
+}
+/** One text with one pair of enclosing quotes removed. */
+export function unquoted(text) {
+    return text.replace(QUOTED, "$2");
+}
+/**
+ * Every token one script's command line holds, each with one pair of enclosing quotes
+ * removed. A token holding a wildcard is a pattern rather than a path, and names no
+ * entry point.
+ */
+export function scriptTokens(command) {
+    return command
+        .split(TOKEN_SEPARATORS)
+        .map(unquoted)
+        .filter((token) => token !== "" && !token.includes("*"));
+}
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+export function withoutComment(line) {
+    let quote = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line[at];
+        if (quote !== "") {
+            if (char === quote) {
+                quote = "";
+            }
+            else if (char === "\\" && quote === '"') {
+                at += 1;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === "\\") {
+            at += 1;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at);
+        }
+    }
+    return line;
+}
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
+const BLANK = /[ \t\r\f\v]/u;
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+export function shellWords(command) {
+    const words = [];
+    let word;
+    let computed = false;
+    const end = () => {
+        if (word !== undefined) {
+            words.push(computed ? undefined : word);
+        }
+        word = undefined;
+        computed = false;
+    };
+    for (let at = 0; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === "\\" && command.charAt(at + 1) === "\n") {
+            at += 1;
+        }
+        else if (BLANK.test(char)) {
+            end();
+        }
+        else if (OPERATOR.test(char)) {
+            end();
+            words.push(undefined);
+        }
+        else if (char === "#" && word === undefined) {
+            const newline = command.indexOf("\n", at);
+            at = newline < 0 ? command.length : newline - 1;
+        }
+        else if (char === "\\") {
+            at += 1;
+            word = (word ?? "") + command.charAt(at);
+        }
+        else if (char === "'" || char === '"') {
+            const close = closingQuote(command, at);
+            if (close < 0) {
+                word ??= "";
+                computed = true;
+                break;
+            }
+            const quoted = char === "'"
+                ? { text: command.slice(at + 1, close), computed: false }
+                : doubleQuoted(command.slice(at + 1, close));
+            word = (word ?? "") + quoted.text;
+            computed ||= quoted.computed;
+            at = close;
+        }
+        else {
+            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+            word = (word ?? "") + char;
+        }
+    }
+    end();
+    return words;
+}
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner) {
+    let text = "";
+    let computed = false;
+    for (let at = 0; at < inner.length; at += 1) {
+        const char = inner.charAt(at);
+        const next = inner.charAt(at + 1);
+        if (char === "\\" && next === "\n") {
+            at += 1;
+        }
+        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+            text += next;
+            at += 1;
+        }
+        else {
+            computed ||= char === "$" || char === "`";
+            text += char;
+        }
+    }
+    return { text, computed };
+}
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command, open) {
+    const quote = command.charAt(open);
+    for (let at = open + 1; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === quote) {
+            return at;
+        }
+        if (quote === '"' && char === "\\") {
+            at += 1;
+        }
+    }
+    return -1;
+}