license-cop 1.9.0 → 2.0.0

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

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

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

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

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

@@ -1,103 +0,0 @@
-"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 Map();
-    const packagesWithAllowedLicenses = new Map();
-    const packagesWithNoLicenses = new Map();
-    const packagesWithForbiddenLicenses = new Map();
-    const dependencyHierarchies = await (0, _reviewingdependencieshierarchy.buildDependenciesTree)([
-        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 pkgId = `${node.alias}@${node.version}`;
-        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.set(pkgId, {
-                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.set(pkgId, {
-                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.set(pkgId, {
-                name: packageJson.name,
-                version: packageJson.version,
-                licenseIdentifiers: joinedIssues,
-                spdxExpression: rawLicenseExpression
-            });
-        } else {
-            _logger.default.verbose(`Package ${packageJson.name} has the allowed license: ${rawLicenseExpression}`);
-            packagesWithAllowedLicenses.set(pkgId, {
-                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);
-    }
-    return {
-        allowedPackages: new Set(foundAllowedPackages.values()),
-        allowedLicenses: new Set(packagesWithAllowedLicenses.values()),
-        noLicenses: new Set(packagesWithNoLicenses.values()),
-        forbiddenLicenses: new Set(packagesWithForbiddenLicenses.values())
-    };
-};
-
-//# sourceMappingURL=pnpm.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/dependency-scanning/pnpm.ts"],"sourcesContent":["import { buildDependenciesTree, DependencyNode } 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 Map<string, AllowedPackage>();\n  const packagesWithAllowedLicenses = new Map<string, LicensedPackage>();\n  const packagesWithNoLicenses = new Map<string, NoLicenseResult>();\n  const packagesWithForbiddenLicenses = new Map<string, ForbiddenLicenseResult>();\n\n  const dependencyHierarchies = await buildDependenciesTree([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: DependencyNode) => {\n    logger.verbose(`Parsing node: ${node.name}`);\n\n    const pkgId = `${node.alias}@${node.version}`;\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.set(pkgId, {\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.set(pkgId, {\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.set(pkgId, {\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.set(pkgId, {\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: DependencyNode[] | 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  }\n\n  return {\n    allowedPackages: new Set(foundAllowedPackages.values()),\n    allowedLicenses: new Set(packagesWithAllowedLicenses.values()),\n    noLicenses: new Set(packagesWithNoLicenses.values()),\n    forbiddenLicenses: new Set(packagesWithForbiddenLicenses.values())\n  };\n};\n"],"names":["pnpmDependencyScanning","options","workingDirectory","allowedLicenses","allowedPackages","includeDevDependencies","devDependenciesOnly","foundAllowedPackages","Map","packagesWithAllowedLicenses","packagesWithNoLicenses","packagesWithForbiddenLicenses","dependencyHierarchies","buildDependenciesTree","depth","Infinity","include","dependencies","devDependencies","optionalDependencies","lockfileDir","virtualStoreDirMaxLength","parseNode","node","logger","verbose","name","pkgId","alias","version","packageJsonPath","join","path","packageJson","readPackageJson","isAllowedPackage","set","parseNodes","rawLicenseExpression","getLicenseExpression","licenseExpression","parseLicenseExpression","type","licenseIssues","calculateIssues","joinedIssues","joinStringArray","length","licenseIdentifiers","spdxExpression","licenses","nodes","hierarchies","Object","values","Set","noLicenses","forbiddenLicenses"],"mappings":"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"}

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

@@ -1,9 +0,0 @@
-import { CheckLicensesResult } from "./result";
-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

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "checkLicenses", {
-    enumerable: true,
-    get: function() {
-        return checkLicenses;
-    }
-});
-const _path = require("path");
-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 target;
-    };
-    return _extends.apply(this, arguments);
-}
-const checkLicenses = async (options)=>{
-    var _options_includeDevDependencies, _options_devDependenciesOnly;
-    const fullProjectPath = resolvePath(options.workingDirectory);
-    const includeDevDependencies = (_options_includeDevDependencies = options.includeDevDependencies) != null ? _options_includeDevDependencies : false;
-    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) {
-        return process.cwd();
-    }
-    return (0, _path.isAbsolute)(path) ? path : (0, _path.join)(process.cwd(), path);
-};
-
-//# sourceMappingURL=license-cop.js.map

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

@@ -1 +0,0 @@
-{"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"],"mappings":";+BAeaA;;;eAAAA;;;sBAfoB;qBACK;sBAEC;mCACL;;;;;;;;;;;;;;;AAW3B,MAAMA,gBAAgB,OAAOC;QAEHA,iCACHA;IAF5B,MAAMC,kBAAkBC,YAAYF,QAAQG,gBAAgB;IAC5D,MAAMC,0BAAyBJ,kCAAAA,QAAQI,sBAAsB,YAA9BJ,kCAAkC;IACjE,MAAMK,uBAAsBL,+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.d.ts

@@ -1,8 +0,0 @@
-declare const logger: {
-    enableLogging: () => void;
-    enableVerboseLogging: () => void;
-    log: (message: string) => void;
-    verbose: (message: string) => void;
-    error: (message: string) => void;
-};
-export default logger;

package/src/lib/logger.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-let loggerEnabled = false;
-let verboseEnabled = false;
-const enableLogging = ()=>{
-    loggerEnabled = true;
-};
-const enableVerboseLogging = ()=>{
-    verboseEnabled = true;
-    verbose("Verbose logging enabled");
-};
-const log = (message)=>{
-    if (loggerEnabled) {
-        console.log(message);
-    }
-};
-const verbose = (message)=>{
-    if (loggerEnabled && verboseEnabled) {
-        log(message);
-    }
-};
-const error = (message)=>{
-    if (loggerEnabled) {
-        console.error(message);
-    }
-};
-const logger = {
-    enableLogging,
-    enableVerboseLogging,
-    log,
-    verbose,
-    error
-};
-const _default = logger;
-
-//# sourceMappingURL=logger.js.map

package/src/lib/logger.js.map

@@ -1 +0,0 @@
-{"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"}

package/src/lib/result.d.ts

@@ -1,27 +0,0 @@
-import { SpdxExpression } from "./spdx/types/spdx-expression";
-export interface CheckLicensesResult {
-    allowedPackages: Set<AllowedPackage>;
-    allowedLicenses: Set<LicensedPackage>;
-    noLicenses: Set<NoLicenseResult>;
-    forbiddenLicenses: Set<ForbiddenLicenseResult>;
-}
-export interface AllowedPackage {
-    name: string;
-    version: string;
-}
-export interface LicensedPackage {
-    name: string;
-    version: string;
-    spdxExpression: string;
-    licenses: SpdxExpression;
-}
-export interface NoLicenseResult {
-    name: string;
-    version: string;
-}
-export interface ForbiddenLicenseResult {
-    name: string;
-    version: string;
-    spdxExpression: string;
-    licenseIdentifiers: string;
-}

package/src/lib/result.js

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

package/src/lib/result.js.map

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

package/src/lib/spdx/calculate-issues.d.ts

@@ -1,2 +0,0 @@
-import { SpdxExpression } from "./types/spdx-expression";
-export declare const calculateIssues: (license: SpdxExpression, allowedLicenses: string[]) => string[];

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "calculateIssues", {
-    enumerable: true,
-    get: function() {
-        return calculateIssues;
-    }
-});
-const calculateIssues = (license, allowedLicenses)=>{
-    const issues = [];
-    const parseNode = (node)=>{
-        switch(node.type){
-            case "identifier":
-                {
-                    if (!allowedLicenses.includes(node.value)) {
-                        issues.push(node.value);
-                    }
-                    return;
-                }
-            case "AND":
-            case "OR":
-                {
-                    parseNode(node.expressions[0]);
-                    parseNode(node.expressions[1]);
-                    return;
-                }
-            case "WITH":
-                {
-                    if (// TODO: Verify that all exceptions make licenses 'weaker'
-                    !allowedLicenses.includes(node.expressions[0]) || !allowedLicenses.includes(`${node.expressions[0]} WITH ${node.expressions[1]}`)) {
-                        issues.push(`${node.expressions[0]} WITH ${node.expressions[1]}`);
-                    }
-                    return;
-                }
-            default:
-                {
-                    const _exhaustiveCheck = node;
-                    throw new Error(`Unhandled license expression type: ${_exhaustiveCheck}`);
-                }
-        }
-    };
-    parseNode(license);
-    return issues;
-};
-
-//# sourceMappingURL=calculate-issues.js.map

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

@@ -1 +0,0 @@
-{"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,GAAGF,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,EAAE,GAC9E;wBACAP,OAAOM,IAAI,CAAC,GAAGJ,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,EAAE;oBAClE;oBACA;gBACF;YAEA;gBAAS;oBACP,MAAMC,mBAA0BN;oBAChC,MAAM,IAAIO,MAAM,CAAC,mCAAmC,EAAED,kBAAkB;gBAC1E;QACF;IACF;IAEAP,UAAUH;IAEV,OAAOE;AACT"}

package/src/lib/spdx/get-tokens.d.ts

@@ -1,2 +0,0 @@
-import { Token } from "./types/token";
-export declare const getTokens: (input: string) => Token[];

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

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "getTokens", {
-    enumerable: true,
-    get: function() {
-        return getTokens;
-    }
-});
-const _token = require("./types/token");
-const getTokens = (input)=>{
-    const tokens = [];
-    let currentToken = "";
-    // Pushes the current token to the tokens array and resets the current token
-    const pushToken = ()=>{
-        if (currentToken.length === 0) {
-            return;
-        }
-        if (currentToken === "WITH") {
-            tokens.push({
-                type: "with"
-            });
-        } else if ((0, _token.isOperator)(currentToken)) {
-            tokens.push({
-                type: "operator",
-                value: currentToken
-            });
-        } else {
-            tokens.push({
-                type: "identifier",
-                value: currentToken
-            });
-        }
-        currentToken = "";
-    };
-    for(let i = 0; i < input.length; i++){
-        const currentChar = input[i];
-        if ((0, _token.isParenthesis)(currentChar)) {
-            pushToken();
-            tokens.push({
-                type: "parenthesis",
-                value: currentChar
-            });
-            continue;
-        }
-        if (currentChar === " ") {
-            pushToken();
-            continue;
-        }
-        currentToken += currentChar;
-    }
-    pushToken();
-    return tokens;
-};
-
-//# sourceMappingURL=get-tokens.js.map

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

@@ -1 +0,0 @@
-{"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"}

package/src/lib/spdx/parse-license-expression.d.ts

@@ -1,2 +0,0 @@
-import { SpdxExpression, Unlicensed } from "./types/spdx-expression";
-export declare const parseLicenseExpression: (input: string) => SpdxExpression | Unlicensed;

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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "parseLicenseExpression", {
-    enumerable: true,
-    get: function() {
-        return parseLicenseExpression;
-    }
-});
-const _gettokens = require("./get-tokens");
-const _parsetokens = require("./parse-tokens");
-const parseLicenseExpression = (input)=>{
-    if (input === "UNLICENSED") {
-        return {
-            type: "unlicensed"
-        };
-    }
-    const tokens = (0, _gettokens.getTokens)(input);
-    return (0, _parsetokens.parseTokens)(tokens, input);
-};
-
-//# sourceMappingURL=parse-license-expression.js.map

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

@@ -1 +0,0 @@
-{"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"}

package/src/lib/spdx/parse-tokens.d.ts

@@ -1,3 +0,0 @@
-import { SpdxExpression } from "./types/spdx-expression";
-import { Token } from "./types/token";
-export declare const parseTokens: (tokens: Token[], originalInput: string) => SpdxExpression;

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

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "parseTokens", {
-    enumerable: true,
-    get: function() {
-        return parseTokens;
-    }
-});
-const parseTokens = (tokens, originalInput)=>{
-    let index = 0;
-    const throwNotValid = ()=>{
-        console.trace();
-        throw new Error(`'${originalInput}' is not a valid SPDX expression`);
-    };
-    const hasMore = ()=>index < tokens.length;
-    const getCurrentToken = ()=>hasMore() ? tokens[index] : null;
-    const moveToNextToken = ()=>{
-        // istanbul ignore next
-        if (!hasMore()) {
-            throwNotValid();
-        }
-        index++;
-    };
-    const tryParseParenthesis = (operator)=>{
-        const currentToken = getCurrentToken();
-        if (currentToken && currentToken.type === "parenthesis" && operator === currentToken.value) {
-            moveToNextToken();
-            return true;
-        }
-        return false;
-    };
-    const tryParseWithToken = ()=>{
-        const currentToken = getCurrentToken();
-        if (currentToken && currentToken.type === "with") {
-            moveToNextToken();
-            return true;
-        }
-        return false;
-    };
-    const tryParseOperator = (operator)=>{
-        const currentToken = getCurrentToken();
-        if (currentToken && currentToken.type === "operator" && operator === currentToken.value) {
-            moveToNextToken();
-            return currentToken.value;
-        }
-        return undefined;
-    };
-    const tryParseLicense = ()=>{
-        const currentToken = getCurrentToken();
-        if (currentToken && currentToken.type === "identifier") {
-            moveToNextToken();
-            return {
-                type: "identifier",
-                value: currentToken.value
-            };
-        }
-        return undefined;
-    };
-    const tryParseParenthesizedExpression = ()=>{
-        const startsWithParenthesis = tryParseParenthesis("(");
-        if (!startsWithParenthesis) {
-            return undefined;
-        }
-        const innerExpression = tryParseExpression();
-        const endsWithParenthesis = tryParseParenthesis(")");
-        if (!endsWithParenthesis) {
-            throwNotValid();
-        }
-        return innerExpression;
-    };
-    const binaryOperationFactory = (operator, tryNextParser)=>{
-        const tryParseBinaryOperation = ()=>{
-            const left = tryNextParser();
-            if (!left) {
-                return undefined;
-            }
-            if (!tryParseOperator(operator)) {
-                return left;
-            }
-            const right = tryParseBinaryOperation();
-            if (!right) {
-                return throwNotValid();
-            }
-            return {
-                type: operator,
-                expressions: [
-                    left,
-                    right
-                ]
-            };
-        };
-        return tryParseBinaryOperation;
-    };
-    const tryParseWith = ()=>{
-        const left = tryParseLicense();
-        if (!left) {
-            return undefined;
-        }
-        if (!tryParseWithToken()) {
-            return left;
-        }
-        const right = tryParseLicense();
-        if (!right) {
-            return throwNotValid();
-        }
-        return {
-            type: "WITH",
-            expressions: [
-                left.value,
-                right.value
-            ]
-        };
-    };
-    const parseAnd = binaryOperationFactory("AND", ()=>tryParseParenthesizedExpression() || tryParseWith());
-    const tryParseExpression = binaryOperationFactory("OR", parseAnd);
-    const node = tryParseExpression();
-    if (!node || hasMore()) {
-        return throwNotValid();
-    }
-    return node;
-};
-
-//# sourceMappingURL=parse-tokens.js.map

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

@@ -1 +0,0 @@
-{"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"}

package/src/lib/spdx/types/spdx-expression.d.ts

@@ -1,20 +0,0 @@
-export type Identifier = {
-    type: "identifier";
-    value: string;
-};
-export type AndExpression = {
-    type: "AND";
-    expressions: [SpdxExpression, SpdxExpression];
-};
-export type OrExpression = {
-    type: "OR";
-    expressions: [SpdxExpression, SpdxExpression];
-};
-export type WithExpression = {
-    type: "WITH";
-    expressions: [string, string];
-};
-export type SpdxExpression = Identifier | AndExpression | OrExpression | WithExpression;
-export type Unlicensed = {
-    type: "unlicensed";
-};

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

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

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

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

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

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