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

package/dist/src/git-ignore.js

@@ -1,10 +1,12 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
-import { globExpression } from "./glob.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-/** The rules one `.gitignore` text writes, in order. */
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
+import { message } from "./product.js";
+import { gitignoreExpression } from "./text/glob.js";
+import { repositoryOf } from "./fs/tree.js";
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text) {
     const rules = [];
     for (const raw of text.split(/\r?\n/u)) {
@@ -13,7 +15,7 @@ function rulesOf(text) {
             continue;
         }
         const negated = line.startsWith("!");
-        line = negated || line.startsWith("\\") ? line.slice(1) : line;
+        line = negated ? line.slice(1) : line;
         const directoryOnly = line.endsWith("/");
         line = line.replace(/\/+$/u, "");
         if (line === "") {
@@ -26,43 +28,54 @@ function rulesOf(text) {
         rules.push({
             negated,
             directoryOnly,
-            expression: globExpression(anchored ? pattern : `**/${pattern}`),
+            expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
         });
     }
     return rules;
 }
+function rulesIn(host, path, unread) {
+    try {
+        return rulesOf(host.readFile(path));
+    }
+    catch (error) {
+        if (host.kindOf(path) !== "absent") {
+            unread(path, message(error));
+        }
+        return [];
+    }
+}
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`, then
+ * the `.gitignore` files from its root down to the path's directory, a later pattern overriding
+ * an earlier one, though a file below an ignored directory stays ignored, as git cannot re-include
+ * it. A path outside `root` is not ignored. With no repository, the files at and below `root` are
+ * read; with one, the directories above `root` give patterns but are not tested. An unreadable
+ * ignore file ignores nothing, and `unread` is told it.
  */
-export function gitIgnored(host, root) {
+export function gitIgnored(host, root, unread = () => undefined) {
+    const found = repositoryOf(host, root);
+    const repository = found?.root;
+    const above = repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+    const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude, unread);
     const read = new Map();
     const rulesAt = (dir) => {
         let rules = read.get(dir);
         if (rules === undefined) {
-            try {
-                rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-            }
-            catch {
-                rules = [];
-            }
+            rules = rulesIn(host, joinPath(dir, ".gitignore"), unread);
             read.set(dir, rules);
         }
         return rules;
     };
-    /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
     const decided = (path, directory) => {
-        const dirs = [];
-        for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-            dirs.unshift(at);
-        }
-        dirs.unshift(root);
+        const sources = [
+            ...(repository === undefined ? [] : [[repository, excluded]]),
+            ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map((dir) => [dir, rulesAt(dir)]),
+        ];
         let ignored = false;
-        for (const dir of dirs) {
-            const below = relativePath(dir, path);
-            for (const rule of below === undefined ? [] : rulesAt(dir)) {
-                if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+        for (const [dir, rules] of sources) {
+            const below = relativePath(dir, path) ?? "";
+            for (const rule of rules) {
+                if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
                     ignored = !rule.negated;
                 }
             }

package/dist/src/import-bindings.js

@@ -2,7 +2,7 @@
  * The import bindings of one file: the names its import declarations bind, which only
  * the file itself can read.
  */
-import { isExportSpecifier, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
+import { isExportDeclaration, isExportSpecifier, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamedExports, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
 /** The extensions of the files whose import bindings are judged: no markup can read them. */
 const JUDGED = /\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/u;
 /** The compiler's `jsx` settings whose emit calls no factory the file must hold. */
@@ -13,41 +13,86 @@ const DOC_COMMENT = /\/\*\*[\s\S]*?\*\//gu;
 const DOC_REFERENCE = /\{[^{}]*\}|@see\s+[A-Za-z_$][\w$.]*/gu;
 /** The factory a pragma comment names: `@jsx h` or `@jsxFrag Fragment`. */
 const PRAGMA = /@jsx(?:Frag)?\s+([A-Za-z_$][\w$]*)/gu;
+const bindingsCache = new WeakMap();
 /**
- * The names one file's import declarations bind: the default, named and namespace names of
- * an `import` declaration, and the name of an `import x = require()` declaration that is
- * not exported. None is judged in a declaration file or a component file.
+ * Every name one import declaration binds, in source order: the default, named and
+ * namespace names of an `import` declaration and the name of an `import x = …` declaration.
+ * A namespace import and an import assignment bind a whole module.
  */
-export function importBindings(file) {
-    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
-        return [];
+export function declarationBindings(declaration) {
+    if (isImportEqualsDeclaration(declaration)) {
+        return [
+            {
+                name: declaration.name,
+                equals: {
+                    exported: (declaration.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword),
+                    external: isExternalModuleReference(declaration.moduleReference),
+                },
+            },
+        ];
     }
+    const clause = declaration.importClause;
     const found = [];
-    for (const statement of file.statements) {
-        if (isImportDeclaration(statement)) {
-            const clause = statement.importClause;
-            if (clause?.name !== undefined) {
-                found.push(clause.name);
-            }
-            const named = clause?.namedBindings;
-            if (named !== undefined && isNamespaceImport(named)) {
-                found.push(named.name);
-            }
-            else if (named !== undefined) {
-                for (const element of named.elements) {
-                    found.push(element.name);
-                }
-            }
-        }
-        else if (isImportEqualsDeclaration(statement) &&
-            isExternalModuleReference(statement.moduleReference) &&
-            isIdentifier(statement.name) &&
-            !(statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)) {
-            found.push(statement.name);
+    if (clause?.name !== undefined) {
+        found.push({ name: clause.name, imported: "default" });
+    }
+    const named = clause?.namedBindings;
+    if (named !== undefined && isNamespaceImport(named)) {
+        found.push({ name: named.name });
+    }
+    else if (named !== undefined) {
+        for (const element of named.elements) {
+            found.push({ name: element.name, imported: element.propertyName?.text ?? element.name.text });
         }
     }
     return found;
 }
+/** Every name one file's top-level import declarations bind, in source order. */
+export function bindingsOf(file) {
+    const known = bindingsCache.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = file.statements.flatMap((statement) => isImportDeclaration(statement) || isImportEqualsDeclaration(statement)
+        ? declarationBindings(statement)
+        : []);
+    bindingsCache.set(file, found);
+    return found;
+}
+/**
+ * The export names an import or a re-export declaration reads from the module it names,
+ * `undefined` standing for the whole module where a namespace or a star reads it; none for
+ * any other node.
+ */
+export function importedNames(node) {
+    if (isImportDeclaration(node)) {
+        return declarationBindings(node).map((binding) => binding.imported);
+    }
+    if (!isExportDeclaration(node)) {
+        return [];
+    }
+    const clause = node.exportClause;
+    return clause === undefined || !isNamedExports(clause)
+        ? [undefined]
+        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
+}
+/** The export names {@link importedNames} gives one node, without the whole module. */
+export function namesImported(node) {
+    return importedNames(node).flatMap((name) => name ?? []);
+}
+/**
+ * The bindings of one file that are judged as imports: those of {@link bindingsOf} but an
+ * `import x = …` that is exported or names no external module. None is judged in a
+ * declaration file or a component file.
+ */
+export function importBindings(file) {
+    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
+        return [];
+    }
+    return bindingsOf(file).flatMap((binding) => binding.equals !== undefined && (binding.equals.exported || !binding.equals.external)
+        ? []
+        : [binding.name]);
+}
 /** Whether one identifier names a binding in a local export, which reads it whatever it resolves to. */
 export function exportsLocally(use) {
     return isExportSpecifier(use.parent);