@kingironman2011/license-checker 1.0.2 → 1.1.0

package/dist/licenses/spdx.d.ts

@@ -0,0 +1,17 @@
+export interface SpdxLicense {
+    license: string;
+    plus?: true;
+    exception?: string;
+}
+export interface SpdxBinaryExpression {
+    left: SpdxExpression;
+    conjunction: "and" | "or";
+    right: SpdxExpression;
+}
+export type SpdxExpression = SpdxLicense | SpdxBinaryExpression;
+export declare function parseSpdxExpression(source: string): SpdxExpression;
+export declare function isValidSpdxExpression(source: string): boolean;
+export declare function correctSpdxExpression(source: string, options?: {
+    upgrade?: boolean;
+}): string | null;
+export declare function spdxExpressionSatisfies(source: string, allowedExpressions: string[]): boolean;

package/dist/licenses/spdx.js

@@ -0,0 +1,394 @@
+import { SPDX_DEPRECATED_LICENSE_IDS, SPDX_EXCEPTION_IDS, SPDX_LICENSE_IDS, SPDX_VERSION_RANGES, } from "./spdx-data.js";
+const licenseIds = new Set([
+    ...SPDX_LICENSE_IDS,
+    ...SPDX_DEPRECATED_LICENSE_IDS,
+]);
+const exceptionIds = new Set(SPDX_EXCEPTION_IDS);
+function tokenize(expression) {
+    const tokens = [];
+    let offset = 0;
+    while (offset < expression.length) {
+        const rest = expression.slice(offset);
+        const whitespace = /^\s+/.exec(rest);
+        if (whitespace) {
+            offset += whitespace[0].length;
+            continue;
+        }
+        const documentLicenseRef = /^(DocumentRef-([A-Za-z0-9.-]+):LicenseRef-([A-Za-z0-9.-]+))/.exec(rest);
+        const licenseRef = /^LicenseRef-([A-Za-z0-9.-]+)/.exec(rest);
+        if (documentLicenseRef) {
+            tokens.push({ type: "licenseRef", value: documentLicenseRef[1] });
+            offset += documentLicenseRef[1].length;
+            continue;
+        }
+        if (licenseRef) {
+            const value = `LicenseRef-${licenseRef[1]}`;
+            tokens.push({ type: "licenseRef", value });
+            offset += value.length;
+            continue;
+        }
+        const operator = /^(AND|OR|WITH)\b/i.exec(rest);
+        if (operator) {
+            tokens.push({
+                type: "operator",
+                value: operator[1].toUpperCase(),
+            });
+            offset += operator[0].length;
+            continue;
+        }
+        const punctuation = /^[()+:]/.exec(rest);
+        if (punctuation) {
+            if (punctuation[0] === "+" && /\s/.test(expression[offset - 1] ?? "")) {
+                throw new Error("A plus marker cannot be separated from its license identifier");
+            }
+            tokens.push({ type: "operator", value: punctuation[0] });
+            offset += punctuation[0].length;
+            continue;
+        }
+        const identifier = /^[A-Za-z0-9.-]+/.exec(rest);
+        if (identifier) {
+            const value = identifier[0];
+            if (licenseIds.has(value)) {
+                tokens.push({ type: "license", value });
+            }
+            else if (exceptionIds.has(value)) {
+                tokens.push({ type: "exception", value });
+            }
+            else {
+                throw new Error(`Unknown SPDX identifier: ${value}`);
+            }
+            offset += value.length;
+            continue;
+        }
+        throw new Error(`Invalid SPDX expression at offset ${offset}`);
+    }
+    return tokens;
+}
+export function parseSpdxExpression(source) {
+    const tokens = tokenize(source);
+    let index = 0;
+    const peek = () => tokens[index];
+    const takeOperator = (value) => {
+        if (peek()?.type === "operator" && peek()?.value === value) {
+            index += 1;
+            return true;
+        }
+        return false;
+    };
+    const parseAtom = () => {
+        if (takeOperator("(")) {
+            const nested = parseOr();
+            if (!takeOperator(")"))
+                throw new Error("Expected closing parenthesis");
+            return nested;
+        }
+        const token = peek();
+        if (!token || (token.type !== "license" && token.type !== "licenseRef")) {
+            throw new Error("Expected a license identifier");
+        }
+        index += 1;
+        const node = { license: token.value };
+        if (token.type === "license" && takeOperator("+"))
+            node.plus = true;
+        if (takeOperator("WITH")) {
+            const exception = peek();
+            if (!exception || exception.type !== "exception") {
+                throw new Error("Expected an SPDX exception after WITH");
+            }
+            node.exception = exception.value;
+            index += 1;
+        }
+        return node;
+    };
+    const parseAnd = () => {
+        let expression = parseAtom();
+        while (takeOperator("AND")) {
+            expression = { left: expression, conjunction: "and", right: parseAtom() };
+        }
+        return expression;
+    };
+    const parseOr = () => {
+        let expression = parseAnd();
+        while (takeOperator("OR")) {
+            expression = { left: expression, conjunction: "or", right: parseAnd() };
+        }
+        return expression;
+    };
+    if (tokens.length === 0)
+        throw new Error("SPDX expression cannot be empty");
+    const result = parseOr();
+    if (index !== tokens.length)
+        throw new Error("Unexpected token in SPDX expression");
+    return result;
+}
+export function isValidSpdxExpression(source) {
+    try {
+        parseSpdxExpression(source);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const transpositions = [
+    ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
+    ["GNU Lesser General Public License", "LGPL-2.1"],
+    ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL"],
+    ["GNU Lesser General Public License", "LGPL"],
+    ["LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
+    ["Lesser General Public License", "LGPL-2.1"],
+    ["LESSER GENERAL PUBLIC LICENSE", "LGPL"],
+    ["Lesser General Public License", "LGPL"],
+    ["GNU General Public License", "GPL"],
+    ["Gnu public license", "GPL"],
+    ["GNU Public License", "GPL"],
+    ["GNU GENERAL PUBLIC LICENSE", "GPL"],
+    ["Mozilla Public License", "MPL"],
+    ["Universal Permissive License", "UPL"],
+    ["GNU/GPL", "GPL"],
+    ["GNU GLP", "GPL"],
+    ["GNU LGPL", "LGPL"],
+    ["GNU", "GPL"],
+    ["GUN", "GPL"],
+    ["GLP", "GPL"],
+    ["Gpl", "GPL"],
+    ["APGL", "AGPL"],
+    ["APL", "Apache"],
+    ["ISD", "ISC"],
+    ["IST", "ISC"],
+    ["MTI", "MIT"],
+    ["WTH", "WTF"],
+    ["WTFGPL", "WTFPL"],
+    [" or later", "+"],
+    [" International", ""],
+    ["Claude", "Clause"],
+    ["+", ""],
+    ["-License", ""],
+].toSorted(([left], [right]) => right.length - left.length);
+const transforms = [
+    (value) => value.toUpperCase(),
+    (value) => value.trim(),
+    (value) => value.replace(/\./g, ""),
+    (value) => value.replace(/\s+/g, ""),
+    (value) => value.replace(/\s+/g, "-"),
+    (value) => value.replace("v", "-"),
+    (value) => value.replace(/,?\s*(\d)/, "-$1"),
+    (value) => value.replace(/,?\s*(\d)/, "-$1.0"),
+    (value) => value.replace(/,?\s*(?:V\.?|Version|version)\s*(\d)/i, "-$1"),
+    (value) => value.replace(/,?\s*(?:V\.?|Version|version)\s*(\d)/i, "-$1.0"),
+    (value) => value[0]?.toUpperCase() + value.slice(1),
+    (value) => value.replace("/", "-"),
+    (value) => value.replace(/\s*V\s*(\d)/, "-$1").replace(/(\d)$/, "$1.0"),
+    (value) => `${value}${value.includes("3.0") ? "-or-later" : "-only"}`,
+    (value) => `${value}only`,
+    (value) => value.replace(/(\d)$/, "-$1.0"),
+    (value) => value.replace(/(-| )?(\d)$/, "-$2-Clause"),
+    (value) => value.replace(/(-| )clause(-| )(\d)/i, "-$3-Clause"),
+    (value) => value.replace(/\b(Modified|New|Revised)(-| )?BSD((-| )License)?/i, "BSD-3-Clause"),
+    (value) => value.replace(/\bSimplified(-| )?BSD((-| )License)?/i, "BSD-2-Clause"),
+    (value) => value.replace(/\b(Free|Net)(-| )?BSD((-| )License)?/i, "BSD-2-Clause-$1BSD"),
+    (value) => value.replace(/\bClear(-| )?BSD((-| )License)?/i, "BSD-3-Clause-Clear"),
+    (value) => value.replace(/\b(Old|Original)(-| )?BSD((-| )License)?/i, "BSD-4-Clause"),
+    (value) => `CC-${value}`,
+    (value) => `CC-${value}-4.0`,
+    (value) => `CC-${value
+        .replace(/Attribution/g, "BY")
+        .replace(/NonCommercial/g, "NC")
+        .replace(/NoDerivatives/g, "ND")
+        .replace(/ (\d)/, "-$1")
+        .replace(/ ?International/, "")}`,
+    (value) => `CC-${value
+        .replace(/Attribution/g, "BY")
+        .replace(/NonCommercial/g, "NC")
+        .replace(/NoDerivatives/g, "ND")
+        .replace(/ (\d)/, "-$1")
+        .replace(/ ?International/, "")}-4.0`,
+];
+const basicLastResorts = [
+    ["UNLI", "Unlicense"],
+    ["WTF", "WTFPL"],
+    ["2 CLAUSE", "BSD-2-Clause"],
+    ["2-CLAUSE", "BSD-2-Clause"],
+    ["3 CLAUSE", "BSD-3-Clause"],
+    ["3-CLAUSE", "BSD-3-Clause"],
+    ["AFFERO", "AGPL-3.0-or-later"],
+    ["AGPL", "AGPL-3.0-or-later"],
+    ["APACHE", "Apache-2.0"],
+    ["ARTISTIC", "Artistic-2.0"],
+    ["BEER", "Beerware"],
+    ["BOOST", "BSL-1.0"],
+    ["BSD", "BSD-2-Clause"],
+    ["CDDL", "CDDL-1.1"],
+    ["ECLIPSE", "EPL-1.0"],
+    ["FUCK", "WTFPL"],
+    ["GNU", "GPL-3.0-or-later"],
+    ["LGPL", "LGPL-3.0-or-later"],
+    ["GPLV1", "GPL-1.0-only"],
+    ["GPL-1", "GPL-1.0-only"],
+    ["GPLV2", "GPL-2.0-only"],
+    ["GPL-2", "GPL-2.0-only"],
+    ["GPL", "GPL-3.0-or-later"],
+    ["MIT +NO-FALSE-ATTRIBS", "MITNFA"],
+    ["MIT", "MIT"],
+    ["MPL", "MPL-2.0"],
+    ["X11", "X11"],
+    ["ZLIB", "Zlib"],
+];
+const licensesByFamily = new Map();
+for (const licenseId of SPDX_LICENSE_IDS) {
+    const match = /^(.*)-\d+\.\d+$/.exec(licenseId);
+    if (!match)
+        continue;
+    const family = match[1];
+    const versions = licensesByFamily.get(family) ?? [];
+    versions.push(licenseId);
+    licensesByFamily.set(family, versions);
+}
+const singleVersionAliases = Array.from(licensesByFamily.entries())
+    .filter(([family, versions]) => family !== "APL" && versions.length === 1)
+    .map(([family, versions]) => [family, versions[0]]);
+const lastResorts = [
+    ...basicLastResorts,
+    ...singleVersionAliases,
+].toSorted(([left], [right]) => right.length - left.length);
+const validLastResort = (value) => {
+    const uppercase = value.toUpperCase();
+    return (lastResorts.find(([substring]) => uppercase.includes(substring))?.[1] ??
+        null);
+};
+const anyCorrection = (value, check) => {
+    for (const [transposed, corrected] of transpositions) {
+        if (value.includes(transposed)) {
+            const result = check(value.replace(transposed, corrected));
+            if (result !== null)
+                return result;
+        }
+    }
+    return null;
+};
+function upgradeGplIdentifiers(value) {
+    const only = new Set([
+        "GPL-1.0",
+        "LGPL-1.0",
+        "AGPL-1.0",
+        "GPL-2.0",
+        "LGPL-2.0",
+        "AGPL-2.0",
+        "LGPL-2.1",
+    ]);
+    const later = new Set(["GPL-3.0", "LGPL-3.0", "AGPL-3.0"]);
+    const plus = new Set([
+        "GPL-1.0+",
+        "GPL-2.0+",
+        "GPL-3.0+",
+        "LGPL-2.0+",
+        "LGPL-2.1+",
+        "LGPL-3.0+",
+        "AGPL-1.0+",
+        "AGPL-3.0+",
+    ]);
+    if (only.has(value))
+        return `${value}-only`;
+    if (later.has(value))
+        return `${value}-or-later`;
+    if (plus.has(value))
+        return `${value.slice(0, -1)}-or-later`;
+    return value;
+}
+export function correctSpdxExpression(source, options = {}) {
+    if (typeof source !== "string" || source.trim() === "") {
+        throw new Error("Invalid argument. Expected non-empty string.");
+    }
+    const upgrade = options.upgrade ?? true;
+    const postprocess = (value) => upgrade ? upgradeGplIdentifiers(value) : value;
+    const input = source.trim();
+    if (isValidSpdxExpression(input))
+        return postprocess(input);
+    const noPlus = input.replace(/\+$/, "").trim();
+    if (noPlus !== input && isValidSpdxExpression(noPlus))
+        return postprocess(noPlus);
+    const validTransformation = (value) => {
+        for (const transform of transforms) {
+            const transformed = transform(value).trim();
+            if (transformed !== value && isValidSpdxExpression(transformed))
+                return transformed;
+        }
+        return null;
+    };
+    const transformed = validTransformation(input);
+    if (transformed !== null)
+        return postprocess(transformed);
+    const transposed = anyCorrection(input, (candidate) => isValidSpdxExpression(candidate)
+        ? candidate
+        : validTransformation(candidate));
+    if (transposed !== null)
+        return postprocess(transposed);
+    const fallback = validLastResort(input);
+    if (fallback !== null)
+        return postprocess(fallback);
+    const fallbackTransposed = anyCorrection(input, validLastResort);
+    return fallbackTransposed === null ? null : postprocess(fallbackTransposed);
+}
+function normalizeGplTerm(term) {
+    const legacy = /^(GPL|LGPL|AGPL|GFDL)-(\d+\.\d+)(-only|-or-later)?$/.exec(term.license);
+    if (!legacy)
+        return term;
+    const [, family, version, suffix] = legacy;
+    const result = { ...term, license: `${family}-${version}` };
+    if (suffix === "-or-later")
+        result.plus = true;
+    else if (suffix === "-only")
+        delete result.plus;
+    return result;
+}
+const versionRanges = SPDX_VERSION_RANGES;
+function isInVersionRange(first, second) {
+    return versionRanges.some((range) => {
+        const indexOf = (license) => range.findIndex((entry) => typeof entry === "string" ? entry === license : entry.includes(license));
+        const firstIndex = indexOf(first);
+        return firstIndex >= 0 && indexOf(second) >= 0;
+    });
+}
+function isAtLeastInRange(first, second) {
+    return versionRanges.some((range) => {
+        const indexOf = (license) => range.findIndex((entry) => typeof entry === "string" ? entry === license : entry.includes(license));
+        const firstIndex = indexOf(first);
+        const secondIndex = indexOf(second);
+        return firstIndex >= 0 && secondIndex >= 0 && firstIndex >= secondIndex;
+    });
+}
+function compatibleLicense(expression, approved) {
+    if (expression.exception !== approved.exception)
+        return false;
+    if (!approved.plus && !expression.plus)
+        return expression.license === approved.license;
+    if (approved.plus && expression.plus) {
+        return isInVersionRange(expression.license, approved.license);
+    }
+    if (approved.plus)
+        return isAtLeastInRange(expression.license, approved.license);
+    return isAtLeastInRange(approved.license, expression.license);
+}
+function expandToDnf(expression) {
+    if (!isBinaryExpression(expression))
+        return [[normalizeGplTerm(expression)]];
+    const left = expandToDnf(expression.left);
+    const right = expandToDnf(expression.right);
+    if (expression.conjunction === "or")
+        return [...left, ...right];
+    return left.flatMap((leftTerms) => right.map((rightTerms) => [...leftTerms, ...rightTerms]));
+}
+function isBinaryExpression(expression) {
+    return "conjunction" in expression;
+}
+export function spdxExpressionSatisfies(source, allowedExpressions) {
+    const expressionDnf = expandToDnf(parseSpdxExpression(source));
+    const allowed = allowedExpressions.map((value) => {
+        const parsed = parseSpdxExpression(value);
+        if (isBinaryExpression(parsed)) {
+            throw new Error("Approved licenses cannot be AND or OR expressions.");
+        }
+        return normalizeGplTerm(parsed);
+    });
+    return expressionDnf.some((terms) => terms.every((term) => allowed.some((candidate) => compatibleLicense(term, candidate))));
+}

package/dist/output/ansi.d.ts

@@ -0,0 +1,4 @@
+export declare function supportsBasicColor(): boolean;
+export declare function boldRed(value: string, enabled?: boolean): string;
+export declare function whiteOnRgb(value: string, rgb: readonly [number, number, number], enabled?: boolean): string;
+export declare function dim(value: string, enabled?: boolean): string;

package/dist/output/ansi.js

@@ -0,0 +1,94 @@
+const ESC = "\u001b[";
+const ansi256Component = (value) => Math.min(5, value < 48 ? 0 : value < 115 ? 1 : Math.round((value - 35) / 40));
+function getColorLevel() {
+    const forced = process.env.FORCE_COLOR;
+    if (forced !== undefined) {
+        if (forced === "0")
+            return 0;
+        const parsed = Number.parseInt(forced, 10);
+        return Number.isNaN(parsed) ? 1 : Math.max(0, Math.min(3, parsed));
+    }
+    if (process.env.NO_COLOR !== undefined || process.env.NODE_DISABLE_COLORS) {
+        return 0;
+    }
+    const stream = process.stdout;
+    if (!stream.isTTY || process.env.TERM === "dumb")
+        return 0;
+    if (/^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? ""))
+        return 3;
+    if (/-256(color)?$/i.test(process.env.TERM ?? ""))
+        return 2;
+    if (process.platform === "win32" || process.env.TERM)
+        return 1;
+    return 0;
+}
+export function supportsBasicColor() {
+    return getColorLevel() >= 1;
+}
+export function boldRed(value, enabled = supportsBasicColor()) {
+    if (!enabled)
+        return value;
+    return `${ESC}1m${ESC}31m${value}${ESC}39m${ESC}22m`;
+}
+function rgbToAnsi256(red, green, blue) {
+    if (red === green && green === blue) {
+        if (red < 8)
+            return 16;
+        if (red > 248)
+            return 231;
+        return Math.round((red - 8) / 10) + 232;
+    }
+    return (16 +
+        36 * ansi256Component(red) +
+        6 * ansi256Component(green) +
+        ansi256Component(blue));
+}
+function rgbToAnsi16(red, green, blue) {
+    const palette = [
+        [0, 0, 0],
+        [128, 0, 0],
+        [0, 128, 0],
+        [128, 128, 0],
+        [0, 0, 128],
+        [128, 0, 128],
+        [0, 128, 128],
+        [192, 192, 192],
+        [128, 128, 128],
+        [255, 0, 0],
+        [0, 255, 0],
+        [255, 255, 0],
+        [0, 0, 255],
+        [255, 0, 255],
+        [0, 255, 255],
+        [255, 255, 255],
+    ];
+    let closest = 0;
+    let smallestDistance = Number.POSITIVE_INFINITY;
+    palette.forEach(([paletteRed, paletteGreen, paletteBlue], index) => {
+        const distance = (red - paletteRed) ** 2 +
+            (green - paletteGreen) ** 2 +
+            (blue - paletteBlue) ** 2;
+        if (distance < smallestDistance) {
+            closest = index;
+            smallestDistance = distance;
+        }
+    });
+    return closest < 8 ? 40 + closest : 100 + closest - 8;
+}
+function rgbBackground(red, green, blue) {
+    const level = getColorLevel();
+    if (level >= 3)
+        return `${ESC}48;2;${red};${green};${blue}m`;
+    if (level >= 2)
+        return `${ESC}48;5;${rgbToAnsi256(red, green, blue)}m`;
+    return `${ESC}${rgbToAnsi16(red, green, blue)}m`;
+}
+export function whiteOnRgb(value, rgb, enabled = supportsBasicColor()) {
+    if (!enabled)
+        return value;
+    const [red, green, blue] = rgb;
+    return `${ESC}37m${rgbBackground(red, green, blue)}${value}${ESC}49m${ESC}39m`;
+}
+export function dim(value, enabled = supportsBasicColor()) {
+    return enabled ? `${ESC}2m${value}${ESC}22m` : value;
+}

package/dist/output/csv.d.ts

@@ -0,0 +1,4 @@
+import type { CustomFormat, ModuleInfos } from "../types.js";
+export declare const getCsvData: (sorted: ModuleInfos, customFormat?: CustomFormat, csvComponentPrefix?: string) => string[];
+export declare const getCsvHeaders: (customFormat?: CustomFormat, csvComponentPrefix?: string) => string;
+export declare const asCSV: (sorted: ModuleInfos, customFormat?: CustomFormat, csvComponentPrefix?: string) => string;

package/dist/output/csv.js

@@ -0,0 +1,50 @@
+export const getCsvData = (sorted, customFormat, csvComponentPrefix) => {
+    const csvDataArr = [];
+    Object.entries(sorted).forEach(([key, module]) => {
+        const dataElements = [];
+        if (csvComponentPrefix) {
+            dataElements.push(`"${csvComponentPrefix}"`);
+        }
+        // Grab the custom keys from the custom format
+        if (typeof customFormat === "object" &&
+            Object.keys(customFormat).length > 0) {
+            dataElements.push(`"${key}"`);
+            Object.keys(customFormat).forEach((item) => {
+                dataElements.push(`"${module[item]}"`);
+            });
+        }
+        else {
+            // Be sure to push empty strings for empty values, as this is what CSV expects:
+            dataElements.push([
+                `"${key}"`,
+                `"${module.licenses || ""}"`,
+                `"${module.repository || ""}"`,
+            ]);
+        }
+        csvDataArr.push(dataElements.join(","));
+    });
+    return csvDataArr;
+};
+export const getCsvHeaders = (customFormat, csvComponentPrefix) => {
+    const prefixName = '"component"';
+    const entriesArr = [];
+    if (csvComponentPrefix) {
+        entriesArr.push(prefixName);
+    }
+    if (typeof customFormat === "object" &&
+        Object.keys(customFormat).length > 0) {
+        entriesArr.push('"module name"');
+        Object.keys(customFormat).forEach((item) => {
+            entriesArr.push(`"${item}"`);
+        });
+    }
+    else {
+        entriesArr.push('"module name"', '"license"', '"repository"');
+    }
+    return entriesArr.join(",");
+};
+export const asCSV = (sorted, customFormat, csvComponentPrefix) => {
+    const csvHeaders = getCsvHeaders(customFormat, csvComponentPrefix);
+    const csvDataArr = getCsvData(sorted, customFormat, csvComponentPrefix);
+    return [csvHeaders, ...csvDataArr].join("\n");
+};

package/dist/output/filter-attributes.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleInfo } from "../types.js";
+export declare const filterAttributes: (attributes: string[], json: ModuleInfo) => ModuleInfo;

package/dist/output/filter-attributes.js

@@ -0,0 +1,10 @@
+export const filterAttributes = (attributes, json) => {
+    let filteredJson = json;
+    if (attributes) {
+        filteredJson = {};
+        attributes.forEach((attribute) => {
+            filteredJson[attribute] = json[attribute];
+        });
+    }
+    return filteredJson;
+};

package/dist/output/format-output.d.ts

@@ -0,0 +1,4 @@
+import type { LicenseCheckOptions, ModuleInfos } from "../types.js";
+export declare function shouldColorizeOutput(args: LicenseCheckOptions): boolean;
+export declare function colorizeOutput(json: ModuleInfos): void;
+export declare function getFormattedOutput(modulesWithVersions: ModuleInfos, args: LicenseCheckOptions): string;

package/dist/output/format-output.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { dim, whiteOnRgb } from "./ansi.js";
+import { asCSV } from "./csv.js";
+import { filterAttributes } from "./filter-attributes.js";
+import { asMarkDown, asPlainVertical, asSummary, asTree } from "./renderers.js";
+export function shouldColorizeOutput(args) {
+    return (Boolean(args.color) &&
+        !args.out &&
+        !args.files &&
+        !(args.csv || args.json || args.markdown || args.plainVertical));
+}
+export function colorizeOutput(json) {
+    Object.keys(json).forEach((key) => {
+        const index = key.lastIndexOf("@");
+        const colorizedKey = whiteOnRgb(key.slice(0, index), [47, 79, 79]) +
+            dim("@") +
+            whiteOnRgb(key.slice(index + 1), [0, 128, 0]);
+        if (colorizedKey === key) {
+            return;
+        }
+        json[colorizedKey] = json[key];
+        delete json[key];
+    });
+}
+function filterJson(limitAttributes, json) {
+    let filteredJson = json;
+    if (limitAttributes) {
+        filteredJson = {};
+        const attributes = limitAttributes
+            .split(",")
+            .map((attribute) => attribute.trim());
+        Object.keys(json).forEach((dependency) => {
+            filteredJson[dependency] = filterAttributes(attributes, json[dependency]);
+        });
+    }
+    return filteredJson;
+}
+export function getFormattedOutput(modulesWithVersions, args) {
+    let filteredJson = filterJson(args.limitAttributes, modulesWithVersions);
+    const jsonCopy = Object.fromEntries(Object.entries(filteredJson).map(([moduleName, moduleInfo]) => [
+        moduleName,
+        { ...moduleInfo },
+    ]));
+    if (args.files) {
+        const filesDirectory = args.files;
+        Object.keys(jsonCopy).forEach((moduleName) => {
+            const outPath = path.join(filesDirectory, `${moduleName}-LICENSE.txt`);
+            const originalLicenseFile = jsonCopy[moduleName].licenseFile;
+            if (originalLicenseFile && fs.existsSync(originalLicenseFile)) {
+                if (args.relativeLicensePath) {
+                    if (args.out) {
+                        jsonCopy[moduleName].licenseFile = path.relative(path.dirname(args.out), outPath);
+                    }
+                    else {
+                        jsonCopy[moduleName].licenseFile = path.relative(process.cwd(), outPath);
+                    }
+                }
+                else {
+                    jsonCopy[moduleName].licenseFile = outPath;
+                }
+            }
+        });
+    }
+    if (args.json) {
+        return `${JSON.stringify(jsonCopy, null, 4)}\n`;
+    }
+    if (args.csv) {
+        return asCSV(jsonCopy, args.customFormat, args.csvComponentPrefix);
+    }
+    if (args.markdown) {
+        return `${asMarkDown(jsonCopy, args.customFormat)}\n`;
+    }
+    if (args.summary) {
+        return asSummary(jsonCopy);
+    }
+    if (args.plainVertical || args.angularCli) {
+        return asPlainVertical(jsonCopy);
+    }
+    return asTree(jsonCopy);
+}

package/dist/output/renderers.d.ts

@@ -0,0 +1,15 @@
+import type { CustomFormat, ModuleInfos } from "../types.js";
+export declare const asTree: (sorted: ModuleInfos) => string;
+export declare const asSummary: (sorted: ModuleInfos) => string;
+/**
+ * Exports data as Markdown (*.md) which has its own syntax.
+ *
+ * @param  sorted                  The sorted JSON data from all packages.
+ * @param  {object} [customFormat] The custom format with information about the needed keys.
+ * @return {string}                The returning plain text.
+ */
+export declare const asMarkDown: (sorted: ModuleInfos, customFormat?: CustomFormat) => string;
+/**
+ * Output data in plain vertical format like Angular CLI does: https://angular.io/3rdpartylicenses.txt
+ */
+export declare const asPlainVertical: (sorted: ModuleInfos) => string;