license-cop 1.4.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "license-cop",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "type": "commonjs",
   "bin": {
     "license-cop": "./src/bin/license-cop"
@@ -33,7 +33,9 @@
   "dependencies": {
     "@commander-js/extra-typings": "^12.0.0",
     "@npmcli/arborist": "^7.0.0",
+    "@pnpm/reviewing.dependencies-hierarchy": "^3.1.10",
     "axios": "^1.6.0",
+    "commander": "^12.0.0",
     "compare-versions": "^6.0.0-rc.1",
     "cosmiconfig": "^9.0.0",
     "deepmerge": "^4.3.1",
@@ -41,5 +43,6 @@
     "json5": "^2.2.3",
     "zod": "^3.22.3"
   },
-  "main": "./src/index.js"
-}
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts"
+}

package/src/index.d.ts

@@ -1,2 +1,3 @@
-export { LicenseCopOptions, checkLicenses } from "./lib/license-cop";
-export { AllowedPackage, CheckLicensesResult, ForbiddenLicenseResult, LicensedPackage, NoLicenseResult } from "./lib/result";
+export { checkLicenses } from "./lib/license-cop";
+export type { LicenseCopOptions } from "./lib/license-cop";
+export type { AllowedPackage, CheckLicensesResult, ForbiddenLicenseResult, LicensedPackage, NoLicenseResult } from "./lib/result";

package/src/index.js

@@ -1,34 +1,10 @@
 "use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    AllowedPackage: function() {
-        return _result.AllowedPackage;
-    },
-    CheckLicensesResult: function() {
-        return _result.CheckLicensesResult;
-    },
-    ForbiddenLicenseResult: function() {
-        return _result.ForbiddenLicenseResult;
-    },
-    LicenseCopOptions: function() {
-        return _licensecop.LicenseCopOptions;
-    },
-    LicensedPackage: function() {
-        return _result.LicensedPackage;
-    },
-    NoLicenseResult: function() {
-        return _result.NoLicenseResult;
-    },
-    checkLicenses: function() {
+Object.defineProperty(exports, "checkLicenses", {
+    enumerable: true,
+    get: function() {
         return _licensecop.checkLicenses;
     }
 });
 const _licensecop = require("./lib/license-cop");
-const _result = require("./lib/result");
 
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../packages/license-cop/src/index.ts"],"sourcesContent":["export { LicenseCopOptions, checkLicenses } from \"./lib/license-cop\";\nexport {\n  AllowedPackage,\n  CheckLicensesResult,\n  ForbiddenLicenseResult,\n  LicensedPackage,\n  NoLicenseResult\n} from \"./lib/result\";\n"],"names":["AllowedPackage","CheckLicensesResult","ForbiddenLicenseResult","LicenseCopOptions","LicensedPackage","NoLicenseResult","checkLicenses"],"mappings":";;;;;;;;IAEEA,cAAc;eAAdA,sBAAc;;IACdC,mBAAmB;eAAnBA,2BAAmB;;IACnBC,sBAAsB;eAAtBA,8BAAsB;;IAJfC,iBAAiB;eAAjBA,6BAAiB;;IAKxBC,eAAe;eAAfA,uBAAe;;IACfC,eAAe;eAAfA,uBAAe;;IANWC,aAAa;eAAbA,yBAAa;;;4BAAQ;wBAO1C"}
+{"version":3,"sources":["../../../../packages/license-cop/src/index.ts"],"sourcesContent":["export { checkLicenses } from \"./lib/license-cop\";\nexport type { LicenseCopOptions } from \"./lib/license-cop\";\nexport type {\n  AllowedPackage,\n  CheckLicensesResult,\n  ForbiddenLicenseResult,\n  LicensedPackage,\n  NoLicenseResult\n} from \"./lib/result\";\n\n// The following is included to insure that Nx doesn't remove \"commander\"\n// as a dependency from packages/license-cop/package.json.\n//\n// This is necessary because the @nx/dependency-checks eslint rule will\n// remove commander if the license-cop package never imports from it directly.\n//\n// This approach was chosen over using the ignoredDependencies config option\n// to insure that the same eslint rule continues to catch when the commander\n// version falls out of sync with the @commander-js/extra-typings version.\nimport type { Command as _Command } from \"commander\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype _UnusedCommand = _Command;\n"],"names":["checkLicenses"],"rangeMappings":";;;;;;;","mappings":";+BAASA;;;eAAAA,yBAAa;;;4BAAQ"}

package/src/lib/cli/commands/init.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/init.ts"],"sourcesContent":["import { writeFile } from \"fs/promises\";\nimport { join } from \"path\";\nimport logger from \"../../logger\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\n\nconst defaultConfig = `{\n  \"$schema\": \"https://license-cop.js.org/schema.json\",\n  \"licenses\": [\"MIT\", \"ISC\", \"Apache-2.0\"],\n  \"packages\": []\n}\n`;\n\nexport const initCommand = createCommandWithGlobalOptions()\n  .name(\"init\")\n  .description(\"Create a new license-cop configuration file\")\n  .action(async options => {\n    const { directory } = options;\n\n    await initCommandAction(directory);\n  });\n\nexport const initCommandAction = async (rootDir: string) => {\n  logger.log(\"Setting up a new license-cop config file...\");\n\n  const configPath = join(rootDir, \".licenses.json\");\n  logger.verbose(`Writing config file to: ${configPath}`);\n  await writeFile(configPath, defaultConfig);\n\n  logger.log(\"Done!\");\n  logger.log(\"Run `npx license-cop` to check your dependencies\");\n};\n"],"names":["initCommand","initCommandAction","defaultConfig","createCommandWithGlobalOptions","name","description","action","options","directory","rootDir","logger","log","configPath","join","verbose","writeFile"],"mappings":";;;;;;;;IAYaA,WAAW;eAAXA;;IASAC,iBAAiB;eAAjBA;;;0BArBa;sBACL;wBACF;+BAC4B;AAE/C,MAAMC,gBAAgB,CAAC;;;;;AAKvB,CAAC;AAEM,MAAMF,cAAcG,IAAAA,6CAA8B,IACtDC,IAAI,CAAC,QACLC,WAAW,CAAC,+CACZC,MAAM,CAAC,OAAMC;IACZ,MAAM,EAAEC,SAAS,EAAE,GAAGD;IAEtB,MAAMN,kBAAkBO;AAC1B;AAEK,MAAMP,oBAAoB,OAAOQ;IACtCC,eAAM,CAACC,GAAG,CAAC;IAEX,MAAMC,aAAaC,IAAAA,UAAI,EAACJ,SAAS;IACjCC,eAAM,CAACI,OAAO,CAAC,CAAC,wBAAwB,EAAEF,WAAW,CAAC;IACtD,MAAMG,IAAAA,mBAAS,EAACH,YAAYV;IAE5BQ,eAAM,CAACC,GAAG,CAAC;IACXD,eAAM,CAACC,GAAG,CAAC;AACb"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/init.ts"],"sourcesContent":["import { writeFile } from \"fs/promises\";\nimport { join } from \"path\";\nimport logger from \"../../logger\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\n\nconst defaultConfig = `{\n  \"$schema\": \"https://license-cop.js.org/schema.json\",\n  \"licenses\": [\"MIT\", \"ISC\", \"Apache-2.0\"],\n  \"packages\": []\n}\n`;\n\nexport const initCommand = createCommandWithGlobalOptions()\n  .name(\"init\")\n  .description(\"Create a new license-cop configuration file\")\n  .action(async options => {\n    const { directory } = options;\n\n    await initCommandAction(directory);\n  });\n\nexport const initCommandAction = async (rootDir: string) => {\n  logger.log(\"Setting up a new license-cop config file...\");\n\n  const configPath = join(rootDir, \".licenses.json\");\n  logger.verbose(`Writing config file to: ${configPath}`);\n  await writeFile(configPath, defaultConfig);\n\n  logger.log(\"Done!\");\n  logger.log(\"Run `npx license-cop` to check your dependencies\");\n};\n"],"names":["initCommand","initCommandAction","defaultConfig","createCommandWithGlobalOptions","name","description","action","options","directory","rootDir","logger","log","configPath","join","verbose","writeFile"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAYaA,WAAW;eAAXA;;IASAC,iBAAiB;eAAjBA;;;0BArBa;sBACL;wBACF;+BAC4B;AAE/C,MAAMC,gBAAgB,CAAC;;;;;AAKvB,CAAC;AAEM,MAAMF,cAAcG,IAAAA,6CAA8B,IACtDC,IAAI,CAAC,QACLC,WAAW,CAAC,+CACZC,MAAM,CAAC,OAAMC;IACZ,MAAM,EAAEC,SAAS,EAAE,GAAGD;IAEtB,MAAMN,kBAAkBO;AAC1B;AAEK,MAAMP,oBAAoB,OAAOQ;IACtCC,eAAM,CAACC,GAAG,CAAC;IAEX,MAAMC,aAAaC,IAAAA,UAAI,EAACJ,SAAS;IACjCC,eAAM,CAACI,OAAO,CAAC,CAAC,wBAAwB,EAAEF,WAAW,CAAC;IACtD,MAAMG,IAAAA,mBAAS,EAACH,YAAYV;IAE5BQ,eAAM,CAACC,GAAG,CAAC;IACXD,eAAM,CAACC,GAAG,CAAC;AACb"}

package/src/lib/cli/commands/main.js

@@ -7,9 +7,9 @@ Object.defineProperty(exports, "mainCommand", {
 });
 const _path = require("path");
 const _loadconfig = require("../../config/load-config");
+const _packagejson = require("../../dependency/package-json");
 const _licensecop = require("../../license-cop");
 const _logger = require("../../logger");
-const _packagejson = require("../../package-json");
 const _createcommand = require("../create-command");
 const _reportfailure = require("../report-failure");
 const _reportsuccess = require("../report-success");

package/src/lib/cli/commands/main.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/main.ts"],"sourcesContent":["import { join } from \"path\";\nimport { loadConfig } from \"../../config/load-config\";\nimport { checkLicenses, LicenseCopOptions } from \"../../license-cop\";\nimport logger from \"../../logger\";\nimport { readPackageJson } from \"../../package-json\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\nimport { reportFailure } from \"../report-failure\";\nimport { reportSuccess } from \"../report-success\";\nimport { initCommandAction } from \"./init\";\n\nexport const mainCommand = createCommandWithGlobalOptions()\n  .name(\"license-cop\")\n  .description(\"Yet another license checker tool for your dependencies; focused on simplicity\")\n  .option(\"-D,--include-dev\", \"Include dev dependencies\", false)\n  .option(\"--dev-only\", \"Only check dev dependencies\", false)\n  .option(\"--init\", \"An alias for 'license-cop init'\", false)\n  .action(async options => {\n    const { directory, includeDev, devOnly } = options;\n\n    if (options.init) {\n      await initCommandAction(directory);\n      return;\n    }\n\n    await runLicenseCop(directory, includeDev, devOnly);\n  });\n\nconst runLicenseCop = async (\n  directory: string,\n  includeDevDependencies: boolean,\n  devDependenciesOnly: boolean\n) => {\n  logger.verbose(`Using directory: ${directory}`);\n\n  const productName = await getProductName(directory);\n  logger.log(`Scanning dependencies of: ${productName}`);\n\n  const config = await loadConfig(directory);\n\n  const options: LicenseCopOptions = {\n    allowedLicenses: config.licenses,\n    allowedPackages: config.packages,\n\n    workingDirectory: directory,\n    includeDevDependencies: includeDevDependencies ?? config.includeDevDependencies,\n    devDependenciesOnly: devDependenciesOnly ?? config.devDependenciesOnly\n  };\n\n  const result = await checkLicenses(options);\n\n  if (result.noLicenses.size > 0 || result.forbiddenLicenses.size > 0) {\n    reportFailure(result);\n    process.exitCode = 1;\n  } else {\n    reportSuccess(result);\n  }\n};\n\nconst getProductName = async (directory: string): Promise<string> => {\n  const packageJsonPath = join(directory, \"package.json\");\n  const packageJson = await readPackageJson(packageJsonPath);\n  return packageJson.name;\n};\n"],"names":["mainCommand","createCommandWithGlobalOptions","name","description","option","action","options","directory","includeDev","devOnly","init","initCommandAction","runLicenseCop","includeDevDependencies","devDependenciesOnly","logger","verbose","productName","getProductName","log","config","loadConfig","allowedLicenses","licenses","allowedPackages","packages","workingDirectory","result","checkLicenses","noLicenses","size","forbiddenLicenses","reportFailure","process","exitCode","reportSuccess","packageJsonPath","join","packageJson","readPackageJson"],"mappings":";+BAUaA;;;eAAAA;;;sBAVQ;4BACM;4BACsB;wBAC9B;6BACa;+BACe;+BACjB;+BACA;sBACI;AAE3B,MAAMA,cAAcC,IAAAA,6CAA8B,IACtDC,IAAI,CAAC,eACLC,WAAW,CAAC,iFACZC,MAAM,CAAC,oBAAoB,4BAA4B,OACvDA,MAAM,CAAC,cAAc,+BAA+B,OACpDA,MAAM,CAAC,UAAU,mCAAmC,OACpDC,MAAM,CAAC,OAAMC;IACZ,MAAM,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAE,GAAGH;IAE3C,IAAIA,QAAQI,IAAI,EAAE;QAChB,MAAMC,IAAAA,uBAAiB,EAACJ;QACxB;IACF;IAEA,MAAMK,cAAcL,WAAWC,YAAYC;AAC7C;AAEF,MAAMG,gBAAgB,OACpBL,WACAM,wBACAC;IAEAC,eAAM,CAACC,OAAO,CAAC,CAAC,iBAAiB,EAAET,UAAU,CAAC;IAE9C,MAAMU,cAAc,MAAMC,eAAeX;IACzCQ,eAAM,CAACI,GAAG,CAAC,CAAC,0BAA0B,EAAEF,YAAY,CAAC;IAErD,MAAMG,SAAS,MAAMC,IAAAA,sBAAU,EAACd;IAEhC,MAAMD,UAA6B;QACjCgB,iBAAiBF,OAAOG,QAAQ;QAChCC,iBAAiBJ,OAAOK,QAAQ;QAEhCC,kBAAkBnB;QAClBM,wBAAwBA,iCAAAA,yBAA0BO,OAAOP,sBAAsB;QAC/EC,qBAAqBA,8BAAAA,sBAAuBM,OAAON,mBAAmB;IACxE;IAEA,MAAMa,SAAS,MAAMC,IAAAA,yBAAa,EAACtB;IAEnC,IAAIqB,OAAOE,UAAU,CAACC,IAAI,GAAG,KAAKH,OAAOI,iBAAiB,CAACD,IAAI,GAAG,GAAG;QACnEE,IAAAA,4BAAa,EAACL;QACdM,QAAQC,QAAQ,GAAG;IACrB,OAAO;QACLC,IAAAA,4BAAa,EAACR;IAChB;AACF;AAEA,MAAMT,iBAAiB,OAAOX;IAC5B,MAAM6B,kBAAkBC,IAAAA,UAAI,EAAC9B,WAAW;IACxC,MAAM+B,cAAc,MAAMC,IAAAA,4BAAe,EAACH;IAC1C,OAAOE,YAAYpC,IAAI;AACzB"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/main.ts"],"sourcesContent":["import { join } from \"path\";\nimport { loadConfig } from \"../../config/load-config\";\nimport { readPackageJson } from \"../../dependency/package-json\";\nimport { checkLicenses, LicenseCopOptions } from \"../../license-cop\";\nimport logger from \"../../logger\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\nimport { reportFailure } from \"../report-failure\";\nimport { reportSuccess } from \"../report-success\";\nimport { initCommandAction } from \"./init\";\n\nexport const mainCommand = createCommandWithGlobalOptions()\n  .name(\"license-cop\")\n  .description(\"Yet another license checker tool for your dependencies; focused on simplicity\")\n  .option(\"-D,--include-dev\", \"Include dev dependencies\", false)\n  .option(\"--dev-only\", \"Only check dev dependencies\", false)\n  .option(\"--init\", \"An alias for 'license-cop init'\", false)\n  .action(async options => {\n    const { directory, includeDev, devOnly } = options;\n\n    if (options.init) {\n      await initCommandAction(directory);\n      return;\n    }\n\n    await runLicenseCop(directory, includeDev, devOnly);\n  });\n\nconst runLicenseCop = async (\n  directory: string,\n  includeDevDependencies: boolean,\n  devDependenciesOnly: boolean\n) => {\n  logger.verbose(`Using directory: ${directory}`);\n\n  const productName = await getProductName(directory);\n  logger.log(`Scanning dependencies of: ${productName}`);\n\n  const config = await loadConfig(directory);\n\n  const options: LicenseCopOptions = {\n    allowedLicenses: config.licenses,\n    allowedPackages: config.packages,\n\n    workingDirectory: directory,\n    includeDevDependencies: includeDevDependencies ?? config.includeDevDependencies,\n    devDependenciesOnly: devDependenciesOnly ?? config.devDependenciesOnly\n  };\n\n  const result = await checkLicenses(options);\n\n  if (result.noLicenses.size > 0 || result.forbiddenLicenses.size > 0) {\n    reportFailure(result);\n    process.exitCode = 1;\n  } else {\n    reportSuccess(result);\n  }\n};\n\nconst getProductName = async (directory: string): Promise<string> => {\n  const packageJsonPath = join(directory, \"package.json\");\n  const packageJson = await readPackageJson(packageJsonPath);\n  return packageJson.name;\n};\n"],"names":["mainCommand","createCommandWithGlobalOptions","name","description","option","action","options","directory","includeDev","devOnly","init","initCommandAction","runLicenseCop","includeDevDependencies","devDependenciesOnly","logger","verbose","productName","getProductName","log","config","loadConfig","allowedLicenses","licenses","allowedPackages","packages","workingDirectory","result","checkLicenses","noLicenses","size","forbiddenLicenses","reportFailure","process","exitCode","reportSuccess","packageJsonPath","join","packageJson","readPackageJson"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAUaA;;;eAAAA;;;sBAVQ;4BACM;6BACK;4BACiB;wBAC9B;+BAC4B;+BACjB;+BACA;sBACI;AAE3B,MAAMA,cAAcC,IAAAA,6CAA8B,IACtDC,IAAI,CAAC,eACLC,WAAW,CAAC,iFACZC,MAAM,CAAC,oBAAoB,4BAA4B,OACvDA,MAAM,CAAC,cAAc,+BAA+B,OACpDA,MAAM,CAAC,UAAU,mCAAmC,OACpDC,MAAM,CAAC,OAAMC;IACZ,MAAM,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAE,GAAGH;IAE3C,IAAIA,QAAQI,IAAI,EAAE;QAChB,MAAMC,IAAAA,uBAAiB,EAACJ;QACxB;IACF;IAEA,MAAMK,cAAcL,WAAWC,YAAYC;AAC7C;AAEF,MAAMG,gBAAgB,OACpBL,WACAM,wBACAC;IAEAC,eAAM,CAACC,OAAO,CAAC,CAAC,iBAAiB,EAAET,UAAU,CAAC;IAE9C,MAAMU,cAAc,MAAMC,eAAeX;IACzCQ,eAAM,CAACI,GAAG,CAAC,CAAC,0BAA0B,EAAEF,YAAY,CAAC;IAErD,MAAMG,SAAS,MAAMC,IAAAA,sBAAU,EAACd;IAEhC,MAAMD,UAA6B;QACjCgB,iBAAiBF,OAAOG,QAAQ;QAChCC,iBAAiBJ,OAAOK,QAAQ;QAEhCC,kBAAkBnB;QAClBM,wBAAwBA,iCAAAA,yBAA0BO,OAAOP,sBAAsB;QAC/EC,qBAAqBA,8BAAAA,sBAAuBM,OAAON,mBAAmB;IACxE;IAEA,MAAMa,SAAS,MAAMC,IAAAA,yBAAa,EAACtB;IAEnC,IAAIqB,OAAOE,UAAU,CAACC,IAAI,GAAG,KAAKH,OAAOI,iBAAiB,CAACD,IAAI,GAAG,GAAG;QACnEE,IAAAA,4BAAa,EAACL;QACdM,QAAQC,QAAQ,GAAG;IACrB,OAAO;QACLC,IAAAA,4BAAa,EAACR;IAChB;AACF;AAEA,MAAMT,iBAAiB,OAAOX;IAC5B,MAAM6B,kBAAkBC,IAAAA,UAAI,EAAC9B,WAAW;IACxC,MAAM+B,cAAc,MAAMC,IAAAA,4BAAe,EAACH;IAC1C,OAAOE,YAAYpC,IAAI;AACzB"}

package/src/lib/cli/commands/version.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "versionCommand", {
     }
 });
 const _path = require("path");
+const _packagejson = require("../../dependency/package-json");
 const _logger = require("../../logger");
-const _packagejson = require("../../package-json");
 const _createcommand = require("../create-command");
 const versionCommand = (0, _createcommand.createCommandWithGlobalOptions)().name("-v").alias("--version").description("Print the installed version of license-cop").action(async ()=>{
     await printPackageVersion();

package/src/lib/cli/commands/version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/version.ts"],"sourcesContent":["import { join } from \"path\";\nimport logger from \"../../logger\";\nimport { readPackageJson } from \"../../package-json\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\n\nexport const versionCommand = createCommandWithGlobalOptions()\n  .name(\"-v\")\n  .alias(\"--version\")\n  .description(\"Print the installed version of license-cop\")\n  .action(async () => {\n    await printPackageVersion();\n  });\n\nconst printPackageVersion = async (): Promise<void> => {\n  const packageJsonLocation = join(__dirname, \"../../../../package.json\");\n  const { version } = await readPackageJson(packageJsonLocation);\n  logger.log(`v${version}`);\n};\n"],"names":["versionCommand","createCommandWithGlobalOptions","name","alias","description","action","printPackageVersion","packageJsonLocation","join","__dirname","version","readPackageJson","logger","log"],"mappings":";+BAKaA;;;eAAAA;;;sBALQ;wBACF;6BACa;+BACe;AAExC,MAAMA,iBAAiBC,IAAAA,6CAA8B,IACzDC,IAAI,CAAC,MACLC,KAAK,CAAC,aACNC,WAAW,CAAC,8CACZC,MAAM,CAAC;IACN,MAAMC;AACR;AAEF,MAAMA,sBAAsB;IAC1B,MAAMC,sBAAsBC,IAAAA,UAAI,EAACC,WAAW;IAC5C,MAAM,EAAEC,OAAO,EAAE,GAAG,MAAMC,IAAAA,4BAAe,EAACJ;IAC1CK,eAAM,CAACC,GAAG,CAAC,CAAC,CAAC,EAAEH,QAAQ,CAAC;AAC1B"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/cli/commands/version.ts"],"sourcesContent":["import { join } from \"path\";\nimport { readPackageJson } from \"../../dependency/package-json\";\nimport logger from \"../../logger\";\nimport { createCommandWithGlobalOptions } from \"../create-command\";\n\nexport const versionCommand = createCommandWithGlobalOptions()\n  .name(\"-v\")\n  .alias(\"--version\")\n  .description(\"Print the installed version of license-cop\")\n  .action(async () => {\n    await printPackageVersion();\n  });\n\nconst printPackageVersion = async (): Promise<void> => {\n  const packageJsonLocation = join(__dirname, \"../../../../package.json\");\n  const { version } = await readPackageJson(packageJsonLocation);\n  logger.log(`v${version}`);\n};\n"],"names":["versionCommand","createCommandWithGlobalOptions","name","alias","description","action","printPackageVersion","packageJsonLocation","join","__dirname","version","readPackageJson","logger","log"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":";+BAKaA;;;eAAAA;;;sBALQ;6BACW;wBACb;+BAC4B;AAExC,MAAMA,iBAAiBC,IAAAA,6CAA8B,IACzDC,IAAI,CAAC,MACLC,KAAK,CAAC,aACNC,WAAW,CAAC,8CACZC,MAAM,CAAC;IACN,MAAMC;AACR;AAEF,MAAMA,sBAAsB;IAC1B,MAAMC,sBAAsBC,IAAAA,UAAI,EAACC,WAAW;IAC5C,MAAM,EAAEC,OAAO,EAAE,GAAG,MAAMC,IAAAA,4BAAe,EAACJ;IAC1CK,eAAM,CAACC,GAAG,CAAC,CAAC,CAAC,EAAEH,QAAQ,CAAC;AAC1B"}

package/src/lib/cli/create-command.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/create-command.ts"],"sourcesContent":["import { Command } from \"@commander-js/extra-typings\";\nimport logger from \"../logger\";\n\nexport const createCommandWithGlobalOptions = () =>\n  new Command()\n    .option(\"--verbose\", \"Enable verbose logging\")\n    .option(\n      \"-d,--directory <directory>\",\n      \"The directory of the project. Defaults to the current working directory.\",\n      process.cwd()\n    )\n    .hook(\"preAction\", thisCommand => {\n      const { verbose } = thisCommand.opts();\n\n      if (verbose) {\n        logger.enableVerboseLogging();\n      }\n    });\n"],"names":["createCommandWithGlobalOptions","Command","option","process","cwd","hook","thisCommand","verbose","opts","logger","enableVerboseLogging"],"mappings":";+BAGaA;;;eAAAA;;;8BAHW;wBACL;AAEZ,MAAMA,iCAAiC,IAC5C,IAAIC,qBAAO,GACRC,MAAM,CAAC,aAAa,0BACpBA,MAAM,CACL,8BACA,4EACAC,QAAQC,GAAG,IAEZC,IAAI,CAAC,aAAaC,CAAAA;QACjB,MAAM,EAAEC,OAAO,EAAE,GAAGD,YAAYE,IAAI;QAEpC,IAAID,SAAS;YACXE,eAAM,CAACC,oBAAoB;QAC7B;IACF"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/create-command.ts"],"sourcesContent":["import { Command } from \"@commander-js/extra-typings\";\nimport logger from \"../logger\";\n\nexport const createCommandWithGlobalOptions = () =>\n  new Command()\n    .option(\"--verbose\", \"Enable verbose logging\")\n    .option(\n      \"-d,--directory <directory>\",\n      \"The directory of the project. Defaults to the current working directory.\",\n      process.cwd()\n    )\n    .hook(\"preAction\", thisCommand => {\n      const { verbose } = thisCommand.opts();\n\n      if (verbose) {\n        logger.enableVerboseLogging();\n      }\n    });\n"],"names":["createCommandWithGlobalOptions","Command","option","process","cwd","hook","thisCommand","verbose","opts","logger","enableVerboseLogging"],"rangeMappings":";;;;;;;;;;;;;;","mappings":";+BAGaA;;;eAAAA;;;8BAHW;wBACL;AAEZ,MAAMA,iCAAiC,IAC5C,IAAIC,qBAAO,GACRC,MAAM,CAAC,aAAa,0BACpBA,MAAM,CACL,8BACA,4EACAC,QAAQC,GAAG,IAEZC,IAAI,CAAC,aAAaC,CAAAA;QACjB,MAAM,EAAEC,OAAO,EAAE,GAAGD,YAAYE,IAAI;QAEpC,IAAID,SAAS;YACXE,eAAM,CAACC,oBAAoB;QAC7B;IACF"}

package/src/lib/cli/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/index.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { initCommand } from \"./commands/init\";\nimport { mainCommand } from \"./commands/main\";\nimport { versionCommand } from \"./commands/version\";\n\nexport const main = async (args: string[]): Promise<void> => {\n  logger.enableLogging();\n  await program.parseAsync(args);\n};\n\nconst program = mainCommand.addCommand(initCommand).addCommand(versionCommand);\n"],"names":["main","args","logger","enableLogging","program","parseAsync","mainCommand","addCommand","initCommand","versionCommand"],"mappings":";+BAKaA;;;eAAAA;;;wBALM;sBACS;sBACA;yBACG;AAExB,MAAMA,OAAO,OAAOC;IACzBC,eAAM,CAACC,aAAa;IACpB,MAAMC,QAAQC,UAAU,CAACJ;AAC3B;AAEA,MAAMG,UAAUE,iBAAW,CAACC,UAAU,CAACC,iBAAW,EAAED,UAAU,CAACE,uBAAc"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/index.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { initCommand } from \"./commands/init\";\nimport { mainCommand } from \"./commands/main\";\nimport { versionCommand } from \"./commands/version\";\n\nexport const main = async (args: string[]): Promise<void> => {\n  logger.enableLogging();\n  await program.parseAsync(args);\n};\n\nconst program = mainCommand.addCommand(initCommand).addCommand(versionCommand);\n"],"names":["main","args","logger","enableLogging","program","parseAsync","mainCommand","addCommand","initCommand","versionCommand"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";+BAKaA;;;eAAAA;;;wBALM;sBACS;sBACA;yBACG;AAExB,MAAMA,OAAO,OAAOC;IACzBC,eAAM,CAACC,aAAa;IACpB,MAAMC,QAAQC,UAAU,CAACJ;AAC3B;AAEA,MAAMG,UAAUE,iBAAW,CAACC,UAAU,CAACC,iBAAW,EAAED,UAAU,CAACE,uBAAc"}

package/src/lib/cli/report-failure.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/report-failure.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { CheckLicensesResult, ForbiddenLicenseResult, NoLicenseResult } from \"../result\";\n\nexport const reportFailure = (result: CheckLicensesResult): void => {\n  const { noLicenses, forbiddenLicenses } = result;\n\n  logger.log(\"Found the following issues...\\n\");\n\n  if (noLicenses.size > 0) {\n    logNoLicenseIssues(noLicenses);\n  }\n\n  if (forbiddenLicenses.size > 0) {\n    logForbiddenLicenseIssues(forbiddenLicenses);\n  }\n};\n\nconst logNoLicenseIssues = (noLicenseResults: Set<NoLicenseResult>) => {\n  logger.error(\"Packages with no license:\");\n\n  for (const result of noLicenseResults.values()) {\n    const { name, version } = result;\n    logger.error(`${name}@${version}`);\n  }\n\n  logger.error(\"\");\n};\n\nconst logForbiddenLicenseIssues = (forbiddenLicensesResults: Set<ForbiddenLicenseResult>): void => {\n  logger.error(\"Packages with forbidden licenses:\");\n\n  for (const result of forbiddenLicensesResults.values()) {\n    const { name, version, licenseIdentifiers, spdxExpression } = result;\n\n    const licenseDetails =\n      licenseIdentifiers === spdxExpression\n        ? licenseIdentifiers\n        : `${licenseIdentifiers} from ${spdxExpression}`;\n\n    logger.error(`${name}@${version} - ${licenseDetails}`);\n  }\n};\n"],"names":["reportFailure","result","noLicenses","forbiddenLicenses","logger","log","size","logNoLicenseIssues","logForbiddenLicenseIssues","noLicenseResults","error","values","name","version","forbiddenLicensesResults","licenseIdentifiers","spdxExpression","licenseDetails"],"mappings":";+BAGaA;;;eAAAA;;;wBAHM;AAGZ,MAAMA,gBAAgB,CAACC;IAC5B,MAAM,EAAEC,UAAU,EAAEC,iBAAiB,EAAE,GAAGF;IAE1CG,eAAM,CAACC,GAAG,CAAC;IAEX,IAAIH,WAAWI,IAAI,GAAG,GAAG;QACvBC,mBAAmBL;IACrB;IAEA,IAAIC,kBAAkBG,IAAI,GAAG,GAAG;QAC9BE,0BAA0BL;IAC5B;AACF;AAEA,MAAMI,qBAAqB,CAACE;IAC1BL,eAAM,CAACM,KAAK,CAAC;IAEb,KAAK,MAAMT,UAAUQ,iBAAiBE,MAAM,GAAI;QAC9C,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAE,GAAGZ;QAC1BG,eAAM,CAACM,KAAK,CAAC,CAAC,EAAEE,KAAK,CAAC,EAAEC,QAAQ,CAAC;IACnC;IAEAT,eAAM,CAACM,KAAK,CAAC;AACf;AAEA,MAAMF,4BAA4B,CAACM;IACjCV,eAAM,CAACM,KAAK,CAAC;IAEb,KAAK,MAAMT,UAAUa,yBAAyBH,MAAM,GAAI;QACtD,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEE,kBAAkB,EAAEC,cAAc,EAAE,GAAGf;QAE9D,MAAMgB,iBACJF,uBAAuBC,iBACnBD,qBACA,CAAC,EAAEA,mBAAmB,MAAM,EAAEC,eAAe,CAAC;QAEpDZ,eAAM,CAACM,KAAK,CAAC,CAAC,EAAEE,KAAK,CAAC,EAAEC,QAAQ,GAAG,EAAEI,eAAe,CAAC;IACvD;AACF"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/report-failure.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { CheckLicensesResult, ForbiddenLicenseResult, NoLicenseResult } from \"../result\";\n\nexport const reportFailure = (result: CheckLicensesResult): void => {\n  const { noLicenses, forbiddenLicenses } = result;\n\n  logger.log(\"Found the following issues...\\n\");\n\n  if (noLicenses.size > 0) {\n    logNoLicenseIssues(noLicenses);\n  }\n\n  if (forbiddenLicenses.size > 0) {\n    logForbiddenLicenseIssues(forbiddenLicenses);\n  }\n};\n\nconst logNoLicenseIssues = (noLicenseResults: Set<NoLicenseResult>) => {\n  logger.error(\"Packages with no license:\");\n\n  for (const result of noLicenseResults.values()) {\n    const { name, version } = result;\n    logger.error(`${name}@${version}`);\n  }\n\n  logger.error(\"\");\n};\n\nconst logForbiddenLicenseIssues = (forbiddenLicensesResults: Set<ForbiddenLicenseResult>): void => {\n  logger.error(\"Packages with forbidden licenses:\");\n\n  for (const result of forbiddenLicensesResults.values()) {\n    const { name, version, licenseIdentifiers, spdxExpression } = result;\n\n    const licenseDetails =\n      licenseIdentifiers === spdxExpression\n        ? licenseIdentifiers\n        : `${licenseIdentifiers} from ${spdxExpression}`;\n\n    logger.error(`${name}@${version} - ${licenseDetails}`);\n  }\n};\n"],"names":["reportFailure","result","noLicenses","forbiddenLicenses","logger","log","size","logNoLicenseIssues","logForbiddenLicenseIssues","noLicenseResults","error","values","name","version","forbiddenLicensesResults","licenseIdentifiers","spdxExpression","licenseDetails"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAGaA;;;eAAAA;;;wBAHM;AAGZ,MAAMA,gBAAgB,CAACC;IAC5B,MAAM,EAAEC,UAAU,EAAEC,iBAAiB,EAAE,GAAGF;IAE1CG,eAAM,CAACC,GAAG,CAAC;IAEX,IAAIH,WAAWI,IAAI,GAAG,GAAG;QACvBC,mBAAmBL;IACrB;IAEA,IAAIC,kBAAkBG,IAAI,GAAG,GAAG;QAC9BE,0BAA0BL;IAC5B;AACF;AAEA,MAAMI,qBAAqB,CAACE;IAC1BL,eAAM,CAACM,KAAK,CAAC;IAEb,KAAK,MAAMT,UAAUQ,iBAAiBE,MAAM,GAAI;QAC9C,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAE,GAAGZ;QAC1BG,eAAM,CAACM,KAAK,CAAC,CAAC,EAAEE,KAAK,CAAC,EAAEC,QAAQ,CAAC;IACnC;IAEAT,eAAM,CAACM,KAAK,CAAC;AACf;AAEA,MAAMF,4BAA4B,CAACM;IACjCV,eAAM,CAACM,KAAK,CAAC;IAEb,KAAK,MAAMT,UAAUa,yBAAyBH,MAAM,GAAI;QACtD,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEE,kBAAkB,EAAEC,cAAc,EAAE,GAAGf;QAE9D,MAAMgB,iBACJF,uBAAuBC,iBACnBD,qBACA,CAAC,EAAEA,mBAAmB,MAAM,EAAEC,eAAe,CAAC;QAEpDZ,eAAM,CAACM,KAAK,CAAC,CAAC,EAAEE,KAAK,CAAC,EAAEC,QAAQ,GAAG,EAAEI,eAAe,CAAC;IACvD;AACF"}

package/src/lib/cli/report-success.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/report-success.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { CheckLicensesResult } from \"../result\";\n\nexport const reportSuccess = (result: CheckLicensesResult): void => {\n  const { allowedPackages, allowedLicenses } = result;\n\n  logger.log(\"\\nDone! No issues found\");\n\n  if (allowedPackages.size !== 0) {\n    logger.log(`Found ${allowedPackages.size} allowed packages`);\n  }\n\n  if (allowedLicenses.size !== 0) {\n    logger.log(`Found ${allowedLicenses.size} packages with allowed licenses`);\n  }\n\n  logger.verbose(\"\\nExiting with error code 0\");\n  process.exitCode = 0;\n};\n"],"names":["reportSuccess","result","allowedPackages","allowedLicenses","logger","log","size","verbose","process","exitCode"],"mappings":";+BAGaA;;;eAAAA;;;wBAHM;AAGZ,MAAMA,gBAAgB,CAACC;IAC5B,MAAM,EAAEC,eAAe,EAAEC,eAAe,EAAE,GAAGF;IAE7CG,eAAM,CAACC,GAAG,CAAC;IAEX,IAAIH,gBAAgBI,IAAI,KAAK,GAAG;QAC9BF,eAAM,CAACC,GAAG,CAAC,CAAC,MAAM,EAAEH,gBAAgBI,IAAI,CAAC,iBAAiB,CAAC;IAC7D;IAEA,IAAIH,gBAAgBG,IAAI,KAAK,GAAG;QAC9BF,eAAM,CAACC,GAAG,CAAC,CAAC,MAAM,EAAEF,gBAAgBG,IAAI,CAAC,+BAA+B,CAAC;IAC3E;IAEAF,eAAM,CAACG,OAAO,CAAC;IACfC,QAAQC,QAAQ,GAAG;AACrB"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/report-success.ts"],"sourcesContent":["import logger from \"../logger\";\nimport { CheckLicensesResult } from \"../result\";\n\nexport const reportSuccess = (result: CheckLicensesResult): void => {\n  const { allowedPackages, allowedLicenses } = result;\n\n  logger.log(\"\\nDone! No issues found\");\n\n  if (allowedPackages.size !== 0) {\n    logger.log(`Found ${allowedPackages.size} allowed packages`);\n  }\n\n  if (allowedLicenses.size !== 0) {\n    logger.log(`Found ${allowedLicenses.size} packages with allowed licenses`);\n  }\n\n  logger.verbose(\"\\nExiting with error code 0\");\n  process.exitCode = 0;\n};\n"],"names":["reportSuccess","result","allowedPackages","allowedLicenses","logger","log","size","verbose","process","exitCode"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";+BAGaA;;;eAAAA;;;wBAHM;AAGZ,MAAMA,gBAAgB,CAACC;IAC5B,MAAM,EAAEC,eAAe,EAAEC,eAAe,EAAE,GAAGF;IAE7CG,eAAM,CAACC,GAAG,CAAC;IAEX,IAAIH,gBAAgBI,IAAI,KAAK,GAAG;QAC9BF,eAAM,CAACC,GAAG,CAAC,CAAC,MAAM,EAAEH,gBAAgBI,IAAI,CAAC,iBAAiB,CAAC;IAC7D;IAEA,IAAIH,gBAAgBG,IAAI,KAAK,GAAG;QAC9BF,eAAM,CAACC,GAAG,CAAC,CAAC,MAAM,EAAEF,gBAAgBG,IAAI,CAAC,+BAA+B,CAAC;IAC3E;IAEAF,eAAM,CAACG,OAAO,CAAC;IACfC,QAAQC,QAAQ,GAAG;AACrB"}

package/src/lib/config/config-error.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/config-error.ts"],"sourcesContent":["export class ConfigError extends Error {\n  constructor(message: string) {\n    super(`Config error: ${message}`);\n  }\n\n  static fromUnknown(e: unknown): ConfigError {\n    const message = resolveMessage(e);\n    return new ConfigError(message);\n  }\n}\n\nconst resolveMessage = (e: unknown): string => {\n  if (e instanceof Error) {\n    return e.message;\n  }\n\n  if (typeof e === \"string\") {\n    return e;\n  }\n\n  return \"Unknown error\";\n};\n"],"names":["ConfigError","Error","fromUnknown","e","message","resolveMessage","constructor"],"mappings":";+BAAaA;;;eAAAA;;;AAAN,IAAA,AAAMA,cAAN,MAAMA,oBAAoBC;IAK/B,OAAOC,YAAYC,CAAU,EAAe;QAC1C,MAAMC,UAAUC,eAAeF;QAC/B,OAAO,IAAIH,YAAYI;IACzB;IAPAE,YAAYF,OAAe,CAAE;QAC3B,KAAK,CAAC,CAAC,cAAc,EAAEA,QAAQ,CAAC;IAClC;AAMF;AAEA,MAAMC,iBAAiB,CAACF;IACtB,IAAIA,aAAaF,OAAO;QACtB,OAAOE,EAAEC,OAAO;IAClB;IAEA,IAAI,OAAOD,MAAM,UAAU;QACzB,OAAOA;IACT;IAEA,OAAO;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/config-error.ts"],"sourcesContent":["export class ConfigError extends Error {\n  constructor(message: string) {\n    super(`Config error: ${message}`);\n  }\n\n  static fromUnknown(e: unknown): ConfigError {\n    const message = resolveMessage(e);\n    return new ConfigError(message);\n  }\n}\n\nconst resolveMessage = (e: unknown): string => {\n  if (e instanceof Error) {\n    return e.message;\n  }\n\n  if (typeof e === \"string\") {\n    return e;\n  }\n\n  return \"Unknown error\";\n};\n"],"names":["ConfigError","Error","fromUnknown","e","message","resolveMessage","constructor"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAAaA;;;eAAAA;;;AAAN,IAAA,AAAMA,cAAN,MAAMA,oBAAoBC;IAK/B,OAAOC,YAAYC,CAAU,EAAe;QAC1C,MAAMC,UAAUC,eAAeF;QAC/B,OAAO,IAAIH,YAAYI;IACzB;IAPAE,YAAYF,OAAe,CAAE;QAC3B,KAAK,CAAC,CAAC,cAAc,EAAEA,QAAQ,CAAC;IAClC;AAMF;AAEA,MAAMC,iBAAiB,CAACF;IACtB,IAAIA,aAAaF,OAAO;QACtB,OAAOE,EAAEC,OAAO;IAClB;IAEA,IAAI,OAAOD,MAAM,UAAU;QACzB,OAAOA;IACT;IAEA,OAAO;AACT"}

package/src/lib/config/config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/config.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ConfigError } from \"./config-error\";\n\nconst configParser = z\n  .object({\n    extends: z.string().optional(),\n    licenses: z.array(z.string()).optional(),\n    packages: z.array(z.string()).optional(),\n    includeDevDependencies: z.boolean().optional(),\n    devDependenciesOnly: z.boolean().optional(),\n    directory: z.string().optional()\n  })\n  .transform(c => ({\n    extends: c.extends,\n    licenses: c.licenses ?? [],\n    packages: c.packages ?? [],\n    includeDevDependencies: c.includeDevDependencies ?? false,\n    devDependenciesOnly: c.devDependenciesOnly ?? false\n  }));\n\nexport type Config = z.infer<typeof configParser>;\n\nexport const parseConfig = (config: unknown): Config => {\n  const parseResult = configParser.safeParse(config);\n\n  if (!parseResult.success) {\n    throw new ConfigError(parseResult.error.message);\n  }\n\n  return parseResult.data;\n};\n"],"names":["parseConfig","configParser","z","object","extends","string","optional","licenses","array","packages","includeDevDependencies","boolean","devDependenciesOnly","directory","transform","c","config","parseResult","safeParse","success","ConfigError","error","message","data"],"mappings":";+BAsBaA;;;eAAAA;;;qBAtBK;6BACU;AAE5B,MAAMC,eAAeC,MAAC,CACnBC,MAAM,CAAC;IACNC,SAASF,MAAC,CAACG,MAAM,GAAGC,QAAQ;IAC5BC,UAAUL,MAAC,CAACM,KAAK,CAACN,MAAC,CAACG,MAAM,IAAIC,QAAQ;IACtCG,UAAUP,MAAC,CAACM,KAAK,CAACN,MAAC,CAACG,MAAM,IAAIC,QAAQ;IACtCI,wBAAwBR,MAAC,CAACS,OAAO,GAAGL,QAAQ;IAC5CM,qBAAqBV,MAAC,CAACS,OAAO,GAAGL,QAAQ;IACzCO,WAAWX,MAAC,CAACG,MAAM,GAAGC,QAAQ;AAChC,GACCQ,SAAS,CAACC,CAAAA;QAECA,aACAA,aACcA,2BACHA;WALN;QACfX,SAASW,EAAEX,OAAO;QAClBG,UAAUQ,CAAAA,cAAAA,EAAER,QAAQ,YAAVQ,cAAc,EAAE;QAC1BN,UAAUM,CAAAA,cAAAA,EAAEN,QAAQ,YAAVM,cAAc,EAAE;QAC1BL,wBAAwBK,CAAAA,4BAAAA,EAAEL,sBAAsB,YAAxBK,4BAA4B;QACpDH,qBAAqBG,CAAAA,yBAAAA,EAAEH,mBAAmB,YAArBG,yBAAyB;IAChD;AAAA;AAIK,MAAMf,cAAc,CAACgB;IAC1B,MAAMC,cAAchB,aAAaiB,SAAS,CAACF;IAE3C,IAAI,CAACC,YAAYE,OAAO,EAAE;QACxB,MAAM,IAAIC,wBAAW,CAACH,YAAYI,KAAK,CAACC,OAAO;IACjD;IAEA,OAAOL,YAAYM,IAAI;AACzB"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/config.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ConfigError } from \"./config-error\";\n\nconst configParser = z\n  .object({\n    extends: z.string().optional(),\n    licenses: z.array(z.string()).optional(),\n    packages: z.array(z.string()).optional(),\n    includeDevDependencies: z.boolean().optional(),\n    devDependenciesOnly: z.boolean().optional(),\n    directory: z.string().optional()\n  })\n  .transform(c => ({\n    extends: c.extends,\n    licenses: c.licenses ?? [],\n    packages: c.packages ?? [],\n    includeDevDependencies: c.includeDevDependencies ?? false,\n    devDependenciesOnly: c.devDependenciesOnly ?? false\n  }));\n\nexport type Config = z.infer<typeof configParser>;\n\nexport const parseConfig = (config: unknown): Config => {\n  const parseResult = configParser.safeParse(config);\n\n  if (!parseResult.success) {\n    throw new ConfigError(parseResult.error.message);\n  }\n\n  return parseResult.data;\n};\n"],"names":["parseConfig","configParser","z","object","extends","string","optional","licenses","array","packages","includeDevDependencies","boolean","devDependenciesOnly","directory","transform","c","config","parseResult","safeParse","success","ConfigError","error","message","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAsBaA;;;eAAAA;;;qBAtBK;6BACU;AAE5B,MAAMC,eAAeC,MAAC,CACnBC,MAAM,CAAC;IACNC,SAASF,MAAC,CAACG,MAAM,GAAGC,QAAQ;IAC5BC,UAAUL,MAAC,CAACM,KAAK,CAACN,MAAC,CAACG,MAAM,IAAIC,QAAQ;IACtCG,UAAUP,MAAC,CAACM,KAAK,CAACN,MAAC,CAACG,MAAM,IAAIC,QAAQ;IACtCI,wBAAwBR,MAAC,CAACS,OAAO,GAAGL,QAAQ;IAC5CM,qBAAqBV,MAAC,CAACS,OAAO,GAAGL,QAAQ;IACzCO,WAAWX,MAAC,CAACG,MAAM,GAAGC,QAAQ;AAChC,GACCQ,SAAS,CAACC,CAAAA;QAECA,aACAA,aACcA,2BACHA;WALN;QACfX,SAASW,EAAEX,OAAO;QAClBG,UAAUQ,CAAAA,cAAAA,EAAER,QAAQ,YAAVQ,cAAc,EAAE;QAC1BN,UAAUM,CAAAA,cAAAA,EAAEN,QAAQ,YAAVM,cAAc,EAAE;QAC1BL,wBAAwBK,CAAAA,4BAAAA,EAAEL,sBAAsB,YAAxBK,4BAA4B;QACpDH,qBAAqBG,CAAAA,yBAAAA,EAAEH,mBAAmB,YAArBG,yBAAyB;IAChD;AAAA;AAIK,MAAMf,cAAc,CAACgB;IAC1B,MAAMC,cAAchB,aAAaiB,SAAS,CAACF;IAE3C,IAAI,CAACC,YAAYE,OAAO,EAAE;QACxB,MAAM,IAAIC,wBAAW,CAACH,YAAYI,KAAK,CAACC,OAAO;IACjD;IAEA,OAAOL,YAAYM,IAAI;AACzB"}

package/src/lib/config/find-config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/find-config.ts"],"sourcesContent":["import { cosmiconfig, Options as CosmiconfigOptions, Loader } from \"cosmiconfig\";\nimport { ConfigError } from \"./config-error\";\nimport { json5Parse } from \"./parsers/json5\";\n\n// cspell:disable-next-line\nconst moduleNames = [\"licenses\", \"licences\", \"licensesrc\", \"licencesrc\"];\n\nconst generateSearchPlaces = (moduleName: string): string[] => [\n  `.${moduleName}`,\n  `.${moduleName}.json`,\n  `.${moduleName}.jsonc`,\n  `.${moduleName}.json5`,\n  `.${moduleName}.yaml`,\n  `.${moduleName}.yml`,\n  `.${moduleName}.js`,\n  `.${moduleName}.cjs`,\n  `.config/${moduleName}`,\n  `.config/${moduleName}.json`,\n  `.config/${moduleName}.jsonc`,\n  `.config/${moduleName}.json5`,\n  `.config/${moduleName}.yaml`,\n  `.config/${moduleName}.yml`,\n  `.config/${moduleName}.js`,\n  `.config/${moduleName}.cjs`,\n  `${moduleName}.config.js`,\n  `${moduleName}.config.cjs`\n];\n\nconst searchPlaces: string[] = [\"package.json\"];\n\nfor (const moduleName of moduleNames) {\n  searchPlaces.push(...generateSearchPlaces(moduleName));\n}\n\nconst json5Loader: Loader = (_filepath, content) => Promise.resolve(json5Parse(content));\n\nexport const findConfig = async (rootDir: string): Promise<unknown> => {\n  const options: Partial<CosmiconfigOptions> = {\n    stopDir: rootDir,\n    searchPlaces,\n    loaders: {\n      \".json\": json5Loader,\n      \".jsonc\": json5Loader,\n      \".json5\": json5Loader\n    }\n  };\n\n  const explorer = cosmiconfig(\"licensecop\", options);\n\n  try {\n    const result = await explorer.search(rootDir);\n\n    if (!result?.config) {\n      throw new Error(\"No config file found\");\n    }\n\n    return result.config;\n  } catch (e) {\n    throw ConfigError.fromUnknown(e);\n  }\n};\n"],"names":["findConfig","moduleNames","generateSearchPlaces","moduleName","searchPlaces","push","json5Loader","_filepath","content","Promise","resolve","json5Parse","rootDir","options","stopDir","loaders","explorer","cosmiconfig","result","search","config","Error","e","ConfigError","fromUnknown"],"mappings":";+BAoCaA;;;eAAAA;;;6BApCsD;6BACvC;uBACD;AAE3B,2BAA2B;AAC3B,MAAMC,cAAc;IAAC;IAAY;IAAY;IAAc;CAAa;AAExE,MAAMC,uBAAuB,CAACC,aAAiC;QAC7D,CAAC,CAAC,EAAEA,WAAW,CAAC;QAChB,CAAC,CAAC,EAAEA,WAAW,KAAK,CAAC;QACrB,CAAC,CAAC,EAAEA,WAAW,MAAM,CAAC;QACtB,CAAC,CAAC,EAAEA,WAAW,MAAM,CAAC;QACtB,CAAC,CAAC,EAAEA,WAAW,KAAK,CAAC;QACrB,CAAC,CAAC,EAAEA,WAAW,IAAI,CAAC;QACpB,CAAC,CAAC,EAAEA,WAAW,GAAG,CAAC;QACnB,CAAC,CAAC,EAAEA,WAAW,IAAI,CAAC;QACpB,CAAC,QAAQ,EAAEA,WAAW,CAAC;QACvB,CAAC,QAAQ,EAAEA,WAAW,KAAK,CAAC;QAC5B,CAAC,QAAQ,EAAEA,WAAW,MAAM,CAAC;QAC7B,CAAC,QAAQ,EAAEA,WAAW,MAAM,CAAC;QAC7B,CAAC,QAAQ,EAAEA,WAAW,KAAK,CAAC;QAC5B,CAAC,QAAQ,EAAEA,WAAW,IAAI,CAAC;QAC3B,CAAC,QAAQ,EAAEA,WAAW,GAAG,CAAC;QAC1B,CAAC,QAAQ,EAAEA,WAAW,IAAI,CAAC;QAC3B,CAAC,EAAEA,WAAW,UAAU,CAAC;QACzB,CAAC,EAAEA,WAAW,WAAW,CAAC;KAC3B;AAED,MAAMC,eAAyB;IAAC;CAAe;AAE/C,KAAK,MAAMD,cAAcF,YAAa;IACpCG,aAAaC,IAAI,IAAIH,qBAAqBC;AAC5C;AAEA,MAAMG,cAAsB,CAACC,WAAWC,UAAYC,QAAQC,OAAO,CAACC,IAAAA,iBAAU,EAACH;AAExE,MAAMR,aAAa,OAAOY;IAC/B,MAAMC,UAAuC;QAC3CC,SAASF;QACTR;QACAW,SAAS;YACP,SAAST;YACT,UAAUA;YACV,UAAUA;QACZ;IACF;IAEA,MAAMU,WAAWC,IAAAA,wBAAW,EAAC,cAAcJ;IAE3C,IAAI;QACF,MAAMK,SAAS,MAAMF,SAASG,MAAM,CAACP;QAErC,IAAI,EAACM,0BAAAA,OAAQE,MAAM,GAAE;YACnB,MAAM,IAAIC,MAAM;QAClB;QAEA,OAAOH,OAAOE,MAAM;IACtB,EAAE,OAAOE,GAAG;QACV,MAAMC,wBAAW,CAACC,WAAW,CAACF;IAChC;AACF"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/find-config.ts"],"sourcesContent":["import { cosmiconfig, Options as CosmiconfigOptions, Loader } from \"cosmiconfig\";\nimport { ConfigError } from \"./config-error\";\nimport { json5Parse } from \"./parsers/json5\";\n\n// cspell:disable-next-line\nconst moduleNames = [\"licenses\", \"licences\", \"licensesrc\", \"licencesrc\"];\n\nconst generateSearchPlaces = (moduleName: string): string[] => [\n  `.${moduleName}`,\n  `.${moduleName}.json`,\n  `.${moduleName}.jsonc`,\n  `.${moduleName}.json5`,\n  `.${moduleName}.yaml`,\n  `.${moduleName}.yml`,\n  `.${moduleName}.js`,\n  `.${moduleName}.cjs`,\n  `.config/${moduleName}`,\n  `.config/${moduleName}.json`,\n  `.config/${moduleName}.jsonc`,\n  `.config/${moduleName}.json5`,\n  `.config/${moduleName}.yaml`,\n  `.config/${moduleName}.yml`,\n  `.config/${moduleName}.js`,\n  `.config/${moduleName}.cjs`,\n  `${moduleName}.config.js`,\n  `${moduleName}.config.cjs`\n];\n\nconst searchPlaces: string[] = [\"package.json\"];\n\nfor (const moduleName of moduleNames) {\n  searchPlaces.push(...generateSearchPlaces(moduleName));\n}\n\nconst json5Loader: Loader = (_filepath, content) => Promise.resolve(json5Parse(content));\n\nexport const findConfig = async (rootDir: string): Promise<unknown> => {\n  const options: Partial<CosmiconfigOptions> = {\n    stopDir: rootDir,\n    searchPlaces,\n    loaders: {\n      \".json\": json5Loader,\n      \".jsonc\": json5Loader,\n      \".json5\": json5Loader\n    }\n  };\n\n  const explorer = cosmiconfig(\"licensecop\", options);\n\n  try {\n    const result = await explorer.search(rootDir);\n\n    if (!result?.config) {\n      throw new Error(\"No config file found\");\n    }\n\n    return result.config;\n  } catch (e) {\n    throw ConfigError.fromUnknown(e);\n  }\n};\n"],"names":["findConfig","moduleNames","generateSearchPlaces","moduleName","searchPlaces","push","json5Loader","_filepath","content","Promise","resolve","json5Parse","rootDir","options","stopDir","loaders","explorer","cosmiconfig","result","search","config","Error","e","ConfigError","fromUnknown"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAoCaA;;;eAAAA;;;6BApCsD;6BACvC;uBACD;AAE3B,2BAA2B;AAC3B,MAAMC,cAAc;IAAC;IAAY;IAAY;IAAc;CAAa;AAExE,MAAMC,uBAAuB,CAACC,aAAiC;QAC7D,CAAC,CAAC,EAAEA,WAAW,CAAC;QAChB,CAAC,CAAC,EAAEA,WAAW,KAAK,CAAC;QACrB,CAAC,CAAC,EAAEA,WAAW,MAAM,CAAC;QACtB,CAAC,CAAC,EAAEA,WAAW,MAAM,CAAC;QACtB,CAAC,CAAC,EAAEA,WAAW,KAAK,CAAC;QACrB,CAAC,CAAC,EAAEA,WAAW,IAAI,CAAC;QACpB,CAAC,CAAC,EAAEA,WAAW,GAAG,CAAC;QACnB,CAAC,CAAC,EAAEA,WAAW,IAAI,CAAC;QACpB,CAAC,QAAQ,EAAEA,WAAW,CAAC;QACvB,CAAC,QAAQ,EAAEA,WAAW,KAAK,CAAC;QAC5B,CAAC,QAAQ,EAAEA,WAAW,MAAM,CAAC;QAC7B,CAAC,QAAQ,EAAEA,WAAW,MAAM,CAAC;QAC7B,CAAC,QAAQ,EAAEA,WAAW,KAAK,CAAC;QAC5B,CAAC,QAAQ,EAAEA,WAAW,IAAI,CAAC;QAC3B,CAAC,QAAQ,EAAEA,WAAW,GAAG,CAAC;QAC1B,CAAC,QAAQ,EAAEA,WAAW,IAAI,CAAC;QAC3B,CAAC,EAAEA,WAAW,UAAU,CAAC;QACzB,CAAC,EAAEA,WAAW,WAAW,CAAC;KAC3B;AAED,MAAMC,eAAyB;IAAC;CAAe;AAE/C,KAAK,MAAMD,cAAcF,YAAa;IACpCG,aAAaC,IAAI,IAAIH,qBAAqBC;AAC5C;AAEA,MAAMG,cAAsB,CAACC,WAAWC,UAAYC,QAAQC,OAAO,CAACC,IAAAA,iBAAU,EAACH;AAExE,MAAMR,aAAa,OAAOY;IAC/B,MAAMC,UAAuC;QAC3CC,SAASF;QACTR;QACAW,SAAS;YACP,SAAST;YACT,UAAUA;YACV,UAAUA;QACZ;IACF;IAEA,MAAMU,WAAWC,IAAAA,wBAAW,EAAC,cAAcJ;IAE3C,IAAI;QACF,MAAMK,SAAS,MAAMF,SAASG,MAAM,CAACP;QAErC,IAAI,EAACM,0BAAAA,OAAQE,MAAM,GAAE;YACnB,MAAM,IAAIC,MAAM;QAClB;QAEA,OAAOH,OAAOE,MAAM;IACtB,EAAE,OAAOE,GAAG;QACV,MAAMC,wBAAW,CAACC,WAAW,CAACF;IAChC;AACF"}

package/src/lib/config/load-config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/load-config.ts"],"sourcesContent":["import * as deepMerge from \"deepmerge\";\nimport logger from \"../logger\";\nimport { parseConfig } from \"./config\";\nimport { findConfig } from \"./find-config\";\nimport { loadParentConfig } from \"./load-parent-config\";\n\nexport const loadConfig = async (rootDir: string) => {\n  const foundConfig = await findConfig(rootDir);\n\n  let config = parseConfig(foundConfig);\n\n  while (config.extends) {\n    logger.verbose(`Extending config with ${config.extends}`);\n    const loadedParentConfig = await loadParentConfig(config.extends, rootDir);\n    const parsedParentConfig = parseConfig(loadedParentConfig);\n\n    config = deepMerge(parsedParentConfig, config);\n    config.extends = parsedParentConfig.extends;\n  }\n\n  return config;\n};\n"],"names":["loadConfig","rootDir","foundConfig","findConfig","config","parseConfig","extends","logger","verbose","loadedParentConfig","loadParentConfig","parsedParentConfig","deepMerge"],"mappings":";+BAMaA;;;eAAAA;;;2BANc;wBACR;wBACS;4BACD;kCACM;AAE1B,MAAMA,aAAa,OAAOC;IAC/B,MAAMC,cAAc,MAAMC,IAAAA,sBAAU,EAACF;IAErC,IAAIG,SAASC,IAAAA,mBAAW,EAACH;IAEzB,MAAOE,OAAOE,OAAO,CAAE;QACrBC,eAAM,CAACC,OAAO,CAAC,CAAC,sBAAsB,EAAEJ,OAAOE,OAAO,CAAC,CAAC;QACxD,MAAMG,qBAAqB,MAAMC,IAAAA,kCAAgB,EAACN,OAAOE,OAAO,EAAEL;QAClE,MAAMU,qBAAqBN,IAAAA,mBAAW,EAACI;QAEvCL,SAASQ,WAAUD,oBAAoBP;QACvCA,OAAOE,OAAO,GAAGK,mBAAmBL,OAAO;IAC7C;IAEA,OAAOF;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/load-config.ts"],"sourcesContent":["import * as deepMerge from \"deepmerge\";\nimport logger from \"../logger\";\nimport { parseConfig } from \"./config\";\nimport { findConfig } from \"./find-config\";\nimport { loadParentConfig } from \"./load-parent-config\";\n\nexport const loadConfig = async (rootDir: string) => {\n  const foundConfig = await findConfig(rootDir);\n\n  let config = parseConfig(foundConfig);\n\n  while (config.extends) {\n    logger.verbose(`Extending config with ${config.extends}`);\n    const loadedParentConfig = await loadParentConfig(config.extends, rootDir);\n    const parsedParentConfig = parseConfig(loadedParentConfig);\n\n    config = deepMerge(parsedParentConfig, config);\n    config.extends = parsedParentConfig.extends;\n  }\n\n  return config;\n};\n"],"names":["loadConfig","rootDir","foundConfig","findConfig","config","parseConfig","extends","logger","verbose","loadedParentConfig","loadParentConfig","parsedParentConfig","deepMerge"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAMaA;;;eAAAA;;;2BANc;wBACR;wBACS;4BACD;kCACM;AAE1B,MAAMA,aAAa,OAAOC;IAC/B,MAAMC,cAAc,MAAMC,IAAAA,sBAAU,EAACF;IAErC,IAAIG,SAASC,IAAAA,mBAAW,EAACH;IAEzB,MAAOE,OAAOE,OAAO,CAAE;QACrBC,eAAM,CAACC,OAAO,CAAC,CAAC,sBAAsB,EAAEJ,OAAOE,OAAO,CAAC,CAAC;QACxD,MAAMG,qBAAqB,MAAMC,IAAAA,kCAAgB,EAACN,OAAOE,OAAO,EAAEL;QAClE,MAAMU,qBAAqBN,IAAAA,mBAAW,EAACI;QAEvCL,SAASQ,WAAUD,oBAAoBP;QACvCA,OAAOE,OAAO,GAAGK,mBAAmBL,OAAO;IAC7C;IAEA,OAAOF;AACT"}

package/src/lib/config/load-parent-config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/load-parent-config.ts"],"sourcesContent":["import { ConfigError } from \"./config-error\";\nimport { githubResolution } from \"./parent-resolutions/github\";\nimport { httpResolution } from \"./parent-resolutions/http\";\nimport { nodeModuleExists, npmResolution } from \"./parent-resolutions/npm\";\n\nexport const loadParentConfig = async (\n  parentConfigPath: string,\n  rootDir: string\n): Promise<unknown> => {\n  if (parentConfigPath.startsWith(\"npm:\")) {\n    const packageName = parentConfigPath.substring(4);\n    return await npmResolution(packageName, rootDir);\n  }\n\n  if (parentConfigPath.startsWith(\"github:\")) {\n    const repo = parentConfigPath.substring(7);\n    return await githubResolution(repo);\n  }\n\n  if (parentConfigPath.startsWith(\"http\")) {\n    return await httpResolution(parentConfigPath);\n  }\n\n  if (await nodeModuleExists(parentConfigPath, rootDir)) {\n    return await npmResolution(parentConfigPath, rootDir);\n  }\n\n  throw new ConfigError(`Invalid parent config location: ${parentConfigPath}`);\n};\n"],"names":["loadParentConfig","parentConfigPath","rootDir","startsWith","packageName","substring","npmResolution","repo","githubResolution","httpResolution","nodeModuleExists","ConfigError"],"mappings":";+BAKaA;;;eAAAA;;;6BALe;wBACK;sBACF;qBACiB;AAEzC,MAAMA,mBAAmB,OAC9BC,kBACAC;IAEA,IAAID,iBAAiBE,UAAU,CAAC,SAAS;QACvC,MAAMC,cAAcH,iBAAiBI,SAAS,CAAC;QAC/C,OAAO,MAAMC,IAAAA,kBAAa,EAACF,aAAaF;IAC1C;IAEA,IAAID,iBAAiBE,UAAU,CAAC,YAAY;QAC1C,MAAMI,OAAON,iBAAiBI,SAAS,CAAC;QACxC,OAAO,MAAMG,IAAAA,wBAAgB,EAACD;IAChC;IAEA,IAAIN,iBAAiBE,UAAU,CAAC,SAAS;QACvC,OAAO,MAAMM,IAAAA,oBAAc,EAACR;IAC9B;IAEA,IAAI,MAAMS,IAAAA,qBAAgB,EAACT,kBAAkBC,UAAU;QACrD,OAAO,MAAMI,IAAAA,kBAAa,EAACL,kBAAkBC;IAC/C;IAEA,MAAM,IAAIS,wBAAW,CAAC,CAAC,gCAAgC,EAAEV,iBAAiB,CAAC;AAC7E"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/config/load-parent-config.ts"],"sourcesContent":["import { ConfigError } from \"./config-error\";\nimport { githubResolution } from \"./parent-resolutions/github\";\nimport { httpResolution } from \"./parent-resolutions/http\";\nimport { nodeModuleExists, npmResolution } from \"./parent-resolutions/npm\";\n\nexport const loadParentConfig = async (\n  parentConfigPath: string,\n  rootDir: string\n): Promise<unknown> => {\n  if (parentConfigPath.startsWith(\"npm:\")) {\n    const packageName = parentConfigPath.substring(4);\n    return await npmResolution(packageName, rootDir);\n  }\n\n  if (parentConfigPath.startsWith(\"github:\")) {\n    const repo = parentConfigPath.substring(7);\n    return await githubResolution(repo);\n  }\n\n  if (parentConfigPath.startsWith(\"http\")) {\n    return await httpResolution(parentConfigPath);\n  }\n\n  if (await nodeModuleExists(parentConfigPath, rootDir)) {\n    return await npmResolution(parentConfigPath, rootDir);\n  }\n\n  throw new ConfigError(`Invalid parent config location: ${parentConfigPath}`);\n};\n"],"names":["loadParentConfig","parentConfigPath","rootDir","startsWith","packageName","substring","npmResolution","repo","githubResolution","httpResolution","nodeModuleExists","ConfigError"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAKaA;;;eAAAA;;;6BALe;wBACK;sBACF;qBACiB;AAEzC,MAAMA,mBAAmB,OAC9BC,kBACAC;IAEA,IAAID,iBAAiBE,UAAU,CAAC,SAAS;QACvC,MAAMC,cAAcH,iBAAiBI,SAAS,CAAC;QAC/C,OAAO,MAAMC,IAAAA,kBAAa,EAACF,aAAaF;IAC1C;IAEA,IAAID,iBAAiBE,UAAU,CAAC,YAAY;QAC1C,MAAMI,OAAON,iBAAiBI,SAAS,CAAC;QACxC,OAAO,MAAMG,IAAAA,wBAAgB,EAACD;IAChC;IAEA,IAAIN,iBAAiBE,UAAU,CAAC,SAAS;QACvC,OAAO,MAAMM,IAAAA,oBAAc,EAACR;IAC9B;IAEA,IAAI,MAAMS,IAAAA,qBAAgB,EAACT,kBAAkBC,UAAU;QACrD,OAAO,MAAMI,IAAAA,kBAAa,EAACL,kBAAkBC;IAC/C;IAEA,MAAM,IAAIS,wBAAW,CAAC,CAAC,gCAAgC,EAAEV,iBAAiB,CAAC;AAC7E"}

package/src/lib/config/parent-resolutions/github.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/github.ts"],"sourcesContent":["import { GitHubClient } from \"git-filesystem\";\nimport logger from \"../../logger\";\nimport { ConfigError } from \"../config-error\";\nimport { json5Parse } from \"../parsers/json5\";\n\nexport const githubResolution = async (repoId: string) => {\n  logger.verbose(`Resolving config from GitHub repo: ${repoId}`);\n\n  const parts = repoId.split(\"/\");\n\n  if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {\n    throw new ConfigError(`Invalid GitHub repo ID: ${repoId}`);\n  }\n\n  const [owner, repoName] = parts;\n\n  try {\n    const repo = new GitHubClient(owner, \"\", \"license-cop\").getReadonlyRepository(repoName);\n    const fileContent = await repo.readFile(\".licenses.json\");\n\n    return json5Parse(fileContent);\n  } catch (e) {\n    throw new ConfigError(\n      `Could not resolve config from GitHub repo: ${repoId}, error: ${JSON.stringify(e)}`\n    );\n  }\n};\n"],"names":["githubResolution","repoId","logger","verbose","parts","split","length","ConfigError","owner","repoName","repo","GitHubClient","getReadonlyRepository","fileContent","readFile","json5Parse","e","JSON","stringify"],"mappings":";+BAKaA;;;eAAAA;;;+BALgB;wBACV;6BACS;uBACD;AAEpB,MAAMA,mBAAmB,OAAOC;IACrCC,eAAM,CAACC,OAAO,CAAC,CAAC,mCAAmC,EAAEF,OAAO,CAAC;IAE7D,MAAMG,QAAQH,OAAOI,KAAK,CAAC;IAE3B,IAAID,MAAME,MAAM,KAAK,KAAKF,KAAK,CAAC,EAAE,CAACE,MAAM,KAAK,KAAKF,KAAK,CAAC,EAAE,CAACE,MAAM,KAAK,GAAG;QACxE,MAAM,IAAIC,wBAAW,CAAC,CAAC,wBAAwB,EAAEN,OAAO,CAAC;IAC3D;IAEA,MAAM,CAACO,OAAOC,SAAS,GAAGL;IAE1B,IAAI;QACF,MAAMM,OAAO,IAAIC,2BAAY,CAACH,OAAO,IAAI,eAAeI,qBAAqB,CAACH;QAC9E,MAAMI,cAAc,MAAMH,KAAKI,QAAQ,CAAC;QAExC,OAAOC,IAAAA,iBAAU,EAACF;IACpB,EAAE,OAAOG,GAAG;QACV,MAAM,IAAIT,wBAAW,CACnB,CAAC,2CAA2C,EAAEN,OAAO,SAAS,EAAEgB,KAAKC,SAAS,CAACF,GAAG,CAAC;IAEvF;AACF"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/github.ts"],"sourcesContent":["import { GitHubClient } from \"git-filesystem\";\nimport logger from \"../../logger\";\nimport { ConfigError } from \"../config-error\";\nimport { json5Parse } from \"../parsers/json5\";\n\nexport const githubResolution = async (repoId: string) => {\n  logger.verbose(`Resolving config from GitHub repo: ${repoId}`);\n\n  const parts = repoId.split(\"/\");\n\n  if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) {\n    throw new ConfigError(`Invalid GitHub repo ID: ${repoId}`);\n  }\n\n  const [owner, repoName] = parts;\n\n  try {\n    const repo = new GitHubClient(owner, \"\", \"license-cop\").getReadonlyRepository(repoName);\n    const fileContent = await repo.readFile(\".licenses.json\");\n\n    return json5Parse(fileContent);\n  } catch (e) {\n    throw new ConfigError(\n      `Could not resolve config from GitHub repo: ${repoId}, error: ${JSON.stringify(e)}`\n    );\n  }\n};\n"],"names":["githubResolution","repoId","logger","verbose","parts","split","length","ConfigError","owner","repoName","repo","GitHubClient","getReadonlyRepository","fileContent","readFile","json5Parse","e","JSON","stringify"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAKaA;;;eAAAA;;;+BALgB;wBACV;6BACS;uBACD;AAEpB,MAAMA,mBAAmB,OAAOC;IACrCC,eAAM,CAACC,OAAO,CAAC,CAAC,mCAAmC,EAAEF,OAAO,CAAC;IAE7D,MAAMG,QAAQH,OAAOI,KAAK,CAAC;IAE3B,IAAID,MAAME,MAAM,KAAK,KAAKF,KAAK,CAAC,EAAE,CAACE,MAAM,KAAK,KAAKF,KAAK,CAAC,EAAE,CAACE,MAAM,KAAK,GAAG;QACxE,MAAM,IAAIC,wBAAW,CAAC,CAAC,wBAAwB,EAAEN,OAAO,CAAC;IAC3D;IAEA,MAAM,CAACO,OAAOC,SAAS,GAAGL;IAE1B,IAAI;QACF,MAAMM,OAAO,IAAIC,2BAAY,CAACH,OAAO,IAAI,eAAeI,qBAAqB,CAACH;QAC9E,MAAMI,cAAc,MAAMH,KAAKI,QAAQ,CAAC;QAExC,OAAOC,IAAAA,iBAAU,EAACF;IACpB,EAAE,OAAOG,GAAG;QACV,MAAM,IAAIT,wBAAW,CACnB,CAAC,2CAA2C,EAAEN,OAAO,SAAS,EAAEgB,KAAKC,SAAS,CAACF,GAAG,CAAC;IAEvF;AACF"}

package/src/lib/config/parent-resolutions/http.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/http.ts"],"sourcesContent":["import axios from \"axios\";\nimport logger from \"../../logger\";\nimport { json5Parse } from \"../parsers/json5\";\n\nexport const httpResolution = async (url: string) => {\n  logger.verbose(`Resolving http config: ${url}`);\n\n  const response = await axios.get(url);\n\n  if (typeof response.data === \"string\") {\n    return await json5Parse(response.data);\n  }\n\n  return response.data;\n};\n"],"names":["httpResolution","url","logger","verbose","response","axios","get","data","json5Parse"],"mappings":";+BAIaA;;;eAAAA;;;uBAJK;wBACC;uBACQ;AAEpB,MAAMA,iBAAiB,OAAOC;IACnCC,eAAM,CAACC,OAAO,CAAC,CAAC,uBAAuB,EAAEF,IAAI,CAAC;IAE9C,MAAMG,WAAW,MAAMC,cAAK,CAACC,GAAG,CAACL;IAEjC,IAAI,OAAOG,SAASG,IAAI,KAAK,UAAU;QACrC,OAAO,MAAMC,IAAAA,iBAAU,EAACJ,SAASG,IAAI;IACvC;IAEA,OAAOH,SAASG,IAAI;AACtB"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/http.ts"],"sourcesContent":["import axios from \"axios\";\nimport logger from \"../../logger\";\nimport { json5Parse } from \"../parsers/json5\";\n\nexport const httpResolution = async (url: string) => {\n  logger.verbose(`Resolving http config: ${url}`);\n\n  const response = await axios.get(url);\n\n  if (typeof response.data === \"string\") {\n    return await json5Parse(response.data);\n  }\n\n  return response.data;\n};\n"],"names":["httpResolution","url","logger","verbose","response","axios","get","data","json5Parse"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";+BAIaA;;;eAAAA;;;uBAJK;wBACC;uBACQ;AAEpB,MAAMA,iBAAiB,OAAOC;IACnCC,eAAM,CAACC,OAAO,CAAC,CAAC,uBAAuB,EAAEF,IAAI,CAAC;IAE9C,MAAMG,WAAW,MAAMC,cAAK,CAACC,GAAG,CAACL;IAEjC,IAAI,OAAOG,SAASG,IAAI,KAAK,UAAU;QACrC,OAAO,MAAMC,IAAAA,iBAAU,EAACJ,SAASG,IAAI;IACvC;IAEA,OAAOH,SAASG,IAAI;AACtB"}

package/src/lib/config/parent-resolutions/npm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/npm.ts"],"sourcesContent":["import { stat } from \"fs/promises\";\nimport { join } from \"path\";\nimport logger from \"../../logger\";\nimport { findConfig } from \"../find-config\";\n\nexport const npmResolution = async (packageName: string, rootDir: string) => {\n  logger.verbose(`Resolving npm package: ${packageName}`);\n\n  const packagePath = getPackagePath(rootDir, packageName);\n  return await findConfig(packagePath);\n};\n\nexport const nodeModuleExists = async (packageName: string, rootDir: string) => {\n  const packagePath = getPackagePath(rootDir, packageName);\n\n  const statResult = await stat(packagePath);\n  return statResult.isDirectory();\n};\n\nconst getPackagePath = (rootDir: string, packageName: string) =>\n  join(rootDir, \"node_modules\", packageName);\n"],"names":["nodeModuleExists","npmResolution","packageName","rootDir","logger","verbose","packagePath","getPackagePath","findConfig","statResult","stat","isDirectory","join"],"mappings":";;;;;;;;IAYaA,gBAAgB;eAAhBA;;IAPAC,aAAa;eAAbA;;;0BALQ;sBACA;wBACF;4BACQ;AAEpB,MAAMA,gBAAgB,OAAOC,aAAqBC;IACvDC,eAAM,CAACC,OAAO,CAAC,CAAC,uBAAuB,EAAEH,YAAY,CAAC;IAEtD,MAAMI,cAAcC,eAAeJ,SAASD;IAC5C,OAAO,MAAMM,IAAAA,sBAAU,EAACF;AAC1B;AAEO,MAAMN,mBAAmB,OAAOE,aAAqBC;IAC1D,MAAMG,cAAcC,eAAeJ,SAASD;IAE5C,MAAMO,aAAa,MAAMC,IAAAA,cAAI,EAACJ;IAC9B,OAAOG,WAAWE,WAAW;AAC/B;AAEA,MAAMJ,iBAAiB,CAACJ,SAAiBD,cACvCU,IAAAA,UAAI,EAACT,SAAS,gBAAgBD"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parent-resolutions/npm.ts"],"sourcesContent":["import { stat } from \"fs/promises\";\nimport { join } from \"path\";\nimport logger from \"../../logger\";\nimport { findConfig } from \"../find-config\";\n\nexport const npmResolution = async (packageName: string, rootDir: string) => {\n  logger.verbose(`Resolving npm package: ${packageName}`);\n\n  const packagePath = getPackagePath(rootDir, packageName);\n  return await findConfig(packagePath);\n};\n\nexport const nodeModuleExists = async (packageName: string, rootDir: string) => {\n  const packagePath = getPackagePath(rootDir, packageName);\n\n  const statResult = await stat(packagePath);\n  return statResult.isDirectory();\n};\n\nconst getPackagePath = (rootDir: string, packageName: string) =>\n  join(rootDir, \"node_modules\", packageName);\n"],"names":["nodeModuleExists","npmResolution","packageName","rootDir","logger","verbose","packagePath","getPackagePath","findConfig","statResult","stat","isDirectory","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAYaA,gBAAgB;eAAhBA;;IAPAC,aAAa;eAAbA;;;0BALQ;sBACA;wBACF;4BACQ;AAEpB,MAAMA,gBAAgB,OAAOC,aAAqBC;IACvDC,eAAM,CAACC,OAAO,CAAC,CAAC,uBAAuB,EAAEH,YAAY,CAAC;IAEtD,MAAMI,cAAcC,eAAeJ,SAASD;IAC5C,OAAO,MAAMM,IAAAA,sBAAU,EAACF;AAC1B;AAEO,MAAMN,mBAAmB,OAAOE,aAAqBC;IAC1D,MAAMG,cAAcC,eAAeJ,SAASD;IAE5C,MAAMO,aAAa,MAAMC,IAAAA,cAAI,EAACJ;IAC9B,OAAOG,WAAWE,WAAW;AAC/B;AAEA,MAAMJ,iBAAiB,CAACJ,SAAiBD,cACvCU,IAAAA,UAAI,EAACT,SAAS,gBAAgBD"}

package/src/lib/config/parsers/json5.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parsers/json5.ts"],"sourcesContent":["import * as JSON5 from \"json5\";\n\nexport const json5Parse = <T>(content: string): T => JSON5.parse<T>(content);\n"],"names":["json5Parse","content","JSON5","parse"],"mappings":";+BAEaA;;;eAAAA;;;uBAFU;AAEhB,MAAMA,aAAa,CAAIC,UAAuBC,OAAMC,KAAK,CAAIF"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/config/parsers/json5.ts"],"sourcesContent":["import * as JSON5 from \"json5\";\n\nexport const json5Parse = <T>(content: string): T => JSON5.parse<T>(content);\n"],"names":["json5Parse","content","JSON5","parse"],"rangeMappings":";;;;;;;;","mappings":";+BAEaA;;;eAAAA;;;uBAFU;AAEhB,MAAMA,aAAa,CAAIC,UAAuBC,OAAMC,KAAK,CAAIF"}

package/src/lib/dependency/get-package-manager.d.ts

@@ -0,0 +1,2 @@
+export type PackageManager = "npm" | "yarn" | "pnpm";
+export declare const getPackageManager: (workingDirectory: string) => Promise<PackageManager>;

package/src/lib/dependency/get-package-manager.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "getPackageManager", {
+    enumerable: true,
+    get: function() {
+        return getPackageManager;
+    }
+});
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+const _packagejson = require("./package-json");
+const getPackageManager = async (workingDirectory)=>{
+    const packageJsonPath = (0, _nodepath.join)(workingDirectory, "package.json");
+    const packageJson = await (0, _packagejson.readPackageJson)(packageJsonPath);
+    if (packageJson.packageManager) {
+        const result = tryResolveFromPackageManager(packageJson.packageManager);
+        if (result) {
+            return result;
+        }
+    }
+    return await resolveFromLockFileDiscovery(workingDirectory);
+};
+const tryResolveFromPackageManager = (packageManager)=>{
+    if (packageManager.startsWith("npm")) {
+        return "npm";
+    }
+    if (packageManager.startsWith("yarn")) {
+        return "yarn";
+    }
+    if (packageManager.startsWith("pnpm")) {
+        return "pnpm";
+    }
+    return undefined;
+};
+const resolveFromLockFileDiscovery = async (workingDirectory)=>{
+    if (await fileExists((0, _nodepath.join)(workingDirectory, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (await fileExists((0, _nodepath.join)(workingDirectory, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    return "npm";
+};
+const fileExists = async (path)=>{
+    try {
+        await (0, _promises.access)(path);
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+//# sourceMappingURL=get-package-manager.js.map

package/src/lib/dependency/get-package-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency/get-package-manager.ts"],"sourcesContent":["import { access } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { readPackageJson } from \"./package-json\";\n\nexport type PackageManager = \"npm\" | \"yarn\" | \"pnpm\";\n\nexport const getPackageManager = async (workingDirectory: string): Promise<PackageManager> => {\n  const packageJsonPath = join(workingDirectory, \"package.json\");\n  const packageJson = await readPackageJson(packageJsonPath);\n\n  if (packageJson.packageManager) {\n    const result = tryResolveFromPackageManager(packageJson.packageManager);\n    if (result) {\n      return result;\n    }\n  }\n\n  return await resolveFromLockFileDiscovery(workingDirectory);\n};\n\nconst tryResolveFromPackageManager = (packageManager: string): PackageManager | undefined => {\n  if (packageManager.startsWith(\"npm\")) {\n    return \"npm\";\n  }\n\n  if (packageManager.startsWith(\"yarn\")) {\n    return \"yarn\";\n  }\n\n  if (packageManager.startsWith(\"pnpm\")) {\n    return \"pnpm\";\n  }\n\n  return undefined;\n};\n\nconst resolveFromLockFileDiscovery = async (workingDirectory: string): Promise<PackageManager> => {\n  if (await fileExists(join(workingDirectory, \"yarn.lock\"))) {\n    return \"yarn\";\n  }\n\n  if (await fileExists(join(workingDirectory, \"pnpm-lock.yaml\"))) {\n    return \"pnpm\";\n  }\n\n  return \"npm\";\n};\n\nconst fileExists = async (path: string): Promise<boolean> => {\n  try {\n    await access(path);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n"],"names":["getPackageManager","workingDirectory","packageJsonPath","join","packageJson","readPackageJson","packageManager","result","tryResolveFromPackageManager","resolveFromLockFileDiscovery","startsWith","undefined","fileExists","path","access","error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAMaA;;;eAAAA;;;0BANU;0BACF;6BACW;AAIzB,MAAMA,oBAAoB,OAAOC;IACtC,MAAMC,kBAAkBC,IAAAA,cAAI,EAACF,kBAAkB;IAC/C,MAAMG,cAAc,MAAMC,IAAAA,4BAAe,EAACH;IAE1C,IAAIE,YAAYE,cAAc,EAAE;QAC9B,MAAMC,SAASC,6BAA6BJ,YAAYE,cAAc;QACtE,IAAIC,QAAQ;YACV,OAAOA;QACT;IACF;IAEA,OAAO,MAAME,6BAA6BR;AAC5C;AAEA,MAAMO,+BAA+B,CAACF;IACpC,IAAIA,eAAeI,UAAU,CAAC,QAAQ;QACpC,OAAO;IACT;IAEA,IAAIJ,eAAeI,UAAU,CAAC,SAAS;QACrC,OAAO;IACT;IAEA,IAAIJ,eAAeI,UAAU,CAAC,SAAS;QACrC,OAAO;IACT;IAEA,OAAOC;AACT;AAEA,MAAMF,+BAA+B,OAAOR;IAC1C,IAAI,MAAMW,WAAWT,IAAAA,cAAI,EAACF,kBAAkB,eAAe;QACzD,OAAO;IACT;IAEA,IAAI,MAAMW,WAAWT,IAAAA,cAAI,EAACF,kBAAkB,oBAAoB;QAC9D,OAAO;IACT;IAEA,OAAO;AACT;AAEA,MAAMW,aAAa,OAAOC;IACxB,IAAI;QACF,MAAMC,IAAAA,gBAAM,EAACD;QACb,OAAO;IACT,EAAE,OAAOE,OAAO;QACd,OAAO;IACT;AACF"}

package/src/lib/{package-json.d.ts → dependency/package-json.d.ts}

@@ -22,6 +22,7 @@ declare const packageJsonValidator: z.ZodObject<{
         type: string;
         url?: string | undefined;
     }>, "many">>;
+    packageManager: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     version: string;
@@ -33,6 +34,7 @@ declare const packageJsonValidator: z.ZodObject<{
         type: string;
         url?: string | undefined;
     }[] | undefined;
+    packageManager?: string | undefined;
 }, {
     name: string;
     version: string;
@@ -44,6 +46,7 @@ declare const packageJsonValidator: z.ZodObject<{
         type: string;
         url?: string | undefined;
     }[] | undefined;
+    packageManager?: string | undefined;
 }>;
 type PackageJson = z.infer<typeof packageJsonValidator>;
 export declare const readPackageJson: (pathToPackageJson: string) => Promise<PackageJson>;

package/src/lib/{package-json.js → dependency/package-json.js}

@@ -15,8 +15,8 @@ _export(exports, {
 });
 const _promises = require("fs/promises");
 const _zod = require("zod");
-const _json5 = require("./config/parsers/json5");
-const _logger = require("./logger");
+const _json5 = require("../config/parsers/json5");
+const _logger = require("../logger");
 const licenseSectionValidator = _zod.z.object({
     type: _zod.z.string(),
     url: _zod.z.string().optional()
@@ -28,7 +28,8 @@ const packageJsonValidator = _zod.z.object({
         _zod.z.string(),
         licenseSectionValidator
     ]).optional(),
-    licenses: licenseSectionValidator.array().optional()
+    licenses: licenseSectionValidator.array().optional(),
+    packageManager: _zod.z.string().optional()
 });
 const readPackageJson = async (pathToPackageJson)=>{
     const doesPackageJsonExist = await doesFileExist(pathToPackageJson);

package/src/lib/dependency/package-json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency/package-json.ts"],"sourcesContent":["import { Stats } from \"fs\";\nimport { readFile, stat } from \"fs/promises\";\nimport { z } from \"zod\";\nimport { json5Parse } from \"../config/parsers/json5\";\nimport logger from \"../logger\";\n\nconst licenseSectionValidator = z.object({\n  type: z.string(),\n  url: z.string().optional()\n});\n\nconst packageJsonValidator = z.object({\n  name: z.string(),\n  version: z.string(),\n  license: z.union([z.string(), licenseSectionValidator]).optional(),\n  licenses: licenseSectionValidator.array().optional(),\n  packageManager: z.string().optional()\n});\n\ntype PackageJson = z.infer<typeof packageJsonValidator>;\n\nexport const readPackageJson = async (pathToPackageJson: string): Promise<PackageJson> => {\n  const doesPackageJsonExist = await doesFileExist(pathToPackageJson);\n  if (!doesPackageJsonExist) {\n    logger.verbose(`Cannot find the package.json: '${pathToPackageJson}'`);\n    throw new Error(`Cannot find the file: '${pathToPackageJson}'`);\n  }\n\n  const packageJsonAsString: string = await readFile(pathToPackageJson, { encoding: \"utf8\" });\n\n  const parsedFile = json5Parse<unknown>(packageJsonAsString);\n\n  const packageJson = packageJsonValidator.safeParse(parsedFile);\n\n  if (!packageJson.success) {\n    throw new Error(\n      `Unable to parse package.json: ${pathToPackageJson}: ${packageJson.error.message}`\n    );\n  }\n\n  return packageJson.data;\n};\n\nexport const getLicenseExpression = (packageJson: PackageJson): string => {\n  if (packageJson.license && typeof packageJson.license === \"string\") {\n    return packageJson.license;\n  }\n\n  if (packageJson.license && typeof packageJson.license === \"object\") {\n    return packageJson.license.type;\n  }\n\n  if (packageJson.licenses) {\n    const licenses = packageJson.licenses.map<string>(license => license.type);\n\n    if (licenses.length === 1) {\n      return licenses[0];\n    }\n\n    return `(${licenses.join(\" AND \")})`;\n  }\n\n  return \"UNLICENSED\";\n};\n\nconst doesFileExist = async (path: string): Promise<boolean> => {\n  try {\n    const stats: Stats = await stat(path);\n    return stats.isFile();\n  } catch {\n    return false;\n  }\n};\n"],"names":["getLicenseExpression","readPackageJson","licenseSectionValidator","z","object","type","string","url","optional","packageJsonValidator","name","version","license","union","licenses","array","packageManager","pathToPackageJson","doesPackageJsonExist","doesFileExist","logger","verbose","Error","packageJsonAsString","readFile","encoding","parsedFile","json5Parse","packageJson","safeParse","success","error","message","data","map","length","join","path","stats","stat","isFile"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IA2CaA,oBAAoB;eAApBA;;IAtBAC,eAAe;eAAfA;;;0BApBkB;qBACb;uBACS;wBACR;AAEnB,MAAMC,0BAA0BC,MAAC,CAACC,MAAM,CAAC;IACvCC,MAAMF,MAAC,CAACG,MAAM;IACdC,KAAKJ,MAAC,CAACG,MAAM,GAAGE,QAAQ;AAC1B;AAEA,MAAMC,uBAAuBN,MAAC,CAACC,MAAM,CAAC;IACpCM,MAAMP,MAAC,CAACG,MAAM;IACdK,SAASR,MAAC,CAACG,MAAM;IACjBM,SAAST,MAAC,CAACU,KAAK,CAAC;QAACV,MAAC,CAACG,MAAM;QAAIJ;KAAwB,EAAEM,QAAQ;IAChEM,UAAUZ,wBAAwBa,KAAK,GAAGP,QAAQ;IAClDQ,gBAAgBb,MAAC,CAACG,MAAM,GAAGE,QAAQ;AACrC;AAIO,MAAMP,kBAAkB,OAAOgB;IACpC,MAAMC,uBAAuB,MAAMC,cAAcF;IACjD,IAAI,CAACC,sBAAsB;QACzBE,eAAM,CAACC,OAAO,CAAC,CAAC,+BAA+B,EAAEJ,kBAAkB,CAAC,CAAC;QACrE,MAAM,IAAIK,MAAM,CAAC,uBAAuB,EAAEL,kBAAkB,CAAC,CAAC;IAChE;IAEA,MAAMM,sBAA8B,MAAMC,IAAAA,kBAAQ,EAACP,mBAAmB;QAAEQ,UAAU;IAAO;IAEzF,MAAMC,aAAaC,IAAAA,iBAAU,EAAUJ;IAEvC,MAAMK,cAAcnB,qBAAqBoB,SAAS,CAACH;IAEnD,IAAI,CAACE,YAAYE,OAAO,EAAE;QACxB,MAAM,IAAIR,MACR,CAAC,8BAA8B,EAAEL,kBAAkB,EAAE,EAAEW,YAAYG,KAAK,CAACC,OAAO,CAAC,CAAC;IAEtF;IAEA,OAAOJ,YAAYK,IAAI;AACzB;AAEO,MAAMjC,uBAAuB,CAAC4B;IACnC,IAAIA,YAAYhB,OAAO,IAAI,OAAOgB,YAAYhB,OAAO,KAAK,UAAU;QAClE,OAAOgB,YAAYhB,OAAO;IAC5B;IAEA,IAAIgB,YAAYhB,OAAO,IAAI,OAAOgB,YAAYhB,OAAO,KAAK,UAAU;QAClE,OAAOgB,YAAYhB,OAAO,CAACP,IAAI;IACjC;IAEA,IAAIuB,YAAYd,QAAQ,EAAE;QACxB,MAAMA,WAAWc,YAAYd,QAAQ,CAACoB,GAAG,CAAStB,CAAAA,UAAWA,QAAQP,IAAI;QAEzE,IAAIS,SAASqB,MAAM,KAAK,GAAG;YACzB,OAAOrB,QAAQ,CAAC,EAAE;QACpB;QAEA,OAAO,CAAC,CAAC,EAAEA,SAASsB,IAAI,CAAC,SAAS,CAAC,CAAC;IACtC;IAEA,OAAO;AACT;AAEA,MAAMjB,gBAAgB,OAAOkB;IAC3B,IAAI;QACF,MAAMC,QAAe,MAAMC,IAAAA,cAAI,EAACF;QAChC,OAAOC,MAAME,MAAM;IACrB,EAAE,UAAM;QACN,OAAO;IACT;AACF"}

package/src/lib/dependency/package-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency/package-rules.ts"],"sourcesContent":["import { satisfies } from \"compare-versions\";\n\nexport const isAllowedPackage = (\n  packageName: string,\n  packageVersion: string,\n  allowedPackages: string[]\n) => {\n  for (const allowedPackage of allowedPackages) {\n    if (allowedPackage === packageName) {\n      return true;\n    }\n\n    if (allowedPackage.startsWith(packageName + \"@\")) {\n      const allowedPackageVersion = allowedPackage.substring(packageName.length + 1);\n\n      if (satisfies(packageVersion, allowedPackageVersion)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n"],"names":["isAllowedPackage","packageName","packageVersion","allowedPackages","allowedPackage","startsWith","allowedPackageVersion","substring","length","satisfies"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";+BAEaA;;;eAAAA;;;iCAFa;AAEnB,MAAMA,mBAAmB,CAC9BC,aACAC,gBACAC;IAEA,KAAK,MAAMC,kBAAkBD,gBAAiB;QAC5C,IAAIC,mBAAmBH,aAAa;YAClC,OAAO;QACT;QAEA,IAAIG,eAAeC,UAAU,CAACJ,cAAc,MAAM;YAChD,MAAMK,wBAAwBF,eAAeG,SAAS,CAACN,YAAYO,MAAM,GAAG;YAE5E,IAAIC,IAAAA,0BAAS,EAACP,gBAAgBI,wBAAwB;gBACpD,OAAO;YACT;QACF;IACF;IAEA,OAAO;AACT"}

package/src/lib/dependency-scanning/npm.d.ts

@@ -0,0 +1,3 @@
+import { CheckLicensesResult } from "../result";
+import { DependencyScanningOptions } from "./options";
+export declare const npmDependencyScanning: (options: DependencyScanningOptions) => Promise<CheckLicensesResult>;

package/src/lib/dependency-scanning/npm.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "npmDependencyScanning", {
+    enumerable: true,
+    get: function() {
+        return npmDependencyScanning;
+    }
+});
+const _nodepath = require("node:path");
+const _packagejson = require("../dependency/package-json");
+const _packagerules = require("../dependency/package-rules");
+const _logger = require("../logger");
+const _calculateissues = require("../spdx/calculate-issues");
+const _parselicenseexpression = require("../spdx/parse-license-expression");
+const _joinstringarray = require("../utils/join-string-array");
+const Arborist = require("@npmcli/arborist");
+const npmDependencyScanning = async (options)=>{
+    const { workingDirectory, allowedLicenses, allowedPackages, includeDevDependencies, devDependenciesOnly } = options;
+    const foundAllowedPackages = new Set();
+    const packagesWithAllowedLicenses = new Set();
+    const packagesWithNoLicenses = new Set();
+    const packagesWithForbiddenLicenses = new Set();
+    const arborist = new Arborist({
+        path: workingDirectory
+    });
+    const topNode = await arborist.loadActual();
+    // This function is very similar to the one in pnpm.ts
+    // If you change this, you probably want to change that one too
+    const parseNode = async (node)=>{
+        _logger.default.verbose(`Parsing node: ${node.name}`);
+        const isDevDependency = node.dev;
+        if (!includeDevDependencies && !devDependenciesOnly && isDevDependency) {
+            return;
+        }
+        if (devDependenciesOnly && !isDevDependency) {
+            return;
+        }
+        const packageJsonPath = (0, _nodepath.join)(node.realpath, "package.json");
+        const packageJson = await (0, _packagejson.readPackageJson)(packageJsonPath);
+        if ((0, _packagerules.isAllowedPackage)(node.name, packageJson.version, allowedPackages)) {
+            _logger.default.verbose(`Package ${packageJson.name} is an allowed package`);
+            foundAllowedPackages.add({
+                name: packageJson.name,
+                version: packageJson.version
+            });
+            if (node.children.size > 0) {
+                await parseNodes(node.children.values());
+            }
+            return;
+        }
+        const rawLicenseExpression = (0, _packagejson.getLicenseExpression)(packageJson);
+        const licenseExpression = (0, _parselicenseexpression.parseLicenseExpression)(rawLicenseExpression);
+        if (licenseExpression.type === "unlicensed") {
+            _logger.default.verbose(`Package ${packageJson.name} is unlicensed`);
+            packagesWithNoLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version
+            });
+            if (node.children.size > 0) {
+                await parseNodes(node.children.values());
+            }
+            return;
+        }
+        const licenseIssues = (0, _calculateissues.calculateIssues)(licenseExpression, allowedLicenses);
+        const joinedIssues = (0, _joinstringarray.joinStringArray)(licenseIssues);
+        if (licenseIssues.length > 0) {
+            _logger.default.verbose(`Package ${packageJson.name} has the forbidden license: ${joinedIssues}`);
+            packagesWithForbiddenLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version,
+                licenseIdentifiers: joinedIssues,
+                spdxExpression: rawLicenseExpression
+            });
+        } else {
+            _logger.default.verbose(`Package ${packageJson.name} has the allowed license: ${rawLicenseExpression}`);
+            packagesWithAllowedLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version,
+                spdxExpression: rawLicenseExpression,
+                licenses: licenseExpression
+            });
+        }
+        if (node.children.size > 0) {
+            parseNodes(node.children.values());
+        }
+    };
+    const parseNodes = async (nodes)=>{
+        for (const node of nodes){
+            await parseNode(node);
+        }
+    };
+    await parseNodes(topNode.children.values());
+    return {
+        allowedPackages: foundAllowedPackages,
+        allowedLicenses: packagesWithAllowedLicenses,
+        noLicenses: packagesWithNoLicenses,
+        forbiddenLicenses: packagesWithForbiddenLicenses
+    };
+};
+
+//# sourceMappingURL=npm.js.map

package/src/lib/dependency-scanning/npm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency-scanning/npm.ts"],"sourcesContent":["import Arborist = require(\"@npmcli/arborist\");\nimport { Link, Node } from \"@npmcli/arborist\";\nimport { join } from \"node:path\";\nimport { getLicenseExpression, readPackageJson } from \"../dependency/package-json\";\nimport { isAllowedPackage } from \"../dependency/package-rules\";\nimport logger from \"../logger\";\nimport {\n  AllowedPackage,\n  CheckLicensesResult,\n  ForbiddenLicenseResult,\n  LicensedPackage,\n  NoLicenseResult\n} from \"../result\";\nimport { calculateIssues } from \"../spdx/calculate-issues\";\nimport { parseLicenseExpression } from \"../spdx/parse-license-expression\";\nimport { joinStringArray } from \"../utils/join-string-array\";\nimport { DependencyScanningOptions } from \"./options\";\n\nexport const npmDependencyScanning = async (\n  options: DependencyScanningOptions\n): Promise<CheckLicensesResult> => {\n  const {\n    workingDirectory,\n    allowedLicenses,\n    allowedPackages,\n    includeDevDependencies,\n    devDependenciesOnly\n  } = options;\n\n  const foundAllowedPackages = new Set<AllowedPackage>();\n  const packagesWithAllowedLicenses = new Set<LicensedPackage>();\n  const packagesWithNoLicenses = new Set<NoLicenseResult>();\n  const packagesWithForbiddenLicenses = new Set<ForbiddenLicenseResult>();\n\n  const arborist = new Arborist({ path: workingDirectory });\n\n  const topNode = await arborist.loadActual();\n\n  // This function is very similar to the one in pnpm.ts\n  // If you change this, you probably want to change that one too\n  const parseNode = async (node: Node | Link) => {\n    logger.verbose(`Parsing node: ${node.name}`);\n\n    const isDevDependency = node.dev;\n\n    if (!includeDevDependencies && !devDependenciesOnly && isDevDependency) {\n      return;\n    }\n\n    if (devDependenciesOnly && !isDevDependency) {\n      return;\n    }\n\n    const packageJsonPath = join(node.realpath, \"package.json\");\n    const packageJson = await readPackageJson(packageJsonPath);\n\n    if (isAllowedPackage(node.name, packageJson.version, allowedPackages)) {\n      logger.verbose(`Package ${packageJson.name} is an allowed package`);\n      foundAllowedPackages.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      if (node.children.size > 0) {\n        await parseNodes(node.children.values());\n      }\n      return;\n    }\n\n    const rawLicenseExpression = getLicenseExpression(packageJson);\n    const licenseExpression = parseLicenseExpression(rawLicenseExpression);\n\n    if (licenseExpression.type === \"unlicensed\") {\n      logger.verbose(`Package ${packageJson.name} is unlicensed`);\n      packagesWithNoLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      if (node.children.size > 0) {\n        await parseNodes(node.children.values());\n      }\n      return;\n    }\n\n    const licenseIssues = calculateIssues(licenseExpression, allowedLicenses);\n    const joinedIssues = joinStringArray(licenseIssues);\n\n    if (licenseIssues.length > 0) {\n      logger.verbose(`Package ${packageJson.name} has the forbidden license: ${joinedIssues}`);\n      packagesWithForbiddenLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        licenseIdentifiers: joinedIssues,\n        spdxExpression: rawLicenseExpression\n      });\n    } else {\n      logger.verbose(\n        `Package ${packageJson.name} has the allowed license: ${rawLicenseExpression}`\n      );\n      packagesWithAllowedLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        spdxExpression: rawLicenseExpression,\n        licenses: licenseExpression\n      });\n    }\n\n    if (node.children.size > 0) {\n      parseNodes(node.children.values());\n    }\n  };\n\n  const parseNodes = async (nodes: IterableIterator<Node | Link>) => {\n    for (const node of nodes) {\n      await parseNode(node);\n    }\n  };\n\n  await parseNodes(topNode.children.values());\n\n  return {\n    allowedPackages: foundAllowedPackages,\n    allowedLicenses: packagesWithAllowedLicenses,\n    noLicenses: packagesWithNoLicenses,\n    forbiddenLicenses: packagesWithForbiddenLicenses\n  };\n};\n"],"names":["npmDependencyScanning","Arborist","options","workingDirectory","allowedLicenses","allowedPackages","includeDevDependencies","devDependenciesOnly","foundAllowedPackages","Set","packagesWithAllowedLicenses","packagesWithNoLicenses","packagesWithForbiddenLicenses","arborist","path","topNode","loadActual","parseNode","node","logger","verbose","name","isDevDependency","dev","packageJsonPath","join","realpath","packageJson","readPackageJson","isAllowedPackage","version","add","children","size","parseNodes","values","rawLicenseExpression","getLicenseExpression","licenseExpression","parseLicenseExpression","type","licenseIssues","calculateIssues","joinedIssues","joinStringArray","length","licenseIdentifiers","spdxExpression","licenses","nodes","noLicenses","forbiddenLicenses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/lib/dependency-scanning/options.d.ts

@@ -0,0 +1,2 @@
+import { LicenseCopOptions } from "../license-cop";
+export type DependencyScanningOptions = Required<LicenseCopOptions>;

package/src/lib/dependency-scanning/options.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=options.js.map

package/src/lib/dependency-scanning/options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency-scanning/options.ts"],"names":[],"rangeMappings":"","mappings":""}

package/src/lib/dependency-scanning/pnpm.d.ts

@@ -0,0 +1,3 @@
+import { CheckLicensesResult } from "../result";
+import { DependencyScanningOptions } from "./options";
+export declare const pnpmDependencyScanning: (options: DependencyScanningOptions) => Promise<CheckLicensesResult>;

package/src/lib/dependency-scanning/pnpm.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "pnpmDependencyScanning", {
+    enumerable: true,
+    get: function() {
+        return pnpmDependencyScanning;
+    }
+});
+const _reviewingdependencieshierarchy = require("@pnpm/reviewing.dependencies-hierarchy");
+const _nodepath = require("node:path");
+const _packagejson = require("../dependency/package-json");
+const _packagerules = require("../dependency/package-rules");
+const _logger = require("../logger");
+const _calculateissues = require("../spdx/calculate-issues");
+const _parselicenseexpression = require("../spdx/parse-license-expression");
+const _joinstringarray = require("../utils/join-string-array");
+const pnpmDependencyScanning = async (options)=>{
+    const { workingDirectory, allowedLicenses, allowedPackages, includeDevDependencies, devDependenciesOnly } = options;
+    const foundAllowedPackages = new Set();
+    const packagesWithAllowedLicenses = new Set();
+    const packagesWithNoLicenses = new Set();
+    const packagesWithForbiddenLicenses = new Set();
+    const dependencyHierarchies = await (0, _reviewingdependencieshierarchy.buildDependenciesHierarchy)([
+        workingDirectory
+    ], {
+        depth: Infinity,
+        include: {
+            dependencies: !devDependenciesOnly,
+            devDependencies: includeDevDependencies,
+            optionalDependencies: false
+        },
+        lockfileDir: workingDirectory,
+        virtualStoreDirMaxLength: Infinity
+    });
+    // This function is very similar to the one in npm.ts
+    // If you change this, you probably want to change that one too
+    const parseNode = async (node)=>{
+        _logger.default.verbose(`Parsing node: ${node.name}`);
+        const packageJsonPath = (0, _nodepath.join)(node.path, "package.json");
+        const packageJson = await (0, _packagejson.readPackageJson)(packageJsonPath);
+        if ((0, _packagerules.isAllowedPackage)(packageJson.name, packageJson.version, allowedPackages)) {
+            _logger.default.verbose(`Package ${packageJson.name} is an allowed package`);
+            foundAllowedPackages.add({
+                name: packageJson.name,
+                version: packageJson.version
+            });
+            await parseNodes(node.dependencies);
+            return;
+        }
+        const rawLicenseExpression = (0, _packagejson.getLicenseExpression)(packageJson);
+        const licenseExpression = (0, _parselicenseexpression.parseLicenseExpression)(rawLicenseExpression);
+        if (licenseExpression.type === "unlicensed") {
+            _logger.default.verbose(`Package ${packageJson.name} is unlicensed`);
+            packagesWithNoLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version
+            });
+            await parseNodes(node.dependencies);
+            return;
+        }
+        const licenseIssues = (0, _calculateissues.calculateIssues)(licenseExpression, allowedLicenses);
+        const joinedIssues = (0, _joinstringarray.joinStringArray)(licenseIssues);
+        if (licenseIssues.length > 0) {
+            _logger.default.verbose(`Package ${packageJson.name} has the forbidden license: ${joinedIssues}`);
+            packagesWithForbiddenLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version,
+                licenseIdentifiers: joinedIssues,
+                spdxExpression: rawLicenseExpression
+            });
+        } else {
+            _logger.default.verbose(`Package ${packageJson.name} has the allowed license: ${rawLicenseExpression}`);
+            packagesWithAllowedLicenses.add({
+                name: packageJson.name,
+                version: packageJson.version,
+                spdxExpression: rawLicenseExpression,
+                licenses: licenseExpression
+            });
+        }
+        await parseNodes(node.dependencies);
+    };
+    const parseNodes = async (nodes)=>{
+        if (!nodes) {
+            return;
+        }
+        for (const node of nodes){
+            await parseNode(node);
+        }
+    };
+    for (const hierarchies of Object.values(dependencyHierarchies)){
+        await parseNodes(hierarchies.dependencies);
+        await parseNodes(hierarchies.devDependencies);
+        await parseNodes(hierarchies.optionalDependencies);
+        await parseNodes(hierarchies.unsavedDependencies);
+    }
+    return {
+        allowedPackages: foundAllowedPackages,
+        allowedLicenses: packagesWithAllowedLicenses,
+        noLicenses: packagesWithNoLicenses,
+        forbiddenLicenses: packagesWithForbiddenLicenses
+    };
+};
+
+//# sourceMappingURL=pnpm.js.map

package/src/lib/dependency-scanning/pnpm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency-scanning/pnpm.ts"],"sourcesContent":["import {\n  buildDependenciesHierarchy,\n  type PackageNode\n} from \"@pnpm/reviewing.dependencies-hierarchy\";\nimport { join } from \"node:path\";\nimport { getLicenseExpression, readPackageJson } from \"../dependency/package-json\";\nimport { isAllowedPackage } from \"../dependency/package-rules\";\nimport logger from \"../logger\";\nimport {\n  AllowedPackage,\n  CheckLicensesResult,\n  ForbiddenLicenseResult,\n  LicensedPackage,\n  NoLicenseResult\n} from \"../result\";\nimport { calculateIssues } from \"../spdx/calculate-issues\";\nimport { parseLicenseExpression } from \"../spdx/parse-license-expression\";\nimport { joinStringArray } from \"../utils/join-string-array\";\nimport { DependencyScanningOptions } from \"./options\";\n\nexport const pnpmDependencyScanning = async (\n  options: DependencyScanningOptions\n): Promise<CheckLicensesResult> => {\n  const {\n    workingDirectory,\n    allowedLicenses,\n    allowedPackages,\n    includeDevDependencies,\n    devDependenciesOnly\n  } = options;\n\n  const foundAllowedPackages = new Set<AllowedPackage>();\n  const packagesWithAllowedLicenses = new Set<LicensedPackage>();\n  const packagesWithNoLicenses = new Set<NoLicenseResult>();\n  const packagesWithForbiddenLicenses = new Set<ForbiddenLicenseResult>();\n\n  const dependencyHierarchies = await buildDependenciesHierarchy([workingDirectory], {\n    depth: Infinity,\n    include: {\n      dependencies: !devDependenciesOnly,\n      devDependencies: includeDevDependencies,\n      optionalDependencies: false\n    },\n    lockfileDir: workingDirectory,\n    virtualStoreDirMaxLength: Infinity\n  });\n\n  // This function is very similar to the one in npm.ts\n  // If you change this, you probably want to change that one too\n  const parseNode = async (node: PackageNode) => {\n    logger.verbose(`Parsing node: ${node.name}`);\n\n    const packageJsonPath = join(node.path, \"package.json\");\n    const packageJson = await readPackageJson(packageJsonPath);\n\n    if (isAllowedPackage(packageJson.name, packageJson.version, allowedPackages)) {\n      logger.verbose(`Package ${packageJson.name} is an allowed package`);\n      foundAllowedPackages.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      await parseNodes(node.dependencies);\n      return;\n    }\n\n    const rawLicenseExpression = getLicenseExpression(packageJson);\n    const licenseExpression = parseLicenseExpression(rawLicenseExpression);\n\n    if (licenseExpression.type === \"unlicensed\") {\n      logger.verbose(`Package ${packageJson.name} is unlicensed`);\n      packagesWithNoLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      await parseNodes(node.dependencies);\n      return;\n    }\n\n    const licenseIssues = calculateIssues(licenseExpression, allowedLicenses);\n    const joinedIssues = joinStringArray(licenseIssues);\n\n    if (licenseIssues.length > 0) {\n      logger.verbose(`Package ${packageJson.name} has the forbidden license: ${joinedIssues}`);\n      packagesWithForbiddenLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        licenseIdentifiers: joinedIssues,\n        spdxExpression: rawLicenseExpression\n      });\n    } else {\n      logger.verbose(\n        `Package ${packageJson.name} has the allowed license: ${rawLicenseExpression}`\n      );\n      packagesWithAllowedLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        spdxExpression: rawLicenseExpression,\n        licenses: licenseExpression\n      });\n    }\n\n    await parseNodes(node.dependencies);\n  };\n\n  const parseNodes = async (nodes: PackageNode[] | undefined) => {\n    if (!nodes) {\n      return;\n    }\n\n    for (const node of nodes) {\n      await parseNode(node);\n    }\n  };\n\n  for (const hierarchies of Object.values(dependencyHierarchies)) {\n    await parseNodes(hierarchies.dependencies);\n    await parseNodes(hierarchies.devDependencies);\n    await parseNodes(hierarchies.optionalDependencies);\n    await parseNodes(hierarchies.unsavedDependencies);\n  }\n\n  return {\n    allowedPackages: foundAllowedPackages,\n    allowedLicenses: packagesWithAllowedLicenses,\n    noLicenses: packagesWithNoLicenses,\n    forbiddenLicenses: packagesWithForbiddenLicenses\n  };\n};\n"],"names":["pnpmDependencyScanning","options","workingDirectory","allowedLicenses","allowedPackages","includeDevDependencies","devDependenciesOnly","foundAllowedPackages","Set","packagesWithAllowedLicenses","packagesWithNoLicenses","packagesWithForbiddenLicenses","dependencyHierarchies","buildDependenciesHierarchy","depth","Infinity","include","dependencies","devDependencies","optionalDependencies","lockfileDir","virtualStoreDirMaxLength","parseNode","node","logger","verbose","name","packageJsonPath","join","path","packageJson","readPackageJson","isAllowedPackage","version","add","parseNodes","rawLicenseExpression","getLicenseExpression","licenseExpression","parseLicenseExpression","type","licenseIssues","calculateIssues","joinedIssues","joinStringArray","length","licenseIdentifiers","spdxExpression","licenses","nodes","hierarchies","Object","values","unsavedDependencies","noLicenses","forbiddenLicenses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/lib/license-cop.d.ts

@@ -1,9 +1,9 @@
 import { CheckLicensesResult } from "./result";
-export interface LicenseCopOptions {
+export type LicenseCopOptions = {
     allowedLicenses: string[];
     allowedPackages: string[];
     workingDirectory?: string;
     includeDevDependencies?: boolean;
     devDependenciesOnly?: boolean;
-}
+};
 export declare const checkLicenses: (options: LicenseCopOptions) => Promise<CheckLicensesResult>;

package/src/lib/license-cop.js

@@ -5,91 +5,42 @@ Object.defineProperty(exports, "checkLicenses", {
         return checkLicenses;
     }
 });
-const _arborist = require("@npmcli/arborist");
 const _path = require("path");
-const _logger = require("./logger");
-const _packagejson = require("./package-json");
-const _packagerules = require("./package-rules");
-const _calculateissues = require("./spdx/calculate-issues");
-const _parselicenseexpression = require("./spdx/parse-license-expression");
-const _joinstringarray = require("./utils/join-string-array");
-const checkLicenses = async (options)=>{
-    const { workingDirectory, allowedLicenses, allowedPackages, includeDevDependencies, devDependenciesOnly } = options;
-    const foundAllowedPackages = new Set();
-    const packagesWithAllowedLicenses = new Set();
-    const packagesWithNoLicenses = new Set();
-    const packagesWithForbiddenLicenses = new Set();
-    const path = resolvePath(workingDirectory);
-    const arborist = new _arborist({
-        path
-    });
-    const topNode = await arborist.loadActual();
-    const parseNode = async (node)=>{
-        _logger.default.verbose(`Parsing node: ${node.name}`);
-        const isDevDependency = node.dev;
-        if (!includeDevDependencies && !devDependenciesOnly && isDevDependency) {
-            return;
-        }
-        if (devDependenciesOnly && !isDevDependency) {
-            return;
-        }
-        const packageJsonPath = (0, _path.join)(node.realpath, "package.json");
-        const packageJson = await (0, _packagejson.readPackageJson)(packageJsonPath);
-        if ((0, _packagerules.isAllowedPackage)(node.name, packageJson.version, allowedPackages)) {
-            foundAllowedPackages.add({
-                name: packageJson.name,
-                version: packageJson.version
-            });
-            if (node.children.size > 0) {
-                await parseNodes(node.children.values());
+const _npm = require("./dependency-scanning/npm");
+const _pnpm = require("./dependency-scanning/pnpm");
+const _getpackagemanager = require("./dependency/get-package-manager");
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
             }
-            return;
-        }
-        const rawLicenseExpression = (0, _packagejson.getLicenseExpression)(packageJson);
-        const licenseExpression = (0, _parselicenseexpression.parseLicenseExpression)(rawLicenseExpression);
-        if (licenseExpression.type === "unlicensed") {
-            packagesWithNoLicenses.add({
-                name: packageJson.name,
-                version: packageJson.version
-            });
-            if (node.children.size > 0) {
-                await parseNodes(node.children.values());
-            }
-            return;
-        }
-        const licenseIssues = (0, _calculateissues.calculateIssues)(licenseExpression, allowedLicenses);
-        const joinedIssues = (0, _joinstringarray.joinStringArray)(licenseIssues);
-        if (licenseIssues.length > 0) {
-            packagesWithForbiddenLicenses.add({
-                name: packageJson.name,
-                version: packageJson.version,
-                licenseIdentifiers: joinedIssues,
-                spdxExpression: rawLicenseExpression
-            });
-        } else {
-            packagesWithAllowedLicenses.add({
-                name: packageJson.name,
-                version: packageJson.version,
-                spdxExpression: rawLicenseExpression,
-                licenses: licenseExpression
-            });
         }
-        if (node.children.size > 0) {
-            parseNodes(node.children.values());
-        }
-    };
-    const parseNodes = async (nodes)=>{
-        for (const node of nodes){
-            await parseNode(node);
-        }
-    };
-    await parseNodes(topNode.children.values());
-    return {
-        allowedPackages: foundAllowedPackages,
-        allowedLicenses: packagesWithAllowedLicenses,
-        noLicenses: packagesWithNoLicenses,
-        forbiddenLicenses: packagesWithForbiddenLicenses
+        return target;
     };
+    return _extends.apply(this, arguments);
+}
+const checkLicenses = async (options)=>{
+    const fullProjectPath = resolvePath(options.workingDirectory);
+    var _options_includeDevDependencies;
+    const includeDevDependencies = (_options_includeDevDependencies = options.includeDevDependencies) != null ? _options_includeDevDependencies : false;
+    var _options_devDependenciesOnly;
+    const devDependenciesOnly = (_options_devDependenciesOnly = options.devDependenciesOnly) != null ? _options_devDependenciesOnly : false;
+    const dependencyScanningOptions = _extends({}, options, {
+        workingDirectory: fullProjectPath,
+        includeDevDependencies,
+        devDependenciesOnly
+    });
+    const packageManager = await (0, _getpackagemanager.getPackageManager)(fullProjectPath);
+    switch(packageManager){
+        case "pnpm":
+            return (0, _pnpm.pnpmDependencyScanning)(dependencyScanningOptions);
+        default:
+            return (0, _npm.npmDependencyScanning)(dependencyScanningOptions);
+    }
 };
 const resolvePath = (path)=>{
     if (!path) {

package/src/lib/license-cop.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/license-cop.ts"],"sourcesContent":["import * as Arborist from \"@npmcli/arborist\";\nimport { Link, Node } from \"@npmcli/arborist\";\nimport { isAbsolute, join } from \"path\";\nimport logger from \"./logger\";\nimport { getLicenseExpression, readPackageJson } from \"./package-json\";\nimport { isAllowedPackage } from \"./package-rules\";\nimport {\n  AllowedPackage,\n  CheckLicensesResult,\n  ForbiddenLicenseResult,\n  LicensedPackage,\n  NoLicenseResult\n} from \"./result\";\nimport { calculateIssues } from \"./spdx/calculate-issues\";\nimport { parseLicenseExpression } from \"./spdx/parse-license-expression\";\nimport { joinStringArray } from \"./utils/join-string-array\";\n\nexport interface LicenseCopOptions {\n  allowedLicenses: string[];\n  allowedPackages: string[];\n  workingDirectory?: string;\n  includeDevDependencies?: boolean;\n  devDependenciesOnly?: boolean;\n}\n\nexport const checkLicenses = async (options: LicenseCopOptions): Promise<CheckLicensesResult> => {\n  const {\n    workingDirectory,\n    allowedLicenses,\n    allowedPackages,\n    includeDevDependencies,\n    devDependenciesOnly\n  } = options;\n\n  const foundAllowedPackages = new Set<AllowedPackage>();\n  const packagesWithAllowedLicenses = new Set<LicensedPackage>();\n  const packagesWithNoLicenses = new Set<NoLicenseResult>();\n  const packagesWithForbiddenLicenses = new Set<ForbiddenLicenseResult>();\n\n  const path = resolvePath(workingDirectory);\n  const arborist = new Arborist({ path });\n\n  const topNode = await arborist.loadActual();\n\n  const parseNode = async (node: Node | Link) => {\n    logger.verbose(`Parsing node: ${node.name}`);\n\n    const isDevDependency = node.dev;\n\n    if (!includeDevDependencies && !devDependenciesOnly && isDevDependency) {\n      return;\n    }\n\n    if (devDependenciesOnly && !isDevDependency) {\n      return;\n    }\n\n    const packageJsonPath = join(node.realpath, \"package.json\");\n    const packageJson = await readPackageJson(packageJsonPath);\n\n    if (isAllowedPackage(node.name, packageJson.version, allowedPackages)) {\n      foundAllowedPackages.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      if (node.children.size > 0) {\n        await parseNodes(node.children.values());\n      }\n      return;\n    }\n\n    const rawLicenseExpression = getLicenseExpression(packageJson);\n    const licenseExpression = parseLicenseExpression(rawLicenseExpression);\n\n    if (licenseExpression.type === \"unlicensed\") {\n      packagesWithNoLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version\n      });\n\n      if (node.children.size > 0) {\n        await parseNodes(node.children.values());\n      }\n      return;\n    }\n\n    const licenseIssues = calculateIssues(licenseExpression, allowedLicenses);\n    const joinedIssues = joinStringArray(licenseIssues);\n\n    if (licenseIssues.length > 0) {\n      packagesWithForbiddenLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        licenseIdentifiers: joinedIssues,\n        spdxExpression: rawLicenseExpression\n      });\n    } else {\n      packagesWithAllowedLicenses.add({\n        name: packageJson.name,\n        version: packageJson.version,\n        spdxExpression: rawLicenseExpression,\n        licenses: licenseExpression\n      });\n    }\n\n    if (node.children.size > 0) {\n      parseNodes(node.children.values());\n    }\n  };\n\n  const parseNodes = async (nodes: IterableIterator<Node | Link>) => {\n    for (const node of nodes) {\n      await parseNode(node);\n    }\n  };\n\n  await parseNodes(topNode.children.values());\n\n  return {\n    allowedPackages: foundAllowedPackages,\n    allowedLicenses: packagesWithAllowedLicenses,\n    noLicenses: packagesWithNoLicenses,\n    forbiddenLicenses: packagesWithForbiddenLicenses\n  };\n};\n\nconst resolvePath = (path?: string): string => {\n  if (!path) {\n    return process.cwd();\n  }\n\n  return isAbsolute(path) ? path : join(process.cwd(), path);\n};\n"],"names":["checkLicenses","options","workingDirectory","allowedLicenses","allowedPackages","includeDevDependencies","devDependenciesOnly","foundAllowedPackages","Set","packagesWithAllowedLicenses","packagesWithNoLicenses","packagesWithForbiddenLicenses","path","resolvePath","arborist","Arborist","topNode","loadActual","parseNode","node","logger","verbose","name","isDevDependency","dev","packageJsonPath","join","realpath","packageJson","readPackageJson","isAllowedPackage","version","add","children","size","parseNodes","values","rawLicenseExpression","getLicenseExpression","licenseExpression","parseLicenseExpression","type","licenseIssues","calculateIssues","joinedIssues","joinStringArray","length","licenseIdentifiers","spdxExpression","licenses","nodes","noLicenses","forbiddenLicenses","process","cwd","isAbsolute"],"mappings":"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"}
+{"version":3,"sources":["../../../../../packages/license-cop/src/lib/license-cop.ts"],"sourcesContent":["import { isAbsolute, join } from \"path\";\nimport { npmDependencyScanning } from \"./dependency-scanning/npm\";\nimport { DependencyScanningOptions } from \"./dependency-scanning/options\";\nimport { pnpmDependencyScanning } from \"./dependency-scanning/pnpm\";\nimport { getPackageManager } from \"./dependency/get-package-manager\";\nimport { CheckLicensesResult } from \"./result\";\n\nexport type LicenseCopOptions = {\n  allowedLicenses: string[];\n  allowedPackages: string[];\n  workingDirectory?: string;\n  includeDevDependencies?: boolean;\n  devDependenciesOnly?: boolean;\n};\n\nexport const checkLicenses = async (options: LicenseCopOptions): Promise<CheckLicensesResult> => {\n  const fullProjectPath = resolvePath(options.workingDirectory);\n  const includeDevDependencies = options.includeDevDependencies ?? false;\n  const devDependenciesOnly = options.devDependenciesOnly ?? false;\n\n  const dependencyScanningOptions: DependencyScanningOptions = {\n    ...options,\n    workingDirectory: fullProjectPath,\n    includeDevDependencies,\n    devDependenciesOnly\n  };\n\n  const packageManager = await getPackageManager(fullProjectPath);\n\n  switch (packageManager) {\n    case \"pnpm\":\n      return pnpmDependencyScanning(dependencyScanningOptions);\n    default:\n      return npmDependencyScanning(dependencyScanningOptions);\n  }\n};\n\nconst resolvePath = (path?: string): string => {\n  if (!path) {\n    return process.cwd();\n  }\n\n  return isAbsolute(path) ? path : join(process.cwd(), path);\n};\n"],"names":["checkLicenses","options","fullProjectPath","resolvePath","workingDirectory","includeDevDependencies","devDependenciesOnly","dependencyScanningOptions","packageManager","getPackageManager","pnpmDependencyScanning","npmDependencyScanning","path","process","cwd","isAbsolute","join"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAeaA;;;eAAAA;;;sBAfoB;qBACK;sBAEC;mCACL;;;;;;;;;;;;;;;AAW3B,MAAMA,gBAAgB,OAAOC;IAClC,MAAMC,kBAAkBC,YAAYF,QAAQG,gBAAgB;QAC7BH;IAA/B,MAAMI,yBAAyBJ,CAAAA,kCAAAA,QAAQI,sBAAsB,YAA9BJ,kCAAkC;QACrCA;IAA5B,MAAMK,sBAAsBL,CAAAA,+BAAAA,QAAQK,mBAAmB,YAA3BL,+BAA+B;IAE3D,MAAMM,4BAAuD,aACxDN;QACHG,kBAAkBF;QAClBG;QACAC;;IAGF,MAAME,iBAAiB,MAAMC,IAAAA,oCAAiB,EAACP;IAE/C,OAAQM;QACN,KAAK;YACH,OAAOE,IAAAA,4BAAsB,EAACH;QAChC;YACE,OAAOI,IAAAA,0BAAqB,EAACJ;IACjC;AACF;AAEA,MAAMJ,cAAc,CAACS;IACnB,IAAI,CAACA,MAAM;QACT,OAAOC,QAAQC,GAAG;IACpB;IAEA,OAAOC,IAAAA,gBAAU,EAACH,QAAQA,OAAOI,IAAAA,UAAI,EAACH,QAAQC,GAAG,IAAIF;AACvD"}

package/src/lib/logger.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/logger.ts"],"sourcesContent":["let loggerEnabled = false;\nlet verboseEnabled = false;\n\nconst enableLogging = () => {\n  loggerEnabled = true;\n};\n\nconst enableVerboseLogging = () => {\n  verboseEnabled = true;\n\n  verbose(\"Verbose logging enabled\");\n};\n\nconst log = (message: string) => {\n  if (loggerEnabled) {\n    console.log(message);\n  }\n};\n\nconst verbose = (message: string) => {\n  if (loggerEnabled && verboseEnabled) {\n    log(message);\n  }\n};\n\nconst error = (message: string) => {\n  if (loggerEnabled) {\n    console.error(message);\n  }\n};\n\nconst logger = {\n  enableLogging,\n  enableVerboseLogging,\n  log,\n  verbose,\n  error\n};\n\nexport default logger;\n"],"names":["loggerEnabled","verboseEnabled","enableLogging","enableVerboseLogging","verbose","log","message","console","error","logger"],"mappings":";+BAuCA;;;eAAA;;;AAvCA,IAAIA,gBAAgB;AACpB,IAAIC,iBAAiB;AAErB,MAAMC,gBAAgB;IACpBF,gBAAgB;AAClB;AAEA,MAAMG,uBAAuB;IAC3BF,iBAAiB;IAEjBG,QAAQ;AACV;AAEA,MAAMC,MAAM,CAACC;IACX,IAAIN,eAAe;QACjBO,QAAQF,GAAG,CAACC;IACd;AACF;AAEA,MAAMF,UAAU,CAACE;IACf,IAAIN,iBAAiBC,gBAAgB;QACnCI,IAAIC;IACN;AACF;AAEA,MAAME,QAAQ,CAACF;IACb,IAAIN,eAAe;QACjBO,QAAQC,KAAK,CAACF;IAChB;AACF;AAEA,MAAMG,SAAS;IACbP;IACAC;IACAE;IACAD;IACAI;AACF;MAEA,WAAeC"}
+{"version":3,"sources":["../../../../../packages/license-cop/src/lib/logger.ts"],"sourcesContent":["let loggerEnabled = false;\nlet verboseEnabled = false;\n\nconst enableLogging = () => {\n  loggerEnabled = true;\n};\n\nconst enableVerboseLogging = () => {\n  verboseEnabled = true;\n\n  verbose(\"Verbose logging enabled\");\n};\n\nconst log = (message: string) => {\n  if (loggerEnabled) {\n    console.log(message);\n  }\n};\n\nconst verbose = (message: string) => {\n  if (loggerEnabled && verboseEnabled) {\n    log(message);\n  }\n};\n\nconst error = (message: string) => {\n  if (loggerEnabled) {\n    console.error(message);\n  }\n};\n\nconst logger = {\n  enableLogging,\n  enableVerboseLogging,\n  log,\n  verbose,\n  error\n};\n\nexport default logger;\n"],"names":["loggerEnabled","verboseEnabled","enableLogging","enableVerboseLogging","verbose","log","message","console","error","logger"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAuCA;;;eAAA;;;AAvCA,IAAIA,gBAAgB;AACpB,IAAIC,iBAAiB;AAErB,MAAMC,gBAAgB;IACpBF,gBAAgB;AAClB;AAEA,MAAMG,uBAAuB;IAC3BF,iBAAiB;IAEjBG,QAAQ;AACV;AAEA,MAAMC,MAAM,CAACC;IACX,IAAIN,eAAe;QACjBO,QAAQF,GAAG,CAACC;IACd;AACF;AAEA,MAAMF,UAAU,CAACE;IACf,IAAIN,iBAAiBC,gBAAgB;QACnCI,IAAIC;IACN;AACF;AAEA,MAAME,QAAQ,CAACF;IACb,IAAIN,eAAe;QACjBO,QAAQC,KAAK,CAACF;IAChB;AACF;AAEA,MAAMG,SAAS;IACbP;IACAC;IACAE;IACAD;IACAI;AACF;MAEA,WAAeC"}

package/src/lib/result.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/result.ts"],"names":[],"mappings":""}
+{"version":3,"sources":["../../../../../packages/license-cop/src/lib/result.ts"],"names":[],"rangeMappings":"","mappings":""}

package/src/lib/spdx/calculate-issues.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/calculate-issues.ts"],"sourcesContent":["import { SpdxExpression } from \"./types/spdx-expression\";\n\nexport const calculateIssues = (license: SpdxExpression, allowedLicenses: string[]): string[] => {\n  const issues: string[] = [];\n\n  const parseNode = (node: SpdxExpression): void => {\n    switch (node.type) {\n      case \"identifier\": {\n        if (!allowedLicenses.includes(node.value)) {\n          issues.push(node.value);\n        }\n        return;\n      }\n\n      case \"AND\":\n      case \"OR\": {\n        parseNode(node.expressions[0]);\n        parseNode(node.expressions[1]);\n        return;\n      }\n\n      case \"WITH\": {\n        if (\n          // TODO: Verify that all exceptions make licenses 'weaker'\n          !allowedLicenses.includes(node.expressions[0]) ||\n          !allowedLicenses.includes(`${node.expressions[0]} WITH ${node.expressions[1]}`)\n        ) {\n          issues.push(`${node.expressions[0]} WITH ${node.expressions[1]}`);\n        }\n        return;\n      }\n\n      default: {\n        const _exhaustiveCheck: never = node;\n        throw new Error(`Unhandled license expression type: ${_exhaustiveCheck}`);\n      }\n    }\n  };\n\n  parseNode(license);\n\n  return issues;\n};\n"],"names":["calculateIssues","license","allowedLicenses","issues","parseNode","node","type","includes","value","push","expressions","_exhaustiveCheck","Error"],"mappings":";+BAEaA;;;eAAAA;;;AAAN,MAAMA,kBAAkB,CAACC,SAAyBC;IACvD,MAAMC,SAAmB,EAAE;IAE3B,MAAMC,YAAY,CAACC;QACjB,OAAQA,KAAKC,IAAI;YACf,KAAK;gBAAc;oBACjB,IAAI,CAACJ,gBAAgBK,QAAQ,CAACF,KAAKG,KAAK,GAAG;wBACzCL,OAAOM,IAAI,CAACJ,KAAKG,KAAK;oBACxB;oBACA;gBACF;YAEA,KAAK;YACL,KAAK;gBAAM;oBACTJ,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7BN,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7B;gBACF;YAEA,KAAK;gBAAQ;oBACX,IACE,0DAA0D;oBAC1D,CAACR,gBAAgBK,QAAQ,CAACF,KAAKK,WAAW,CAAC,EAAE,KAC7C,CAACR,gBAAgBK,QAAQ,CAAC,CAAC,EAAEF,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC,GAC9E;wBACAP,OAAOM,IAAI,CAAC,CAAC,EAAEJ,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC;oBAClE;oBACA;gBACF;YAEA;gBAAS;oBACP,MAAMC,mBAA0BN;oBAChC,MAAM,IAAIO,MAAM,CAAC,mCAAmC,EAAED,iBAAiB,CAAC;gBAC1E;QACF;IACF;IAEAP,UAAUH;IAEV,OAAOE;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/calculate-issues.ts"],"sourcesContent":["import { SpdxExpression } from \"./types/spdx-expression\";\n\nexport const calculateIssues = (license: SpdxExpression, allowedLicenses: string[]): string[] => {\n  const issues: string[] = [];\n\n  const parseNode = (node: SpdxExpression): void => {\n    switch (node.type) {\n      case \"identifier\": {\n        if (!allowedLicenses.includes(node.value)) {\n          issues.push(node.value);\n        }\n        return;\n      }\n\n      case \"AND\":\n      case \"OR\": {\n        parseNode(node.expressions[0]);\n        parseNode(node.expressions[1]);\n        return;\n      }\n\n      case \"WITH\": {\n        if (\n          // TODO: Verify that all exceptions make licenses 'weaker'\n          !allowedLicenses.includes(node.expressions[0]) ||\n          !allowedLicenses.includes(`${node.expressions[0]} WITH ${node.expressions[1]}`)\n        ) {\n          issues.push(`${node.expressions[0]} WITH ${node.expressions[1]}`);\n        }\n        return;\n      }\n\n      default: {\n        const _exhaustiveCheck: never = node;\n        throw new Error(`Unhandled license expression type: ${_exhaustiveCheck}`);\n      }\n    }\n  };\n\n  parseNode(license);\n\n  return issues;\n};\n"],"names":["calculateIssues","license","allowedLicenses","issues","parseNode","node","type","includes","value","push","expressions","_exhaustiveCheck","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAEaA;;;eAAAA;;;AAAN,MAAMA,kBAAkB,CAACC,SAAyBC;IACvD,MAAMC,SAAmB,EAAE;IAE3B,MAAMC,YAAY,CAACC;QACjB,OAAQA,KAAKC,IAAI;YACf,KAAK;gBAAc;oBACjB,IAAI,CAACJ,gBAAgBK,QAAQ,CAACF,KAAKG,KAAK,GAAG;wBACzCL,OAAOM,IAAI,CAACJ,KAAKG,KAAK;oBACxB;oBACA;gBACF;YAEA,KAAK;YACL,KAAK;gBAAM;oBACTJ,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7BN,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7B;gBACF;YAEA,KAAK;gBAAQ;oBACX,IACE,0DAA0D;oBAC1D,CAACR,gBAAgBK,QAAQ,CAACF,KAAKK,WAAW,CAAC,EAAE,KAC7C,CAACR,gBAAgBK,QAAQ,CAAC,CAAC,EAAEF,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC,GAC9E;wBACAP,OAAOM,IAAI,CAAC,CAAC,EAAEJ,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC;oBAClE;oBACA;gBACF;YAEA;gBAAS;oBACP,MAAMC,mBAA0BN;oBAChC,MAAM,IAAIO,MAAM,CAAC,mCAAmC,EAAED,iBAAiB,CAAC;gBAC1E;QACF;IACF;IAEAP,UAAUH;IAEV,OAAOE;AACT"}

package/src/lib/spdx/get-tokens.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/get-tokens.ts"],"sourcesContent":["import { isOperator, isParenthesis, Token } from \"./types/token\";\n\nexport const getTokens = (input: string): Token[] => {\n  const tokens: Token[] = [];\n  let currentToken = \"\";\n\n  // Pushes the current token to the tokens array and resets the current token\n  const pushToken = () => {\n    if (currentToken.length === 0) {\n      return;\n    }\n\n    if (currentToken === \"WITH\") {\n      tokens.push({\n        type: \"with\"\n      });\n    } else if (isOperator(currentToken)) {\n      tokens.push({\n        type: \"operator\",\n        value: currentToken\n      });\n    } else {\n      tokens.push({\n        type: \"identifier\",\n        value: currentToken\n      });\n    }\n\n    currentToken = \"\";\n  };\n\n  for (let i = 0; i < input.length; i++) {\n    const currentChar = input[i];\n\n    if (isParenthesis(currentChar)) {\n      pushToken();\n\n      tokens.push({\n        type: \"parenthesis\",\n        value: currentChar\n      });\n\n      continue;\n    }\n\n    if (currentChar === \" \") {\n      pushToken();\n      continue;\n    }\n\n    currentToken += currentChar;\n  }\n\n  pushToken();\n  return tokens;\n};\n"],"names":["getTokens","input","tokens","currentToken","pushToken","length","push","type","isOperator","value","i","currentChar","isParenthesis"],"mappings":";+BAEaA;;;eAAAA;;;uBAFoC;AAE1C,MAAMA,YAAY,CAACC;IACxB,MAAMC,SAAkB,EAAE;IAC1B,IAAIC,eAAe;IAEnB,4EAA4E;IAC5E,MAAMC,YAAY;QAChB,IAAID,aAAaE,MAAM,KAAK,GAAG;YAC7B;QACF;QAEA,IAAIF,iBAAiB,QAAQ;YAC3BD,OAAOI,IAAI,CAAC;gBACVC,MAAM;YACR;QACF,OAAO,IAAIC,IAAAA,iBAAU,EAACL,eAAe;YACnCD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF,OAAO;YACLD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF;QAEAA,eAAe;IACjB;IAEA,IAAK,IAAIO,IAAI,GAAGA,IAAIT,MAAMI,MAAM,EAAEK,IAAK;QACrC,MAAMC,cAAcV,KAAK,CAACS,EAAE;QAE5B,IAAIE,IAAAA,oBAAa,EAACD,cAAc;YAC9BP;YAEAF,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAOE;YACT;YAEA;QACF;QAEA,IAAIA,gBAAgB,KAAK;YACvBP;YACA;QACF;QAEAD,gBAAgBQ;IAClB;IAEAP;IACA,OAAOF;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/get-tokens.ts"],"sourcesContent":["import { isOperator, isParenthesis, Token } from \"./types/token\";\n\nexport const getTokens = (input: string): Token[] => {\n  const tokens: Token[] = [];\n  let currentToken = \"\";\n\n  // Pushes the current token to the tokens array and resets the current token\n  const pushToken = () => {\n    if (currentToken.length === 0) {\n      return;\n    }\n\n    if (currentToken === \"WITH\") {\n      tokens.push({\n        type: \"with\"\n      });\n    } else if (isOperator(currentToken)) {\n      tokens.push({\n        type: \"operator\",\n        value: currentToken\n      });\n    } else {\n      tokens.push({\n        type: \"identifier\",\n        value: currentToken\n      });\n    }\n\n    currentToken = \"\";\n  };\n\n  for (let i = 0; i < input.length; i++) {\n    const currentChar = input[i];\n\n    if (isParenthesis(currentChar)) {\n      pushToken();\n\n      tokens.push({\n        type: \"parenthesis\",\n        value: currentChar\n      });\n\n      continue;\n    }\n\n    if (currentChar === \" \") {\n      pushToken();\n      continue;\n    }\n\n    currentToken += currentChar;\n  }\n\n  pushToken();\n  return tokens;\n};\n"],"names":["getTokens","input","tokens","currentToken","pushToken","length","push","type","isOperator","value","i","currentChar","isParenthesis"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAEaA;;;eAAAA;;;uBAFoC;AAE1C,MAAMA,YAAY,CAACC;IACxB,MAAMC,SAAkB,EAAE;IAC1B,IAAIC,eAAe;IAEnB,4EAA4E;IAC5E,MAAMC,YAAY;QAChB,IAAID,aAAaE,MAAM,KAAK,GAAG;YAC7B;QACF;QAEA,IAAIF,iBAAiB,QAAQ;YAC3BD,OAAOI,IAAI,CAAC;gBACVC,MAAM;YACR;QACF,OAAO,IAAIC,IAAAA,iBAAU,EAACL,eAAe;YACnCD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF,OAAO;YACLD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF;QAEAA,eAAe;IACjB;IAEA,IAAK,IAAIO,IAAI,GAAGA,IAAIT,MAAMI,MAAM,EAAEK,IAAK;QACrC,MAAMC,cAAcV,KAAK,CAACS,EAAE;QAE5B,IAAIE,IAAAA,oBAAa,EAACD,cAAc;YAC9BP;YAEAF,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAOE;YACT;YAEA;QACF;QAEA,IAAIA,gBAAgB,KAAK;YACvBP;YACA;QACF;QAEAD,gBAAgBQ;IAClB;IAEAP;IACA,OAAOF;AACT"}

package/src/lib/spdx/parse-license-expression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-license-expression.ts"],"sourcesContent":["import { getTokens } from \"./get-tokens\";\nimport { parseTokens } from \"./parse-tokens\";\nimport { SpdxExpression, Unlicensed } from \"./types/spdx-expression\";\n\nexport const parseLicenseExpression = (input: string): SpdxExpression | Unlicensed => {\n  if (input === \"UNLICENSED\") {\n    return {\n      type: \"unlicensed\"\n    };\n  }\n\n  const tokens = getTokens(input);\n  return parseTokens(tokens, input);\n};\n"],"names":["parseLicenseExpression","input","type","tokens","getTokens","parseTokens"],"mappings":";+BAIaA;;;eAAAA;;;2BAJa;6BACE;AAGrB,MAAMA,yBAAyB,CAACC;IACrC,IAAIA,UAAU,cAAc;QAC1B,OAAO;YACLC,MAAM;QACR;IACF;IAEA,MAAMC,SAASC,IAAAA,oBAAS,EAACH;IACzB,OAAOI,IAAAA,wBAAW,EAACF,QAAQF;AAC7B"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-license-expression.ts"],"sourcesContent":["import { getTokens } from \"./get-tokens\";\nimport { parseTokens } from \"./parse-tokens\";\nimport { SpdxExpression, Unlicensed } from \"./types/spdx-expression\";\n\nexport const parseLicenseExpression = (input: string): SpdxExpression | Unlicensed => {\n  if (input === \"UNLICENSED\") {\n    return {\n      type: \"unlicensed\"\n    };\n  }\n\n  const tokens = getTokens(input);\n  return parseTokens(tokens, input);\n};\n"],"names":["parseLicenseExpression","input","type","tokens","getTokens","parseTokens"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";+BAIaA;;;eAAAA;;;2BAJa;6BACE;AAGrB,MAAMA,yBAAyB,CAACC;IACrC,IAAIA,UAAU,cAAc;QAC1B,OAAO;YACLC,MAAM;QACR;IACF;IAEA,MAAMC,SAASC,IAAAA,oBAAS,EAACH;IACzB,OAAOI,IAAAA,wBAAW,EAACF,QAAQF;AAC7B"}

package/src/lib/spdx/parse-tokens.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-tokens.ts"],"sourcesContent":["import { Identifier, SpdxExpression } from \"./types/spdx-expression\";\nimport { Operator, Parenthesis, Token } from \"./types/token\";\n\nexport const parseTokens = (tokens: Token[], originalInput: string): SpdxExpression => {\n  let index = 0;\n\n  const throwNotValid = () => {\n    console.trace();\n    throw new Error(`'${originalInput}' is not a valid SPDX expression`);\n  };\n\n  const hasMore = (): boolean => index < tokens.length;\n\n  const getCurrentToken = (): Token | null => (hasMore() ? tokens[index] : null);\n\n  const moveToNextToken = () => {\n    // istanbul ignore next\n    if (!hasMore()) {\n      throwNotValid();\n    }\n\n    index++;\n  };\n\n  const tryParseParenthesis = (operator: Parenthesis): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"parenthesis\" && operator === currentToken.value) {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseWithToken = (): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"with\") {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseOperator = (operator: Operator): Operator | undefined => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"operator\" && operator === currentToken.value) {\n      moveToNextToken();\n      return currentToken.value;\n    }\n\n    return undefined;\n  };\n\n  const tryParseLicense = (): Identifier | undefined => {\n    const currentToken = getCurrentToken();\n    if (currentToken && currentToken.type === \"identifier\") {\n      moveToNextToken();\n\n      return {\n        type: \"identifier\",\n        value: currentToken.value\n      };\n    }\n\n    return undefined;\n  };\n\n  const tryParseParenthesizedExpression = () => {\n    const startsWithParenthesis = tryParseParenthesis(\"(\");\n    if (!startsWithParenthesis) {\n      return undefined;\n    }\n\n    const innerExpression = tryParseExpression();\n\n    const endsWithParenthesis = tryParseParenthesis(\")\");\n    if (!endsWithParenthesis) {\n      throwNotValid();\n    }\n\n    return innerExpression;\n  };\n\n  const binaryOperationFactory = (\n    operator: Exclude<Operator, \"WITH\">,\n    tryNextParser: () => SpdxExpression | undefined\n  ) => {\n    const tryParseBinaryOperation = (): SpdxExpression | undefined => {\n      const left = tryNextParser();\n\n      if (!left) {\n        return undefined;\n      }\n\n      if (!tryParseOperator(operator)) {\n        return left;\n      }\n\n      const right = tryParseBinaryOperation();\n      if (!right) {\n        return throwNotValid();\n      }\n\n      return {\n        type: operator,\n        expressions: [left, right]\n      };\n    };\n\n    return tryParseBinaryOperation;\n  };\n\n  const tryParseWith = (): SpdxExpression | undefined => {\n    const left = tryParseLicense();\n\n    if (!left) {\n      return undefined;\n    }\n\n    if (!tryParseWithToken()) {\n      return left;\n    }\n\n    const right = tryParseLicense();\n    if (!right) {\n      return throwNotValid();\n    }\n\n    return {\n      type: \"WITH\",\n      expressions: [left.value, right.value]\n    };\n  };\n\n  const parseAnd = binaryOperationFactory(\n    \"AND\",\n    () => tryParseParenthesizedExpression() || tryParseWith()\n  );\n  const tryParseExpression = binaryOperationFactory(\"OR\", parseAnd);\n\n  const node = tryParseExpression();\n  if (!node || hasMore()) {\n    return throwNotValid();\n  }\n\n  return node;\n};\n"],"names":["parseTokens","tokens","originalInput","index","throwNotValid","console","trace","Error","hasMore","length","getCurrentToken","moveToNextToken","tryParseParenthesis","operator","currentToken","type","value","tryParseWithToken","tryParseOperator","undefined","tryParseLicense","tryParseParenthesizedExpression","startsWithParenthesis","innerExpression","tryParseExpression","endsWithParenthesis","binaryOperationFactory","tryNextParser","tryParseBinaryOperation","left","right","expressions","tryParseWith","parseAnd","node"],"mappings":";+BAGaA;;;eAAAA;;;AAAN,MAAMA,cAAc,CAACC,QAAiBC;IAC3C,IAAIC,QAAQ;IAEZ,MAAMC,gBAAgB;QACpBC,QAAQC,KAAK;QACb,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEL,cAAc,gCAAgC,CAAC;IACrE;IAEA,MAAMM,UAAU,IAAeL,QAAQF,OAAOQ,MAAM;IAEpD,MAAMC,kBAAkB,IAAqBF,YAAYP,MAAM,CAACE,MAAM,GAAG;IAEzE,MAAMQ,kBAAkB;QACtB,uBAAuB;QACvB,IAAI,CAACH,WAAW;YACdJ;QACF;QAEAD;IACF;IAEA,MAAMS,sBAAsB,CAACC;QAC3B,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,iBAAiBF,aAAaC,aAAaE,KAAK,EAAE;YAC1FL;YACA,OAAO;QACT;QAEA,OAAO;IACT;IAEA,MAAMM,oBAAoB;QACxB,MAAMH,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,QAAQ;YAChDJ;YACA,OAAO;QACT;QAEA,OAAO;IACT;IAEA,MAAMO,mBAAmB,CAACL;QACxB,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAcF,aAAaC,aAAaE,KAAK,EAAE;YACvFL;YACA,OAAOG,aAAaE,KAAK;QAC3B;QAEA,OAAOG;IACT;IAEA,MAAMC,kBAAkB;QACtB,MAAMN,eAAeJ;QACrB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAc;YACtDJ;YAEA,OAAO;gBACLI,MAAM;gBACNC,OAAOF,aAAaE,KAAK;YAC3B;QACF;QAEA,OAAOG;IACT;IAEA,MAAME,kCAAkC;QACtC,MAAMC,wBAAwBV,oBAAoB;QAClD,IAAI,CAACU,uBAAuB;YAC1B,OAAOH;QACT;QAEA,MAAMI,kBAAkBC;QAExB,MAAMC,sBAAsBb,oBAAoB;QAChD,IAAI,CAACa,qBAAqB;YACxBrB;QACF;QAEA,OAAOmB;IACT;IAEA,MAAMG,yBAAyB,CAC7Bb,UACAc;QAEA,MAAMC,0BAA0B;YAC9B,MAAMC,OAAOF;YAEb,IAAI,CAACE,MAAM;gBACT,OAAOV;YACT;YAEA,IAAI,CAACD,iBAAiBL,WAAW;gBAC/B,OAAOgB;YACT;YAEA,MAAMC,QAAQF;YACd,IAAI,CAACE,OAAO;gBACV,OAAO1B;YACT;YAEA,OAAO;gBACLW,MAAMF;gBACNkB,aAAa;oBAACF;oBAAMC;iBAAM;YAC5B;QACF;QAEA,OAAOF;IACT;IAEA,MAAMI,eAAe;QACnB,MAAMH,OAAOT;QAEb,IAAI,CAACS,MAAM;YACT,OAAOV;QACT;QAEA,IAAI,CAACF,qBAAqB;YACxB,OAAOY;QACT;QAEA,MAAMC,QAAQV;QACd,IAAI,CAACU,OAAO;YACV,OAAO1B;QACT;QAEA,OAAO;YACLW,MAAM;YACNgB,aAAa;gBAACF,KAAKb,KAAK;gBAAEc,MAAMd,KAAK;aAAC;QACxC;IACF;IAEA,MAAMiB,WAAWP,uBACf,OACA,IAAML,qCAAqCW;IAE7C,MAAMR,qBAAqBE,uBAAuB,MAAMO;IAExD,MAAMC,OAAOV;IACb,IAAI,CAACU,QAAQ1B,WAAW;QACtB,OAAOJ;IACT;IAEA,OAAO8B;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-tokens.ts"],"sourcesContent":["import { Identifier, SpdxExpression } from \"./types/spdx-expression\";\nimport { Operator, Parenthesis, Token } from \"./types/token\";\n\nexport const parseTokens = (tokens: Token[], originalInput: string): SpdxExpression => {\n  let index = 0;\n\n  const throwNotValid = () => {\n    console.trace();\n    throw new Error(`'${originalInput}' is not a valid SPDX expression`);\n  };\n\n  const hasMore = (): boolean => index < tokens.length;\n\n  const getCurrentToken = (): Token | null => (hasMore() ? tokens[index] : null);\n\n  const moveToNextToken = () => {\n    // istanbul ignore next\n    if (!hasMore()) {\n      throwNotValid();\n    }\n\n    index++;\n  };\n\n  const tryParseParenthesis = (operator: Parenthesis): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"parenthesis\" && operator === currentToken.value) {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseWithToken = (): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"with\") {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseOperator = (operator: Operator): Operator | undefined => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"operator\" && operator === currentToken.value) {\n      moveToNextToken();\n      return currentToken.value;\n    }\n\n    return undefined;\n  };\n\n  const tryParseLicense = (): Identifier | undefined => {\n    const currentToken = getCurrentToken();\n    if (currentToken && currentToken.type === \"identifier\") {\n      moveToNextToken();\n\n      return {\n        type: \"identifier\",\n        value: currentToken.value\n      };\n    }\n\n    return undefined;\n  };\n\n  const tryParseParenthesizedExpression = () => {\n    const startsWithParenthesis = tryParseParenthesis(\"(\");\n    if (!startsWithParenthesis) {\n      return undefined;\n    }\n\n    const innerExpression = tryParseExpression();\n\n    const endsWithParenthesis = tryParseParenthesis(\")\");\n    if (!endsWithParenthesis) {\n      throwNotValid();\n    }\n\n    return innerExpression;\n  };\n\n  const binaryOperationFactory = (\n    operator: Exclude<Operator, \"WITH\">,\n    tryNextParser: () => SpdxExpression | undefined\n  ) => {\n    const tryParseBinaryOperation = (): SpdxExpression | undefined => {\n      const left = tryNextParser();\n\n      if (!left) {\n        return undefined;\n      }\n\n      if (!tryParseOperator(operator)) {\n        return left;\n      }\n\n      const right = tryParseBinaryOperation();\n      if (!right) {\n        return throwNotValid();\n      }\n\n      return {\n        type: operator,\n        expressions: [left, right]\n      };\n    };\n\n    return tryParseBinaryOperation;\n  };\n\n  const tryParseWith = (): SpdxExpression | undefined => {\n    const left = tryParseLicense();\n\n    if (!left) {\n      return undefined;\n    }\n\n    if (!tryParseWithToken()) {\n      return left;\n    }\n\n    const right = tryParseLicense();\n    if (!right) {\n      return throwNotValid();\n    }\n\n    return {\n      type: \"WITH\",\n      expressions: [left.value, right.value]\n    };\n  };\n\n  const parseAnd = binaryOperationFactory(\n    \"AND\",\n    () => tryParseParenthesizedExpression() || tryParseWith()\n  );\n  const tryParseExpression = binaryOperationFactory(\"OR\", parseAnd);\n\n  const node = tryParseExpression();\n  if (!node || hasMore()) {\n    return throwNotValid();\n  }\n\n  return node;\n};\n"],"names":["parseTokens","tokens","originalInput","index","throwNotValid","console","trace","Error","hasMore","length","getCurrentToken","moveToNextToken","tryParseParenthesis","operator","currentToken","type","value","tryParseWithToken","tryParseOperator","undefined","tryParseLicense","tryParseParenthesizedExpression","startsWithParenthesis","innerExpression","tryParseExpression","endsWithParenthesis","binaryOperationFactory","tryNextParser","tryParseBinaryOperation","left","right","expressions","tryParseWith","parseAnd","node"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAGaA;;;eAAAA;;;AAAN,MAAMA,cAAc,CAACC,QAAiBC;IAC3C,IAAIC,QAAQ;IAEZ,MAAMC,gBAAgB;QACpBC,QAAQC,KAAK;QACb,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEL,cAAc,gCAAgC,CAAC;IACrE;IAEA,MAAMM,UAAU,IAAeL,QAAQF,OAAOQ,MAAM;IAEpD,MAAMC,kBAAkB,IAAqBF,YAAYP,MAAM,CAACE,MAAM,GAAG;IAEzE,MAAMQ,kBAAkB;QACtB,uBAAuB;QACvB,IAAI,CAACH,WAAW;YACdJ;QACF;QAEAD;IACF;IAEA,MAAMS,sBAAsB,CAACC;QAC3B,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,iBAAiBF,aAAaC,aAAaE,KAAK,EAAE;YAC1FL;YACA,OAAO;QACT;QAEA,OAAO;IACT;IAEA,MAAMM,oBAAoB;QACxB,MAAMH,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,QAAQ;YAChDJ;YACA,OAAO;QACT;QAEA,OAAO;IACT;IAEA,MAAMO,mBAAmB,CAACL;QACxB,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAcF,aAAaC,aAAaE,KAAK,EAAE;YACvFL;YACA,OAAOG,aAAaE,KAAK;QAC3B;QAEA,OAAOG;IACT;IAEA,MAAMC,kBAAkB;QACtB,MAAMN,eAAeJ;QACrB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAc;YACtDJ;YAEA,OAAO;gBACLI,MAAM;gBACNC,OAAOF,aAAaE,KAAK;YAC3B;QACF;QAEA,OAAOG;IACT;IAEA,MAAME,kCAAkC;QACtC,MAAMC,wBAAwBV,oBAAoB;QAClD,IAAI,CAACU,uBAAuB;YAC1B,OAAOH;QACT;QAEA,MAAMI,kBAAkBC;QAExB,MAAMC,sBAAsBb,oBAAoB;QAChD,IAAI,CAACa,qBAAqB;YACxBrB;QACF;QAEA,OAAOmB;IACT;IAEA,MAAMG,yBAAyB,CAC7Bb,UACAc;QAEA,MAAMC,0BAA0B;YAC9B,MAAMC,OAAOF;YAEb,IAAI,CAACE,MAAM;gBACT,OAAOV;YACT;YAEA,IAAI,CAACD,iBAAiBL,WAAW;gBAC/B,OAAOgB;YACT;YAEA,MAAMC,QAAQF;YACd,IAAI,CAACE,OAAO;gBACV,OAAO1B;YACT;YAEA,OAAO;gBACLW,MAAMF;gBACNkB,aAAa;oBAACF;oBAAMC;iBAAM;YAC5B;QACF;QAEA,OAAOF;IACT;IAEA,MAAMI,eAAe;QACnB,MAAMH,OAAOT;QAEb,IAAI,CAACS,MAAM;YACT,OAAOV;QACT;QAEA,IAAI,CAACF,qBAAqB;YACxB,OAAOY;QACT;QAEA,MAAMC,QAAQV;QACd,IAAI,CAACU,OAAO;YACV,OAAO1B;QACT;QAEA,OAAO;YACLW,MAAM;YACNgB,aAAa;gBAACF,KAAKb,KAAK;gBAAEc,MAAMd,KAAK;aAAC;QACxC;IACF;IAEA,MAAMiB,WAAWP,uBACf,OACA,IAAML,qCAAqCW;IAE7C,MAAMR,qBAAqBE,uBAAuB,MAAMO;IAExD,MAAMC,OAAOV;IACb,IAAI,CAACU,QAAQ1B,WAAW;QACtB,OAAOJ;IACT;IAEA,OAAO8B;AACT"}

package/src/lib/spdx/types/spdx-expression.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/spdx-expression.ts"],"names":[],"mappings":""}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/spdx-expression.ts"],"names":[],"rangeMappings":"","mappings":""}

package/src/lib/spdx/types/token.d.ts

@@ -1,5 +1,5 @@
 declare const operators: readonly ["AND", "OR"];
-export declare const isOperator: (value: string) => value is "AND" | "OR";
+export declare const isOperator: (value: string) => value is Operator;
 export type Operator = (typeof operators)[number];
 export type OperatorToken = {
     type: "operator";
@@ -13,7 +13,7 @@ export type IdentifierToken = {
     value: string;
 };
 declare const parenthesis: readonly ["(", ")"];
-export declare const isParenthesis: (value: string) => value is "(" | ")";
+export declare const isParenthesis: (value: string) => value is Parenthesis;
 export type Parenthesis = (typeof parenthesis)[number];
 export type ParenthesisToken = {
     type: "parenthesis";

package/src/lib/spdx/types/token.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/token.ts"],"sourcesContent":["// Operators\n\nconst operators = [\"AND\", \"OR\"] as const;\nexport const isOperator = (value: string): value is Operator =>\n  operators.includes(value as Operator);\n\nexport type Operator = (typeof operators)[number];\nexport type OperatorToken = {\n  type: \"operator\";\n  value: Operator;\n};\n\n// With\n\nexport type WithToken = {\n  type: \"with\";\n};\n\n// Identifiers\n\nexport type IdentifierToken = {\n  type: \"identifier\";\n  value: string;\n};\n\n// Parenthesis\n\nconst parenthesis = [\"(\", \")\"] as const;\nexport const isParenthesis = (value: string): value is Parenthesis =>\n  parenthesis.includes(value as Parenthesis);\n\nexport type Parenthesis = (typeof parenthesis)[number];\nexport type ParenthesisToken = {\n  type: \"parenthesis\";\n  value: Parenthesis;\n};\n\nexport type Token = OperatorToken | WithToken | IdentifierToken | ParenthesisToken;\n"],"names":["isOperator","isParenthesis","operators","value","includes","parenthesis"],"mappings":"AAAA,YAAY;;;;;;;;;IAGCA,UAAU;eAAVA;;IAyBAC,aAAa;eAAbA;;;AA1Bb,MAAMC,YAAY;IAAC;IAAO;CAAK;AACxB,MAAMF,aAAa,CAACG,QACzBD,UAAUE,QAAQ,CAACD;AAqBrB,cAAc;AAEd,MAAME,cAAc;IAAC;IAAK;CAAI;AACvB,MAAMJ,gBAAgB,CAACE,QAC5BE,YAAYD,QAAQ,CAACD"}
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/token.ts"],"sourcesContent":["// Operators\n\nconst operators = [\"AND\", \"OR\"] as const;\nexport const isOperator = (value: string): value is Operator =>\n  operators.includes(value as Operator);\n\nexport type Operator = (typeof operators)[number];\nexport type OperatorToken = {\n  type: \"operator\";\n  value: Operator;\n};\n\n// With\n\nexport type WithToken = {\n  type: \"with\";\n};\n\n// Identifiers\n\nexport type IdentifierToken = {\n  type: \"identifier\";\n  value: string;\n};\n\n// Parenthesis\n\nconst parenthesis = [\"(\", \")\"] as const;\nexport const isParenthesis = (value: string): value is Parenthesis =>\n  parenthesis.includes(value as Parenthesis);\n\nexport type Parenthesis = (typeof parenthesis)[number];\nexport type ParenthesisToken = {\n  type: \"parenthesis\";\n  value: Parenthesis;\n};\n\nexport type Token = OperatorToken | WithToken | IdentifierToken | ParenthesisToken;\n"],"names":["isOperator","isParenthesis","operators","value","includes","parenthesis"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,YAAY;;;;;;;;;IAGCA,UAAU;eAAVA;;IAyBAC,aAAa;eAAbA;;;AA1Bb,MAAMC,YAAY;IAAC;IAAO;CAAK;AACxB,MAAMF,aAAa,CAACG,QACzBD,UAAUE,QAAQ,CAACD;AAqBrB,cAAc;AAEd,MAAME,cAAc;IAAC;IAAK;CAAI;AACvB,MAAMJ,gBAAgB,CAACE,QAC5BE,YAAYD,QAAQ,CAACD"}

package/src/lib/utils/join-string-array.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/utils/join-string-array.ts"],"sourcesContent":["export const joinStringArray = (array: string[]): string => {\n  let result = \"\";\n\n  for (let i = 0; i < array.length; i++) {\n    result += array[i];\n\n    const isPenultimateElement = i === array.length - 2;\n    const isLastElement = i === array.length - 1;\n\n    if (isPenultimateElement) {\n      if (array.length === 2) {\n        result += \" and \";\n      } else {\n        result += \", and \";\n      }\n    }\n\n    if (!isLastElement && !isPenultimateElement) {\n      result += \", \";\n    }\n  }\n\n  return result;\n};\n"],"names":["joinStringArray","array","result","i","length","isPenultimateElement","isLastElement"],"mappings":";+BAAaA;;;eAAAA;;;AAAN,MAAMA,kBAAkB,CAACC;IAC9B,IAAIC,SAAS;IAEb,IAAK,IAAIC,IAAI,GAAGA,IAAIF,MAAMG,MAAM,EAAED,IAAK;QACrCD,UAAUD,KAAK,CAACE,EAAE;QAElB,MAAME,uBAAuBF,MAAMF,MAAMG,MAAM,GAAG;QAClD,MAAME,gBAAgBH,MAAMF,MAAMG,MAAM,GAAG;QAE3C,IAAIC,sBAAsB;YACxB,IAAIJ,MAAMG,MAAM,KAAK,GAAG;gBACtBF,UAAU;YACZ,OAAO;gBACLA,UAAU;YACZ;QACF;QAEA,IAAI,CAACI,iBAAiB,CAACD,sBAAsB;YAC3CH,UAAU;QACZ;IACF;IAEA,OAAOA;AACT"}
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/utils/join-string-array.ts"],"sourcesContent":["export const joinStringArray = (array: string[]): string => {\n  let result = \"\";\n\n  for (let i = 0; i < array.length; i++) {\n    result += array[i];\n\n    const isPenultimateElement = i === array.length - 2;\n    const isLastElement = i === array.length - 1;\n\n    if (isPenultimateElement) {\n      if (array.length === 2) {\n        result += \" and \";\n      } else {\n        result += \", and \";\n      }\n    }\n\n    if (!isLastElement && !isPenultimateElement) {\n      result += \", \";\n    }\n  }\n\n  return result;\n};\n"],"names":["joinStringArray","array","result","i","length","isPenultimateElement","isLastElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAAaA;;;eAAAA;;;AAAN,MAAMA,kBAAkB,CAACC;IAC9B,IAAIC,SAAS;IAEb,IAAK,IAAIC,IAAI,GAAGA,IAAIF,MAAMG,MAAM,EAAED,IAAK;QACrCD,UAAUD,KAAK,CAACE,EAAE;QAElB,MAAME,uBAAuBF,MAAMF,MAAMG,MAAM,GAAG;QAClD,MAAME,gBAAgBH,MAAMF,MAAMG,MAAM,GAAG;QAE3C,IAAIC,sBAAsB;YACxB,IAAIJ,MAAMG,MAAM,KAAK,GAAG;gBACtBF,UAAU;YACZ,OAAO;gBACLA,UAAU;YACZ;QACF;QAEA,IAAI,CAACI,iBAAiB,CAACD,sBAAsB;YAC3CH,UAAU;QACZ;IACF;IAEA,OAAOA;AACT"}

package/src/lib/package-json.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/package-json.ts"],"sourcesContent":["import { Stats } from \"fs\";\nimport { readFile, stat } from \"fs/promises\";\nimport { z } from \"zod\";\nimport { json5Parse } from \"./config/parsers/json5\";\nimport logger from \"./logger\";\n\nconst licenseSectionValidator = z.object({\n  type: z.string(),\n  url: z.string().optional()\n});\n\nconst packageJsonValidator = z.object({\n  name: z.string(),\n  version: z.string(),\n  license: z.union([z.string(), licenseSectionValidator]).optional(),\n  licenses: licenseSectionValidator.array().optional()\n});\n\ntype PackageJson = z.infer<typeof packageJsonValidator>;\n\nexport const readPackageJson = async (pathToPackageJson: string): Promise<PackageJson> => {\n  const doesPackageJsonExist = await doesFileExist(pathToPackageJson);\n  if (!doesPackageJsonExist) {\n    logger.verbose(`Cannot find the package.json: '${pathToPackageJson}'`);\n    throw new Error(`Cannot find the file: '${pathToPackageJson}'`);\n  }\n\n  const packageJsonAsString: string = await readFile(pathToPackageJson, { encoding: \"utf8\" });\n\n  const parsedFile = json5Parse<unknown>(packageJsonAsString);\n\n  const packageJson = packageJsonValidator.safeParse(parsedFile);\n\n  if (!packageJson.success) {\n    throw new Error(\n      `Unable to parse package.json: ${pathToPackageJson}: ${packageJson.error.message}`\n    );\n  }\n\n  return packageJson.data;\n};\n\nexport const getLicenseExpression = (packageJson: PackageJson): string => {\n  if (packageJson.license && typeof packageJson.license === \"string\") {\n    return packageJson.license;\n  }\n\n  if (packageJson.license && typeof packageJson.license === \"object\") {\n    return packageJson.license.type;\n  }\n\n  if (packageJson.licenses) {\n    const licenses = packageJson.licenses.map<string>(license => license.type);\n\n    if (licenses.length === 1) {\n      return licenses[0];\n    }\n\n    return `(${licenses.join(\" AND \")})`;\n  }\n\n  return \"UNLICENSED\";\n};\n\nconst doesFileExist = async (path: string): Promise<boolean> => {\n  try {\n    const stats: Stats = await stat(path);\n    return stats.isFile();\n  } catch {\n    return false;\n  }\n};\n"],"names":["getLicenseExpression","readPackageJson","licenseSectionValidator","z","object","type","string","url","optional","packageJsonValidator","name","version","license","union","licenses","array","pathToPackageJson","doesPackageJsonExist","doesFileExist","logger","verbose","Error","packageJsonAsString","readFile","encoding","parsedFile","json5Parse","packageJson","safeParse","success","error","message","data","map","length","join","path","stats","stat","isFile"],"mappings":";;;;;;;;IA0CaA,oBAAoB;eAApBA;;IAtBAC,eAAe;eAAfA;;;0BAnBkB;qBACb;uBACS;wBACR;AAEnB,MAAMC,0BAA0BC,MAAC,CAACC,MAAM,CAAC;IACvCC,MAAMF,MAAC,CAACG,MAAM;IACdC,KAAKJ,MAAC,CAACG,MAAM,GAAGE,QAAQ;AAC1B;AAEA,MAAMC,uBAAuBN,MAAC,CAACC,MAAM,CAAC;IACpCM,MAAMP,MAAC,CAACG,MAAM;IACdK,SAASR,MAAC,CAACG,MAAM;IACjBM,SAAST,MAAC,CAACU,KAAK,CAAC;QAACV,MAAC,CAACG,MAAM;QAAIJ;KAAwB,EAAEM,QAAQ;IAChEM,UAAUZ,wBAAwBa,KAAK,GAAGP,QAAQ;AACpD;AAIO,MAAMP,kBAAkB,OAAOe;IACpC,MAAMC,uBAAuB,MAAMC,cAAcF;IACjD,IAAI,CAACC,sBAAsB;QACzBE,eAAM,CAACC,OAAO,CAAC,CAAC,+BAA+B,EAAEJ,kBAAkB,CAAC,CAAC;QACrE,MAAM,IAAIK,MAAM,CAAC,uBAAuB,EAAEL,kBAAkB,CAAC,CAAC;IAChE;IAEA,MAAMM,sBAA8B,MAAMC,IAAAA,kBAAQ,EAACP,mBAAmB;QAAEQ,UAAU;IAAO;IAEzF,MAAMC,aAAaC,IAAAA,iBAAU,EAAUJ;IAEvC,MAAMK,cAAclB,qBAAqBmB,SAAS,CAACH;IAEnD,IAAI,CAACE,YAAYE,OAAO,EAAE;QACxB,MAAM,IAAIR,MACR,CAAC,8BAA8B,EAAEL,kBAAkB,EAAE,EAAEW,YAAYG,KAAK,CAACC,OAAO,CAAC,CAAC;IAEtF;IAEA,OAAOJ,YAAYK,IAAI;AACzB;AAEO,MAAMhC,uBAAuB,CAAC2B;IACnC,IAAIA,YAAYf,OAAO,IAAI,OAAOe,YAAYf,OAAO,KAAK,UAAU;QAClE,OAAOe,YAAYf,OAAO;IAC5B;IAEA,IAAIe,YAAYf,OAAO,IAAI,OAAOe,YAAYf,OAAO,KAAK,UAAU;QAClE,OAAOe,YAAYf,OAAO,CAACP,IAAI;IACjC;IAEA,IAAIsB,YAAYb,QAAQ,EAAE;QACxB,MAAMA,WAAWa,YAAYb,QAAQ,CAACmB,GAAG,CAASrB,CAAAA,UAAWA,QAAQP,IAAI;QAEzE,IAAIS,SAASoB,MAAM,KAAK,GAAG;YACzB,OAAOpB,QAAQ,CAAC,EAAE;QACpB;QAEA,OAAO,CAAC,CAAC,EAAEA,SAASqB,IAAI,CAAC,SAAS,CAAC,CAAC;IACtC;IAEA,OAAO;AACT;AAEA,MAAMjB,gBAAgB,OAAOkB;IAC3B,IAAI;QACF,MAAMC,QAAe,MAAMC,IAAAA,cAAI,EAACF;QAChC,OAAOC,MAAME,MAAM;IACrB,EAAE,UAAM;QACN,OAAO;IACT;AACF"}

package/src/lib/package-rules.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/package-rules.ts"],"sourcesContent":["import { satisfies } from \"compare-versions\";\n\nexport const isAllowedPackage = (\n  packageName: string,\n  packageVersion: string,\n  allowedPackages: string[]\n) => {\n  for (const allowedPackage of allowedPackages) {\n    if (allowedPackage === packageName) {\n      return true;\n    }\n\n    if (allowedPackage.startsWith(packageName + \"@\")) {\n      const allowedPackageVersion = allowedPackage.substring(packageName.length + 1);\n\n      if (satisfies(packageVersion, allowedPackageVersion)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n};\n"],"names":["isAllowedPackage","packageName","packageVersion","allowedPackages","allowedPackage","startsWith","allowedPackageVersion","substring","length","satisfies"],"mappings":";+BAEaA;;;eAAAA;;;iCAFa;AAEnB,MAAMA,mBAAmB,CAC9BC,aACAC,gBACAC;IAEA,KAAK,MAAMC,kBAAkBD,gBAAiB;QAC5C,IAAIC,mBAAmBH,aAAa;YAClC,OAAO;QACT;QAEA,IAAIG,eAAeC,UAAU,CAACJ,cAAc,MAAM;YAChD,MAAMK,wBAAwBF,eAAeG,SAAS,CAACN,YAAYO,MAAM,GAAG;YAE5E,IAAIC,IAAAA,0BAAS,EAACP,gBAAgBI,wBAAwB;gBACpD,OAAO;YACT;QACF;IACF;IAEA,OAAO;AACT"}