virtual-code-owners 7.0.1 → 7.0.2

package/dist/cli.js

@@ -24,61 +24,65 @@ Options:
   --dryRun                             Just validate inputs, don't generate
                                        outputs (default: false)
   -h, --help                           display help for command`;
-export function cli(pArguments = process.argv.slice(2), pOutStream = process.stdout, pErrorStream = process.stderr, pErrorExitCode = 1) {
-    try {
-        const lOptions = getOptions(pArguments);
-        if (lOptions.help) {
-            pOutStream.write(`${HELP_MESSAGE}${EOL}`);
-            return;
-        }
-        if (lOptions.version) {
-            pOutStream.write(`${VERSION}${EOL}`);
-            return;
-        }
-        main(lOptions, pErrorStream);
+export function cli(
+  pArguments = process.argv.slice(2),
+  pOutStream = process.stdout,
+  pErrorStream = process.stderr,
+  pErrorExitCode = 1,
+) {
+  try {
+    const lOptions = getOptions(pArguments);
+    if (lOptions.help) {
+      pOutStream.write(`${HELP_MESSAGE}${EOL}`);
+      return;
     }
-    catch (pError) {
-        pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
-        process.exitCode = pErrorExitCode;
+    if (lOptions.version) {
+      pOutStream.write(`${VERSION}${EOL}`);
+      return;
     }
+    main(lOptions, pErrorStream);
+  } catch (pError) {
+    pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
+    process.exitCode = pErrorExitCode;
+  }
 }
 function getOptions(pArguments) {
-    return parseArgs({
-        args: pArguments,
-        options: {
-            virtualCodeOwners: {
-                type: "string",
-                short: "v",
-                default: ".github/VIRTUAL-CODEOWNERS.txt",
-            },
-            virtualTeams: {
-                type: "string",
-                short: "t",
-                default: ".github/virtual-teams.yml",
-            },
-            codeOwners: {
-                type: "string",
-                short: "c",
-                default: ".github/CODEOWNERS",
-            },
-            emitLabeler: {
-                type: "boolean",
-                short: "l",
-                default: false,
-            },
-            labelerLocation: {
-                type: "string",
-                default: ".github/labeler.yml",
-            },
-            dryRun: {
-                type: "boolean",
-                default: false,
-            },
-            help: { type: "boolean", short: "h", default: false },
-            version: { type: "boolean", short: "V", default: false },
-        },
-        strict: true,
-        allowPositionals: true,
-        tokens: false,
-    }).values;
+  return parseArgs({
+    args: pArguments,
+    options: {
+      virtualCodeOwners: {
+        type: "string",
+        short: "v",
+        default: ".github/VIRTUAL-CODEOWNERS.txt",
+      },
+      virtualTeams: {
+        type: "string",
+        short: "t",
+        default: ".github/virtual-teams.yml",
+      },
+      codeOwners: {
+        type: "string",
+        short: "c",
+        default: ".github/CODEOWNERS",
+      },
+      emitLabeler: {
+        type: "boolean",
+        short: "l",
+        default: false,
+      },
+      labelerLocation: {
+        type: "string",
+        default: ".github/labeler.yml",
+      },
+      dryRun: {
+        type: "boolean",
+        default: false,
+      },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "V", default: false },
+    },
+    strict: true,
+    allowPositionals: true,
+    tokens: false,
+  }).values;
 }

package/dist/codeowners/generate.js

@@ -1,52 +1,63 @@
 import { EOL } from "node:os";
 import { isEmailIshUsername } from "../utensils.js";
-const DEFAULT_WARNING = `#${EOL}` +
-    `# DO NOT EDIT - this file is generated and your edits will be overwritten${EOL}` +
-    `#${EOL}` +
-    `# To make changes:${EOL}` +
-    `#${EOL}` +
-    `#   - edit .github/VIRTUAL-CODEOWNERS.txt${EOL}` +
-    `#   - and/ or add team members to .github/virtual-teams.yml${EOL}` +
-    `#   - run 'npx virtual-code-owners' (or 'npx virtual-code-owners --emitLabeler' if you also${EOL}` +
-    `#     want to generate a .github/labeler.yml)${EOL}` +
-    `#${EOL}${EOL}`;
-export default function generateCodeOwners(pVirtualCodeOwners, pTeamMap, pGeneratedWarning = DEFAULT_WARNING) {
-    return (pGeneratedWarning +
-        pVirtualCodeOwners
-            .filter((pLine) => pLine.type !== "ignorable-comment")
-            .map((pLine) => generateLine(pLine, pTeamMap))
-            .join(EOL));
+const DEFAULT_WARNING =
+  `#${EOL}` +
+  `# DO NOT EDIT - this file is generated and your edits will be overwritten${EOL}` +
+  `#${EOL}` +
+  `# To make changes:${EOL}` +
+  `#${EOL}` +
+  `#   - edit .github/VIRTUAL-CODEOWNERS.txt${EOL}` +
+  `#   - and/ or add team members to .github/virtual-teams.yml${EOL}` +
+  `#   - run 'npx virtual-code-owners' (or 'npx virtual-code-owners --emitLabeler' if you also${EOL}` +
+  `#     want to generate a .github/labeler.yml)${EOL}` +
+  `#${EOL}${EOL}`;
+export default function generateCodeOwners(
+  pVirtualCodeOwners,
+  pTeamMap,
+  pGeneratedWarning = DEFAULT_WARNING,
+) {
+  return (
+    pGeneratedWarning +
+    pVirtualCodeOwners
+      .filter((pLine) => pLine.type !== "ignorable-comment")
+      .map((pLine) => generateLine(pLine, pTeamMap))
+      .join(EOL)
+  );
 }
 function generateLine(pCSTLine, pTeamMap) {
-    if (pCSTLine.type === "rule") {
-        const lUserNames = uniq(pCSTLine.users.flatMap((pUser) => expandTeamToUserNames(pUser, pTeamMap)))
-            .sort(compareUserNames)
-            .join(" ");
-        return (pCSTLine.filesPattern +
-            pCSTLine.spaces +
-            lUserNames +
-            (pCSTLine.inlineComment ? ` #${pCSTLine.inlineComment}` : ""));
-    }
-    return pCSTLine.raw;
+  if (pCSTLine.type === "rule") {
+    const lUserNames = uniq(
+      pCSTLine.users.flatMap((pUser) => expandTeamToUserNames(pUser, pTeamMap)),
+    )
+      .sort(compareUserNames)
+      .join(" ");
+    return (
+      pCSTLine.filesPattern +
+      pCSTLine.spaces +
+      lUserNames +
+      (pCSTLine.inlineComment ? ` #${pCSTLine.inlineComment}` : "")
+    );
+  }
+  return pCSTLine.raw;
 }
 function expandTeamToUserNames(pUser, pTeamMap) {
-    if (pUser.type == "virtual-team-name") {
-        return stringifyTeamMembers(pTeamMap, pUser.bareName);
-    }
-    return [pUser.raw];
+  if (pUser.type === "virtual-team-name") {
+    return stringifyTeamMembers(pTeamMap, pUser.bareName);
+  }
+  return [pUser.raw];
 }
 function stringifyTeamMembers(pTeamMap, pTeamName) {
-    return (pTeamMap[pTeamName] ?? []).map(userNameToCodeOwner);
+  return (pTeamMap[pTeamName] ?? []).map(userNameToCodeOwner);
 }
 function userNameToCodeOwner(pUserName) {
-    if (isEmailIshUsername(pUserName)) {
-        return pUserName;
-    }
-    return `@${pUserName}`;
+  if (isEmailIshUsername(pUserName)) {
+    return pUserName;
+  }
+  return `@${pUserName}`;
 }
 function compareUserNames(pLeftName, pRightName) {
-    return pLeftName.toLowerCase() > pRightName.toLowerCase() ? 1 : -1;
+  return pLeftName.toLowerCase() > pRightName.toLowerCase() ? 1 : -1;
 }
 function uniq(pUserNames) {
-    return Array.from(new Set(pUserNames));
+  return Array.from(new Set(pUserNames));
 }

package/dist/labeler-yml/generate.js

@@ -1,46 +1,53 @@
 import { EOL } from "node:os";
-const DEFAULT_WARNING = `#${EOL}` +
-    `# DO NOT EDIT - this file is generated and your edits will be overwritten${EOL}` +
-    `#${EOL}` +
-    `# To make changes:${EOL}` +
-    `#${EOL}` +
-    `#   - edit .github/VIRTUAL-CODEOWNERS.txt${EOL}` +
-    `#   - and/ or add teams (& members) to .github/virtual-teams.yml${EOL}` +
-    `#   - run 'npx virtual-code-owners --emitLabeler'${EOL}` +
-    `#${EOL}${EOL}`;
-export default function generateLabelerYml(pCodeOwners, pTeamMap, pGeneratedWarning = DEFAULT_WARNING) {
-    let lReturnValue = pGeneratedWarning;
-    for (const lTeamName in pTeamMap) {
-        const lPatternsForTeam = getPatternsForTeam(pCodeOwners, lTeamName)
-            .map((pPattern) => `  - ${transformForYamlAndMinimatch(pPattern)}${EOL}`)
-            .join("");
-        if (lPatternsForTeam) {
-            lReturnValue += `${lTeamName}:${EOL}${lPatternsForTeam}${EOL}`;
-        }
+const DEFAULT_WARNING =
+  `#${EOL}` +
+  `# DO NOT EDIT - this file is generated and your edits will be overwritten${EOL}` +
+  `#${EOL}` +
+  `# To make changes:${EOL}` +
+  `#${EOL}` +
+  `#   - edit .github/VIRTUAL-CODEOWNERS.txt${EOL}` +
+  `#   - and/ or add teams (& members) to .github/virtual-teams.yml${EOL}` +
+  `#   - run 'npx virtual-code-owners --emitLabeler'${EOL}` +
+  `#${EOL}${EOL}`;
+export default function generateLabelerYml(
+  pCodeOwners,
+  pTeamMap,
+  pGeneratedWarning = DEFAULT_WARNING,
+) {
+  let lReturnValue = pGeneratedWarning;
+  for (const lTeamName in pTeamMap) {
+    const lPatternsForTeam = getPatternsForTeam(pCodeOwners, lTeamName)
+      .map((pPattern) => `  - ${transformForYamlAndMinimatch(pPattern)}${EOL}`)
+      .join("");
+    if (lPatternsForTeam) {
+      lReturnValue += `${lTeamName}:${EOL}${lPatternsForTeam}${EOL}`;
     }
-    return lReturnValue;
+  }
+  return lReturnValue;
 }
 function getPatternsForTeam(pCodeOwners, pTeamName) {
-    return (pCodeOwners
-        .filter((pLine) => {
-        return (pLine.type === "rule" &&
-            lineContainsTeamName(pLine, pTeamName));
+  return pCodeOwners
+    .filter((pLine) => {
+      return pLine.type === "rule" && lineContainsTeamName(pLine, pTeamName);
     })
-        .map((pLine) => pLine.filesPattern));
+    .map((pLine) => pLine.filesPattern);
 }
 function transformForYamlAndMinimatch(pOriginalString) {
-    let lReturnValue = pOriginalString;
-    if (pOriginalString === "*") {
-        lReturnValue = "**";
-    }
-    if (lReturnValue.startsWith("*")) {
-        lReturnValue = `"${lReturnValue}"`;
-    }
-    if (pOriginalString.endsWith("/")) {
-        lReturnValue = `${lReturnValue}**`;
-    }
-    return lReturnValue;
+  let lReturnValue = pOriginalString;
+  if (pOriginalString === "*") {
+    lReturnValue = "**";
+  }
+  if (lReturnValue.startsWith("*")) {
+    lReturnValue = `"${lReturnValue}"`;
+  }
+  if (pOriginalString.endsWith("/")) {
+    lReturnValue = `${lReturnValue}**`;
+  }
+  return lReturnValue;
 }
 function lineContainsTeamName(pLine, pTeamName) {
-    return pLine.users.some((pUser) => pUser.type === "virtual-team-name" && pUser.bareName === pTeamName);
+  return pLine.users.some(
+    (pUser) =>
+      pUser.type === "virtual-team-name" && pUser.bareName === pTeamName,
+  );
 }

package/dist/main.js

@@ -5,24 +5,28 @@ import generateLabelerYml from "./labeler-yml/generate.js";
 import readTeamMap from "./team-map/read.js";
 import readVirtualCodeOwners from "./virtual-code-owners/read.js";
 export function main(pOptions, pErrorStream) {
-    const lTeamMap = readTeamMap(pOptions.virtualTeams);
-    const lVirtualCodeOwners = readVirtualCodeOwners(pOptions.virtualCodeOwners, lTeamMap);
-    const lCodeOwnersContent = generateCodeOwners(lVirtualCodeOwners, lTeamMap);
+  const lTeamMap = readTeamMap(pOptions.virtualTeams);
+  const lVirtualCodeOwners = readVirtualCodeOwners(
+    pOptions.virtualCodeOwners,
+    lTeamMap,
+  );
+  const lCodeOwnersContent = generateCodeOwners(lVirtualCodeOwners, lTeamMap);
+  if (!pOptions.dryRun) {
+    writeFileSync(pOptions.codeOwners, lCodeOwnersContent, {
+      encoding: "utf-8",
+    });
+  }
+  if (pOptions.emitLabeler) {
+    const lLabelerContent = generateLabelerYml(lVirtualCodeOwners, lTeamMap);
     if (!pOptions.dryRun) {
-        writeFileSync(pOptions.codeOwners, lCodeOwnersContent, {
-            encoding: "utf-8",
-        });
-    }
-    if (pOptions.emitLabeler) {
-        const lLabelerContent = generateLabelerYml(lVirtualCodeOwners, lTeamMap);
-        if (!pOptions.dryRun) {
-            writeFileSync(pOptions.labelerLocation, lLabelerContent, {
-                encoding: "utf-8",
-            });
-        }
-        pErrorStream.write(`${EOL}Wrote '${pOptions.codeOwners}' AND '${pOptions.labelerLocation}'${EOL}${EOL}`);
-    }
-    else {
-        pErrorStream.write(`${EOL}Wrote '${pOptions.codeOwners}'${EOL}${EOL}`);
+      writeFileSync(pOptions.labelerLocation, lLabelerContent, {
+        encoding: "utf-8",
+      });
     }
+    pErrorStream.write(
+      `${EOL}Wrote '${pOptions.codeOwners}' AND '${pOptions.labelerLocation}'${EOL}${EOL}`,
+    );
+  } else {
+    pErrorStream.write(`${EOL}Wrote '${pOptions.codeOwners}'${EOL}${EOL}`);
+  }
 }

package/dist/team-map/read.js

@@ -4,27 +4,34 @@ import { EOL } from "node:os";
 import { parse as parseYaml } from "yaml";
 import virtualTeamsSchema from "./virtual-teams.schema.js";
 export default function readTeamMap(pVirtualTeamsFileName) {
-    const lVirtualTeamsAsAString = readFileSync(pVirtualTeamsFileName, {
-        encoding: "utf-8",
-    });
-    const lTeamMap = parseYaml(lVirtualTeamsAsAString);
-    assertTeamMapValid(lTeamMap, pVirtualTeamsFileName);
-    return lTeamMap;
+  const lVirtualTeamsAsAString = readFileSync(pVirtualTeamsFileName, {
+    encoding: "utf-8",
+  });
+  const lTeamMap = parseYaml(lVirtualTeamsAsAString);
+  assertTeamMapValid(lTeamMap, pVirtualTeamsFileName);
+  return lTeamMap;
 }
 function assertTeamMapValid(pTeamMap, pVirtualTeamsFileName) {
-    const ajv = new Ajv({
-        allErrors: true,
-        verbose: true,
-    });
-    if (!ajv.validate(virtualTeamsSchema, pTeamMap)) {
-        throw new Error(`This is not a valid virtual-teams.yml:${EOL}${formatAjvErrors(ajv.errors, pVirtualTeamsFileName)}.\n`);
-    }
+  const ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+  });
+  if (!ajv.validate(virtualTeamsSchema, pTeamMap)) {
+    throw new Error(
+      `This is not a valid virtual-teams.yml:${EOL}${formatAjvErrors(
+        ajv.errors,
+        pVirtualTeamsFileName,
+      )}.\n`,
+    );
+  }
 }
 function formatAjvErrors(pAjvErrors, pVirtualTeamsFileName) {
-    return pAjvErrors
-        .map((pAjvError) => formatAjvError(pAjvError, pVirtualTeamsFileName))
-        .join(EOL);
+  return pAjvErrors
+    .map((pAjvError) => formatAjvError(pAjvError, pVirtualTeamsFileName))
+    .join(EOL);
 }
 function formatAjvError(pAjvError, pVirtualTeamsFileName) {
-    return `${pVirtualTeamsFileName}: ${pAjvError.instancePath} - ${JSON.stringify(pAjvError.data)} ${pAjvError.message}`;
+  return `${pVirtualTeamsFileName}: ${
+    pAjvError.instancePath
+  } - ${JSON.stringify(pAjvError.data)} ${pAjvError.message}`;
 }

package/dist/team-map/virtual-teams.schema.js

@@ -1,15 +1,16 @@
 export default {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    title: "virtual teams schema for virtual-code-owners",
-    description: "a list of teams and their team members",
-    $id: "org.js.virtual-code-owners/7.0.0",
-    type: "object",
-    additionalProperties: {
-        type: "array",
-        items: {
-            type: "string",
-            description: "Username or e-mail address of a team member. (Don't prefix usernames with '@')",
-            pattern: "^[^@][^\\s]+$",
-        },
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "virtual teams schema for virtual-code-owners",
+  description: "a list of teams and their team members",
+  $id: "org.js.virtual-code-owners/7.0.0",
+  type: "object",
+  additionalProperties: {
+    type: "array",
+    items: {
+      type: "string",
+      description:
+        "Username or e-mail address of a team member. (Don't prefix usernames with '@')",
+      pattern: "^[^@][^\\s]+$",
     },
+  },
 };

package/dist/utensils.js

@@ -1,4 +1,4 @@
 export function isEmailIshUsername(pUsername) {
-    const lEmailIshUsernameRE = /^.+@.+$/;
-    return Boolean(pUsername.match(lEmailIshUsernameRE));
+  const lEmailIshUsernameRE = /^.+@.+$/;
+  return Boolean(pUsername.match(lEmailIshUsernameRE));
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "7.0.1";
+export const VERSION = "7.0.2";

package/dist/virtual-code-owners/anomalies.js

@@ -1,31 +1,32 @@
 export function getAnomalies(pVirtualCodeOwners) {
-    const weirdLines = pVirtualCodeOwners
-        .filter((pLine) => pLine.type === "unknown")
-        .map((pLine) => ({
-        ...pLine,
-        type: "invalid-line",
+  const weirdLines = pVirtualCodeOwners
+    .filter((pLine) => pLine.type === "unknown")
+    .map((pLine) => ({
+      ...pLine,
+      type: "invalid-line",
     }));
-    const weirdUsers = pVirtualCodeOwners.flatMap((pLine) => {
-        if (pLine.type === "rule") {
-            return pLine.users
-                .filter((pUser) => pUser.type === "invalid")
-                .map((pUser) => ({
-                ...pUser,
-                line: pLine.line,
-                type: "invalid-user",
-            }));
-        }
-        return [];
-    });
-    return weirdLines.concat(weirdUsers).sort(orderAnomaly);
+  const weirdUsers = pVirtualCodeOwners.flatMap((pLine) => {
+    if (pLine.type === "rule") {
+      return pLine.users
+        .filter((pUser) => pUser.type === "invalid")
+        .map((pUser) => ({
+          ...pUser,
+          line: pLine.line,
+          type: "invalid-user",
+        }));
+    }
+    return [];
+  });
+  return weirdLines.concat(weirdUsers).sort(orderAnomaly);
 }
 function orderAnomaly(pLeft, pRight) {
-    if (pLeft.line === pRight.line &&
-        pLeft.type === "invalid-user" &&
-        pRight.type === "invalid-user") {
-        return pLeft.userNumberWithinLine > pRight.userNumberWithinLine ? 1 : -1;
-    }
-    else {
-        return pLeft.line > pRight.line ? 1 : -1;
-    }
+  if (
+    pLeft.line === pRight.line &&
+    pLeft.type === "invalid-user" &&
+    pRight.type === "invalid-user"
+  ) {
+    return pLeft.userNumberWithinLine > pRight.userNumberWithinLine ? 1 : -1;
+  } else {
+    return pLeft.line > pRight.line ? 1 : -1;
+  }
 }

package/dist/virtual-code-owners/parse.js

@@ -1,63 +1,67 @@
 import { EOL } from "node:os";
 import { isEmailIshUsername } from "../utensils.js";
 export function parse(pVirtualCodeOwnersAsString, pTeamMap = {}) {
-    return pVirtualCodeOwnersAsString
-        .split(EOL)
-        .map((pUntreatedLine, pLineNo) => parseLine(pUntreatedLine, pTeamMap, pLineNo + 1));
+  return pVirtualCodeOwnersAsString
+    .split(EOL)
+    .map((pUntreatedLine, pLineNo) =>
+      parseLine(pUntreatedLine, pTeamMap, pLineNo + 1),
+    );
 }
 function parseLine(pUntreatedLine, pTeamMap, pLineNo) {
-    const lTrimmedLine = pUntreatedLine.trim();
-    const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
-    const lRule = lCommentSplitLine[0]?.match(/^(?<filesPattern>[^\s]+)(?<spaces>\s+)(?<userNames>.*)$/);
-    if (lTrimmedLine.startsWith("#!")) {
-        return { type: "ignorable-comment", line: pLineNo, raw: pUntreatedLine };
+  const lTrimmedLine = pUntreatedLine.trim();
+  const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
+  const lRule = lCommentSplitLine[0]?.match(
+    /^(?<filesPattern>[^\s]+)(?<spaces>\s+)(?<userNames>.*)$/,
+  );
+  if (lTrimmedLine.startsWith("#!")) {
+    return { type: "ignorable-comment", line: pLineNo, raw: pUntreatedLine };
+  }
+  if (lTrimmedLine.startsWith("#")) {
+    return { type: "comment", line: pLineNo, raw: pUntreatedLine };
+  }
+  if (!lRule?.groups) {
+    if (lTrimmedLine === "") {
+      return { type: "empty", line: pLineNo, raw: pUntreatedLine };
     }
-    if (lTrimmedLine.startsWith("#")) {
-        return { type: "comment", line: pLineNo, raw: pUntreatedLine };
-    }
-    if (!lRule?.groups) {
-        if (lTrimmedLine === "") {
-            return { type: "empty", line: pLineNo, raw: pUntreatedLine };
-        }
-        return { type: "unknown", line: pLineNo, raw: pUntreatedLine };
-    }
-    return {
-        type: "rule",
-        line: pLineNo,
-        filesPattern: lRule.groups.filesPattern,
-        spaces: lRule.groups.spaces,
-        users: parseUsers(lRule.groups.userNames, pTeamMap),
-        inlineComment: lCommentSplitLine[1] ?? "",
-        raw: pUntreatedLine,
-    };
+    return { type: "unknown", line: pLineNo, raw: pUntreatedLine };
+  }
+  return {
+    type: "rule",
+    line: pLineNo,
+    filesPattern: lRule.groups.filesPattern,
+    spaces: lRule.groups.spaces,
+    users: parseUsers(lRule.groups.userNames, pTeamMap),
+    inlineComment: lCommentSplitLine[1] ?? "",
+    raw: pUntreatedLine,
+  };
 }
 function parseUsers(pUserNamesString, pTeamMap) {
-    const lUserNames = pUserNamesString.split(/\s+/);
-    return lUserNames.map((pUserName, pIndex) => {
-        const lBareName = getBareUserName(pUserName);
-        return {
-            type: getUserNameType(pUserName, lBareName, pTeamMap),
-            userNumberWithinLine: pIndex + 1,
-            bareName: lBareName,
-            raw: pUserName,
-        };
-    });
+  const lUserNames = pUserNamesString.split(/\s+/);
+  return lUserNames.map((pUserName, pIndex) => {
+    const lBareName = getBareUserName(pUserName);
+    return {
+      type: getUserNameType(pUserName, lBareName, pTeamMap),
+      userNumberWithinLine: pIndex + 1,
+      bareName: lBareName,
+      raw: pUserName,
+    };
+  });
 }
 function getUserNameType(pUserName, pBareName, pTeamMap) {
-    if (isEmailIshUsername(pUserName)) {
-        return "e-mail-address";
+  if (isEmailIshUsername(pUserName)) {
+    return "e-mail-address";
+  }
+  if (pUserName.startsWith("@")) {
+    if (pTeamMap.hasOwnProperty(pBareName)) {
+      return "virtual-team-name";
     }
-    if (pUserName.startsWith("@")) {
-        if (pTeamMap.hasOwnProperty(pBareName)) {
-            return "virtual-team-name";
-        }
-        return "other-user-or-team";
-    }
-    return "invalid";
+    return "other-user-or-team";
+  }
+  return "invalid";
 }
 function getBareUserName(pUserName) {
-    if (pUserName.startsWith("@")) {
-        return pUserName.slice(1);
-    }
-    return pUserName;
+  if (pUserName.startsWith("@")) {
+    return pUserName.slice(1);
+  }
+  return pUserName;
 }

package/dist/virtual-code-owners/read.js

@@ -2,27 +2,39 @@ import { readFileSync } from "node:fs";
 import { EOL } from "node:os";
 import { getAnomalies } from "./anomalies.js";
 import { parse as parseVirtualCodeOwners } from "./parse.js";
-export default function readVirtualCodeOwners(pVirtualCodeOwnersFileName, pTeamMap) {
-    const lVirtualCodeOwnersAsAString = readFileSync(pVirtualCodeOwnersFileName, {
-        encoding: "utf-8",
-    });
-    const lVirtualCodeOwners = parseVirtualCodeOwners(lVirtualCodeOwnersAsAString, pTeamMap);
-    const lAnomalies = getAnomalies(lVirtualCodeOwners);
-    if (lAnomalies.length > 0) {
-        throw new Error(`This is not a valid virtual code-owners file:${EOL}${reportAnomalies(pVirtualCodeOwnersFileName, lAnomalies)}`);
-    }
-    return lVirtualCodeOwners;
+export default function readVirtualCodeOwners(
+  pVirtualCodeOwnersFileName,
+  pTeamMap,
+) {
+  const lVirtualCodeOwnersAsAString = readFileSync(pVirtualCodeOwnersFileName, {
+    encoding: "utf-8",
+  });
+  const lVirtualCodeOwners = parseVirtualCodeOwners(
+    lVirtualCodeOwnersAsAString,
+    pTeamMap,
+  );
+  const lAnomalies = getAnomalies(lVirtualCodeOwners);
+  if (lAnomalies.length > 0) {
+    throw new Error(
+      `This is not a valid virtual code-owners file:${EOL}${reportAnomalies(
+        pVirtualCodeOwnersFileName,
+        lAnomalies,
+      )}`,
+    );
+  }
+  return lVirtualCodeOwners;
 }
 function reportAnomalies(pFileName, pAnomalies) {
-    return pAnomalies
-        .map((pAnomaly) => {
-        if (pAnomaly.type === "invalid-line") {
-            return `${pFileName}:${pAnomaly.line}:1 invalid line - neither a rule, comment nor empty: "${pAnomaly.raw}"`;
-        }
-        else {
-            return (`${pFileName}:${pAnomaly.line}:1 invalid user or team name "${pAnomaly.raw}" (#${pAnomaly.userNumberWithinLine} on this line). ` +
-                `It should either start with "@" or be an e-mail address.`);
-        }
+  return pAnomalies
+    .map((pAnomaly) => {
+      if (pAnomaly.type === "invalid-line") {
+        return `${pFileName}:${pAnomaly.line}:1 invalid line - neither a rule, comment nor empty: "${pAnomaly.raw}"`;
+      } else {
+        return (
+          `${pFileName}:${pAnomaly.line}:1 invalid user or team name "${pAnomaly.raw}" (#${pAnomaly.userNumberWithinLine} on this line). ` +
+          `It should either start with "@" or be an e-mail address.`
+        );
+      }
     })
-        .join(EOL);
+    .join(EOL);
 }

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "virtual-code-owners",
-  "version": "7.0.1",
+  "version": "7.0.2",
   "description": "Makes your CODEOWNERS file liveable again",
   "type": "module",
-  "bin": "dist/run-cli.js",
+  "bin": {
+    "virtual-code-owners": "dist/run-cli.js"
+  },
   "files": [
     "dist/",
     "package.json",
@@ -25,7 +27,7 @@
   },
   "dependencies": {
     "ajv": "8.12.0",
-    "yaml": "2.3.3"
+    "yaml": "2.3.4"
   },
   "engines": {
     "node": "^18.11.0||>=20.0.0"