@volumegraphics/license-info-collector 2.0.0 → 3.0.3

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from './package_infos';
-export * from './package_overrides';
-export * from './section';
+export * from './package_infos';
+export * from './package_overrides';
+export * from './section';

package/lib/index.js

@@ -1,8 +1,19 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./package_infos"));
-__export(require("./package_overrides"));
-__export(require("./section"));
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./package_infos"), exports);
+__exportStar(require("./package_overrides"), exports);
+__exportStar(require("./section"), exports);

package/lib/package_infos.d.ts

@@ -1,47 +1,57 @@
-export interface Author {
-    name?: string;
-    email?: string;
-    url?: string;
-}
-export interface Repository {
-    type: string;
-    url: string;
-}
-export interface PackageContent {
-    name: string;
-    version: string;
-    packageJson: string[];
-    contributors?: (string | Author)[];
-    author?: string | Author;
-    description?: string;
-    repository?: string | Repository;
-    homepage?: string;
-    license?: string;
-}
-export interface Dependency {
-    [index: string]: string;
-}
-export interface RawPackageDependencies {
-    dependencies?: Dependency;
-    devDependencies?: Dependency;
-    optionalDependencies?: Dependency;
-}
-export interface PackageDependencies {
-    packageDependencies: PackageContent[];
-    packageDevDependencies: PackageContent[];
-    packageOptionalDependencies: PackageContent[];
-}
-export interface InvalidPackageContent {
-    copyright: PackageContent[];
-    license: PackageContent[];
-}
-export declare function collectPackageInfos(productPackageJson: string, nodeModulePaths: string[], disableNpmVersionCheck: boolean): (PackageContent & PackageDependencies & RawPackageDependencies)[];
-export declare type LicenseName = string;
-export declare function findInvalidPackageContent(packageContents: (PackageContent & PackageDependencies)[], allowedLicenses: LicenseName[], evaluateCopyrightInfo: (content: PackageContent) => boolean): InvalidPackageContent;
-export interface MissingPackages {
-    packageReference: PackageContent & PackageDependencies & RawPackageDependencies;
-    missingDependencies: Dependency;
-    missingDevDependencies: Dependency;
-    missingOptionalDependencies: Dependency;
-}
-export declare function findMissingPackages(contents: (PackageContent & PackageDependencies & RawPackageDependencies)[], disableNpmVersionCheck: boolean): MissingPackages[];
+export interface Author {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+export interface Repository {
+    type: string;
+    url: string;
+}
+export interface PackageContent {
+    name: string;
+    version: string;
+    packageJson: string[];
+    contributors?: (string | Author)[];
+    author?: string | Author;
+    description?: string;
+    repository?: string | Repository;
+    homepage?: string;
+    license?: string;
+}
+export interface Dependency {
+    [index: string]: string;
+}
+export interface RawPackageDependencies {
+    dependencies?: Dependency;
+    devDependencies?: Dependency;
+    optionalDependencies?: Dependency;
+}
+export interface PackageDependencies {
+    packageDependencies: PackageContent[];
+    packageDevDependencies: PackageContent[];
+    packageOptionalDependencies: PackageContent[];
+}
+export interface InvalidPackageContent {
+    copyright: PackageContent[];
+    license: PackageContent[];
+}
+export type ContentAndRawDependencies = PackageContent & RawPackageDependencies;
+export type CollectPackageError = {
+    packageFilePath: string;
+};
+export type CollectPackageInfoResult = {
+    result: (PackageContent & PackageDependencies & RawPackageDependencies)[];
+    invalidPackages: CollectPackageError[];
+};
+export declare function isCollectPackageError(object: ContentAndRawDependencies | CollectPackageError): object is CollectPackageError;
+export declare function isCollectRawDependencies(object: ContentAndRawDependencies | CollectPackageError): object is ContentAndRawDependencies;
+export declare function collectPackageInfos(productPackageJson: string, nodeModulePaths: string[], disableNpmVersionCheck: boolean): CollectPackageInfoResult;
+export type LicenseName = string;
+export declare function findInvalidPackageContent(packageContents: (PackageContent & PackageDependencies)[], allowedLicenses: LicenseName[], evaluateCopyrightInfo: (content: PackageContent) => boolean): InvalidPackageContent;
+export interface MissingPackages {
+    packageReference: PackageContent & PackageDependencies & RawPackageDependencies;
+    missingDependencies: Dependency;
+    missingDevDependencies: Dependency;
+    missingOptionalDependencies: Dependency;
+}
+export declare function findMissingPackages(contents: (PackageContent & PackageDependencies & RawPackageDependencies)[], disableNpmVersionCheck: boolean): MissingPackages[];

package/lib/package_infos.js

@@ -1,180 +1,208 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const semver = require("semver");
-function isSamePackageContent(left, right) {
-    return left.name === right.name && left.version === right.version;
-}
-function groupSameContents(contents) {
-    let uniques = [];
-    contents.forEach((content) => {
-        let foundUniqueItem = uniques.find((uniqueItem) => {
-            return content !== uniqueItem && isSamePackageContent(content, uniqueItem);
-        });
-        if (foundUniqueItem === undefined) {
-            uniques.push(content);
-            return;
-        }
-        foundUniqueItem.packageJson = foundUniqueItem.packageJson.concat(content.packageJson);
-    });
-    return uniques;
-}
-function getPackageFileFromDirectory(dir) {
-    let files = [];
-    const directoryItems = fs.readdirSync(dir);
-    for (let directoryItem of directoryItems) {
-        const absItem = path.join(dir, directoryItem);
-        if (fs.statSync(absItem).isDirectory()) {
-            files = files.concat(getPackageFileFromDirectory(absItem));
-        }
-        else {
-            if (directoryItem !== "package.json") {
-                continue;
-            }
-            files.push(absItem);
-        }
-    }
-    return files;
-}
-function getPackageFiles(nodeModulePaths) {
-    const paths = [];
-    for (const nodeModulesPath of nodeModulePaths) {
-        paths.push(...getPackageFileFromDirectory(nodeModulesPath));
-    }
-    return paths;
-}
-function resolve(dependencies, contents, disableNpmVersionCheck) {
-    let result = {
-        foundPackages: [],
-        missing: {}
-    };
-    for (let packageName in dependencies) {
-        const versionSemanticString = dependencies[packageName];
-        const referencedLib = contents.find((pack) => {
-            if (pack.name !== packageName)
-                return false;
-            if (pack.version === versionSemanticString)
-                return true;
-            if (disableNpmVersionCheck)
-                return false;
-            try {
-                return semver.satisfies(pack.version, versionSemanticString);
-            }
-            catch (e) {
-                return false;
-            }
-        });
-        if (referencedLib === undefined) {
-            result.missing[packageName] = dependencies[packageName];
-        }
-        else {
-            result.foundPackages.push(referencedLib);
-        }
-    }
-    return result;
-}
-;
-function resolveRawDependencies(contents, disableNpmVersionCheck) {
-    return contents.map((content) => {
-        const resolvedDependencies = {
-            packageDependencies: resolve(content.dependencies, contents, disableNpmVersionCheck).foundPackages,
-            packageDevDependencies: resolve(content.devDependencies, contents, disableNpmVersionCheck).foundPackages,
-            packageOptionalDependencies: resolve(content.optionalDependencies, contents, disableNpmVersionCheck).foundPackages
-        };
-        return Object.assign(content, resolvedDependencies);
-    });
-}
-function removeUnreferencedContents(contents, targetPackage) {
-    return contents.filter((content) => {
-        if (content === targetPackage) {
-            return true;
-        }
-        for (let c of contents) {
-            if (c === content)
-                continue;
-            if (c.packageDependencies.includes(content) || c.packageDevDependencies.includes(content) || c.packageOptionalDependencies.includes(content))
-                return true;
-        }
-        return false;
-    });
-}
-function collectPackageInfos(productPackageJson, nodeModulePaths, disableNpmVersionCheck) {
-    const transformDeprecatedContent = (content, deprecatedContent) => {
-        if (content.license && typeof content.license === "string") {
-            return;
-        }
-        if (deprecatedContent.license !== undefined && deprecatedContent.license.type !== undefined) {
-            if (!deprecatedContent.licenses)
-                deprecatedContent.licenses = [];
-            deprecatedContent.licenses.push(deprecatedContent.license);
-        }
-        if (!deprecatedContent.licenses) {
-            return;
-        }
-        const types = [];
-        for (let license of deprecatedContent.licenses) {
-            if (!license.type)
-                continue;
-            types.push(license.type);
-        }
-        if (types.length > 1) {
-            content.license = "(" + types.join(" OR ") + ")";
-            return;
-        }
-        if (types.length === 1) {
-            content.license = types[0];
-        }
-    };
-    const createPackageContent = (packageFilePath) => {
-        const fileContents = fs.readFileSync(packageFilePath).toString();
-        const contents = JSON.parse(fileContents);
-        const packageContent = contents;
-        packageContent.packageJson = [packageFilePath];
-        transformDeprecatedContent(packageContent, contents);
-        return packageContent;
-    };
-    let contents = getPackageFiles(nodeModulePaths).map(createPackageContent);
-    contents = groupSameContents(contents);
-    contents.push(createPackageContent(productPackageJson));
-    const resolvedContents = resolveRawDependencies(contents, disableNpmVersionCheck);
-    const referencedContents = removeUnreferencedContents(resolvedContents, resolvedContents[resolvedContents.length - 1]);
-    return referencedContents;
-}
-exports.collectPackageInfos = collectPackageInfos;
-function findInvalidPackageContent(packageContents, allowedLicenses, evaluateCopyrightInfo) {
-    const invalid = {
-        copyright: [],
-        license: []
-    };
-    for (let content of packageContents) {
-        if (!allowedLicenses.find((name) => { return name === content.license; })) {
-            invalid.license.push(content);
-        }
-        if (evaluateCopyrightInfo(content) === false) {
-            invalid.copyright.push(content);
-        }
-    }
-    return invalid;
-}
-exports.findInvalidPackageContent = findInvalidPackageContent;
-function findMissingPackages(contents, disableNpmVersionCheck) {
-    const missing = [];
-    for (const content of contents) {
-        const missingDependencies = resolve(content.dependencies, contents, disableNpmVersionCheck).missing;
-        const missingDevDependencies = resolve(content.devDependencies, contents, disableNpmVersionCheck).missing;
-        const missingOptionalDependencies = resolve(content.optionalDependencies, contents, disableNpmVersionCheck).missing;
-        if (Object.keys(missingDependencies).length !== 0
-            || Object.keys(missingDevDependencies).length !== 0
-            || Object.keys(missingOptionalDependencies).length !== 0) {
-            missing.push({
-                packageReference: content,
-                missingDependencies: missingDependencies,
-                missingDevDependencies: missingDevDependencies,
-                missingOptionalDependencies: missingOptionalDependencies
-            });
-        }
-    }
-    return missing;
-}
-exports.findMissingPackages = findMissingPackages;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMissingPackages = exports.findInvalidPackageContent = exports.collectPackageInfos = exports.isCollectRawDependencies = exports.isCollectPackageError = void 0;
+const path = require("path");
+const fs = require("fs");
+const semver = require("semver");
+function isCollectPackageError(object) {
+    return object.packageFilePath !== undefined;
+}
+exports.isCollectPackageError = isCollectPackageError;
+function isCollectRawDependencies(object) {
+    return !isCollectPackageError(object);
+}
+exports.isCollectRawDependencies = isCollectRawDependencies;
+function isSamePackageContent(left, right) {
+    return left.name === right.name && left.version === right.version;
+}
+function groupSameContents(contents) {
+    let uniques = [];
+    contents.forEach((content) => {
+        let foundUniqueItem = uniques.find((uniqueItem) => {
+            return content !== uniqueItem && isSamePackageContent(content, uniqueItem);
+        });
+        if (foundUniqueItem === undefined) {
+            uniques.push(content);
+            return;
+        }
+        foundUniqueItem.packageJson = foundUniqueItem.packageJson.concat(content.packageJson);
+    });
+    return uniques;
+}
+function getPackageFileFromDirectory(dir) {
+    let files = [];
+    const directoryItems = fs.readdirSync(dir);
+    for (let directoryItem of directoryItems) {
+        const absItem = path.join(dir, directoryItem);
+        if (fs.statSync(absItem).isDirectory()) {
+            files = files.concat(getPackageFileFromDirectory(absItem));
+        }
+        else {
+            if (directoryItem !== "package.json") {
+                continue;
+            }
+            files.push(absItem);
+        }
+    }
+    return files;
+}
+function getPackageFiles(nodeModulePaths) {
+    const paths = [];
+    for (const nodeModulesPath of nodeModulePaths) {
+        paths.push(...getPackageFileFromDirectory(nodeModulesPath));
+    }
+    return paths;
+}
+function resolve(dependencies, contents, disableNpmVersionCheck) {
+    let result = {
+        foundPackages: [],
+        missing: {}
+    };
+    for (let packageName in dependencies) {
+        const versionSemanticString = dependencies[packageName];
+        const referencedLib = contents.find((pack) => {
+            if (pack.name !== packageName)
+                return false;
+            if (pack.version === versionSemanticString)
+                return true;
+            if (disableNpmVersionCheck)
+                return false;
+            try {
+                return semver.satisfies(pack.version, versionSemanticString);
+            }
+            catch (e) {
+                return false;
+            }
+        });
+        if (referencedLib === undefined) {
+            result.missing[packageName] = dependencies[packageName];
+        }
+        else {
+            result.foundPackages.push(referencedLib);
+        }
+    }
+    return result;
+}
+;
+function resolveRawDependencies(contents, disableNpmVersionCheck) {
+    return contents.map((content) => {
+        const resolvedDependencies = {
+            packageDependencies: resolve(content.dependencies, contents, disableNpmVersionCheck).foundPackages,
+            packageDevDependencies: resolve(content.devDependencies, contents, disableNpmVersionCheck).foundPackages,
+            packageOptionalDependencies: resolve(content.optionalDependencies, contents, disableNpmVersionCheck).foundPackages
+        };
+        return Object.assign(content, resolvedDependencies);
+    });
+}
+function removeUnreferencedContents(contents, targetPackage) {
+    return contents.filter((content) => {
+        if (content === targetPackage) {
+            return true;
+        }
+        for (let c of contents) {
+            if (c === content)
+                continue;
+            if (c.packageDependencies.includes(content) || c.packageDevDependencies.includes(content) || c.packageOptionalDependencies.includes(content))
+                return true;
+        }
+        return false;
+    });
+}
+function collectPackageInfos(productPackageJson, nodeModulePaths, disableNpmVersionCheck) {
+    const transformDeprecatedContent = (content, deprecatedContent) => {
+        if (content.license && typeof content.license === "string") {
+            return;
+        }
+        if (deprecatedContent.license !== undefined && deprecatedContent.license.type !== undefined) {
+            if (!deprecatedContent.licenses)
+                deprecatedContent.licenses = [];
+            deprecatedContent.licenses.push(deprecatedContent.license);
+        }
+        if (!deprecatedContent.licenses) {
+            return;
+        }
+        const types = [];
+        for (let license of deprecatedContent.licenses) {
+            if (!license.type)
+                continue;
+            types.push(license.type);
+        }
+        if (types.length > 1) {
+            content.license = "(" + types.join(" OR ") + ")";
+            return;
+        }
+        if (types.length === 1) {
+            content.license = types[0];
+        }
+    };
+    const parseFileContents = (packageFilePath) => {
+        const fileContents = fs.readFileSync(packageFilePath).toString();
+        try {
+            return JSON.parse(fileContents);
+        }
+        catch (e) {
+            return {
+                packageFilePath
+            };
+        }
+    };
+    const createPackageContent = (packageFilePath) => {
+        const contents = parseFileContents(packageFilePath);
+        if (isCollectPackageError(contents))
+            return contents;
+        contents.packageJson = [packageFilePath];
+        transformDeprecatedContent(contents, contents);
+        return contents;
+    };
+    const contentsAndErrors = getPackageFiles(nodeModulePaths).map(createPackageContent);
+    const productContentOrError = createPackageContent(productPackageJson);
+    let contents = contentsAndErrors.filter(isCollectRawDependencies);
+    contents = groupSameContents(contents);
+    const invalidPackages = contentsAndErrors.filter(isCollectPackageError);
+    isCollectPackageError(productContentOrError)
+        ? invalidPackages.push(productContentOrError)
+        : contents.push(productContentOrError);
+    const resolvedContents = resolveRawDependencies(contents, disableNpmVersionCheck);
+    const result = removeUnreferencedContents(resolvedContents, resolvedContents[resolvedContents.length - 1]);
+    return {
+        result,
+        invalidPackages
+    };
+}
+exports.collectPackageInfos = collectPackageInfos;
+function findInvalidPackageContent(packageContents, allowedLicenses, evaluateCopyrightInfo) {
+    const invalid = {
+        copyright: [],
+        license: []
+    };
+    for (let content of packageContents) {
+        if (!allowedLicenses.find((name) => { return name === content.license; })) {
+            invalid.license.push(content);
+        }
+        if (evaluateCopyrightInfo(content) === false) {
+            invalid.copyright.push(content);
+        }
+    }
+    return invalid;
+}
+exports.findInvalidPackageContent = findInvalidPackageContent;
+function findMissingPackages(contents, disableNpmVersionCheck) {
+    const missing = [];
+    for (const content of contents) {
+        const missingDependencies = resolve(content.dependencies, contents, disableNpmVersionCheck).missing;
+        const missingDevDependencies = resolve(content.devDependencies, contents, disableNpmVersionCheck).missing;
+        const missingOptionalDependencies = resolve(content.optionalDependencies, contents, disableNpmVersionCheck).missing;
+        if (Object.keys(missingDependencies).length !== 0
+            || Object.keys(missingDevDependencies).length !== 0
+            || Object.keys(missingOptionalDependencies).length !== 0) {
+            missing.push({
+                packageReference: content,
+                missingDependencies: missingDependencies,
+                missingDevDependencies: missingDevDependencies,
+                missingOptionalDependencies: missingOptionalDependencies
+            });
+        }
+    }
+    return missing;
+}
+exports.findMissingPackages = findMissingPackages;

package/lib/package_overrides.d.ts

@@ -1,13 +1,13 @@
-import { PackageContent } from './package_infos';
-export interface Override {
-    name: string;
-    version: string;
-    new: string;
-    comment: string;
-}
-export interface Overrides {
-    homepage: Override[];
-    license: Override[];
-}
-export declare function applyOverrides(packages: PackageContent[], overrides: Overrides): void;
-export declare function findUnusedOverrides(packages: PackageContent[], overrides: Overrides): Overrides;
+import { PackageContent } from './package_infos';
+export interface Override {
+    name: string;
+    version: string;
+    new: string;
+    comment: string;
+}
+export interface Overrides {
+    homepage: Override[];
+    license: Override[];
+}
+export declare function applyOverrides(packages: PackageContent[], overrides: Overrides): void;
+export declare function findUnusedOverrides(packages: PackageContent[], overrides: Overrides): Overrides;

package/lib/package_overrides.js

@@ -1,57 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var OverrideSection;
-(function (OverrideSection) {
-    OverrideSection[OverrideSection["Homepage"] = 0] = "Homepage";
-    OverrideSection[OverrideSection["License"] = 1] = "License";
-})(OverrideSection || (OverrideSection = {}));
-function findOverrides(packages, overrides, overrideMatch) {
-    const getPackageFn = (o) => (pack) => {
-        return o.name === pack.name && o.version == pack.version;
-    };
-    for (let override of overrides.homepage) {
-        overrideMatch(packages.find(getPackageFn(override)), override, OverrideSection.Homepage);
-    }
-    for (let override of overrides.license) {
-        overrideMatch(packages.find(getPackageFn(override)), override, OverrideSection.License);
-    }
-}
-function applyOverrides(packages, overrides) {
-    findOverrides(packages, overrides, (pack, override, overrideSection) => {
-        if (!pack)
-            return;
-        switch (overrideSection) {
-            case OverrideSection.Homepage: {
-                pack.homepage = override.new;
-                return;
-            }
-            case OverrideSection.License: {
-                pack.license = override.new;
-                return;
-            }
-        }
-    });
-}
-exports.applyOverrides = applyOverrides;
-function findUnusedOverrides(packages, overrides) {
-    const unusedOverrides = {
-        license: [],
-        homepage: []
-    };
-    findOverrides(packages, overrides, (pack, override, overrideSection) => {
-        if (pack)
-            return;
-        switch (overrideSection) {
-            case OverrideSection.Homepage: {
-                unusedOverrides.homepage.push(override);
-                return;
-            }
-            case OverrideSection.License: {
-                unusedOverrides.license.push(override);
-                return;
-            }
-        }
-    });
-    return unusedOverrides;
-}
-exports.findUnusedOverrides = findUnusedOverrides;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUnusedOverrides = exports.applyOverrides = void 0;
+var OverrideSection;
+(function (OverrideSection) {
+    OverrideSection[OverrideSection["Homepage"] = 0] = "Homepage";
+    OverrideSection[OverrideSection["License"] = 1] = "License";
+})(OverrideSection || (OverrideSection = {}));
+function findOverrides(packages, overrides, overrideMatch) {
+    const getPackageFn = (o) => (pack) => {
+        return o.name === pack.name && o.version == pack.version;
+    };
+    for (let override of overrides.homepage) {
+        overrideMatch(packages.find(getPackageFn(override)), override, OverrideSection.Homepage);
+    }
+    for (let override of overrides.license) {
+        overrideMatch(packages.find(getPackageFn(override)), override, OverrideSection.License);
+    }
+}
+function applyOverrides(packages, overrides) {
+    findOverrides(packages, overrides, (pack, override, overrideSection) => {
+        if (!pack)
+            return;
+        switch (overrideSection) {
+            case OverrideSection.Homepage: {
+                pack.homepage = override.new;
+                return;
+            }
+            case OverrideSection.License: {
+                pack.license = override.new;
+                return;
+            }
+        }
+    });
+}
+exports.applyOverrides = applyOverrides;
+function findUnusedOverrides(packages, overrides) {
+    const unusedOverrides = {
+        license: [],
+        homepage: []
+    };
+    findOverrides(packages, overrides, (pack, override, overrideSection) => {
+        if (pack)
+            return;
+        switch (overrideSection) {
+            case OverrideSection.Homepage: {
+                unusedOverrides.homepage.push(override);
+                return;
+            }
+            case OverrideSection.License: {
+                unusedOverrides.license.push(override);
+                return;
+            }
+        }
+    });
+    return unusedOverrides;
+}
+exports.findUnusedOverrides = findUnusedOverrides;

package/lib/section.d.ts

@@ -1,14 +1,14 @@
-import { PackageContent } from './package_infos';
-export declare type LicenseMeta<T> = {
-    licenseName: string;
-    meta: T;
-};
-export declare type LicenseSection = {
-    licenseName: string;
-    libraries: PackageContent[];
-};
-export declare type LicenseSectionWithMeta<T> = {
-    meta?: T;
-} & LicenseSection;
-export declare function gatherLicenseSections(packageInfos: PackageContent[]): LicenseSection[];
-export declare function attachMeta<T>(l: LicenseSection[], m: LicenseMeta<T>[]): LicenseSectionWithMeta<T>[];
+import { PackageContent } from './package_infos';
+export type LicenseMeta<T> = {
+    licenseName: string;
+    meta: T;
+};
+export type LicenseSection = {
+    licenseName: string;
+    libraries: PackageContent[];
+};
+export type LicenseSectionWithMeta<T> = {
+    meta?: T;
+} & LicenseSection;
+export declare function gatherLicenseSections(packageInfos: PackageContent[]): LicenseSection[];
+export declare function attachMeta<T>(l: LicenseSection[], m: LicenseMeta<T>[]): LicenseSectionWithMeta<T>[];

package/lib/section.js

@@ -1,37 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function orderByLicense(packageInfos) {
-    const getLicenseStr = (a) => {
-        return a === undefined ? "" : a;
-    };
-    packageInfos.sort((a, b) => {
-        return getLicenseStr(a.license).localeCompare(getLicenseStr(b.license));
-    });
-}
-function gatherLicenseSections(packageInfos) {
-    orderByLicense(packageInfos);
-    const licenseSections = [];
-    for (let info of packageInfos) {
-        if (licenseSections.length === 0 || licenseSections[licenseSections.length - 1].licenseName !== info.license) {
-            licenseSections.push({
-                licenseName: info.license,
-                libraries: []
-            });
-        }
-        licenseSections[licenseSections.length - 1].libraries.push(info);
-    }
-    for (let license of licenseSections) {
-        license.libraries.sort((a, b) => {
-            return a.name.localeCompare(b.name);
-        });
-    }
-    return licenseSections;
-}
-exports.gatherLicenseSections = gatherLicenseSections;
-function attachMeta(l, m) {
-    return l.map((ls) => {
-        const licenseMeta = m.find((lm) => lm.licenseName === ls.licenseName);
-        return Object.assign({}, ls, licenseMeta);
-    });
-}
-exports.attachMeta = attachMeta;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachMeta = exports.gatherLicenseSections = void 0;
+function orderByLicense(packageInfos) {
+    const getLicenseStr = (a) => {
+        return a === undefined ? "" : a;
+    };
+    packageInfos.sort((a, b) => {
+        return getLicenseStr(a.license).localeCompare(getLicenseStr(b.license));
+    });
+}
+function gatherLicenseSections(packageInfos) {
+    orderByLicense(packageInfos);
+    const licenseSections = [];
+    for (let info of packageInfos) {
+        if (licenseSections.length === 0 || licenseSections[licenseSections.length - 1].licenseName !== info.license) {
+            licenseSections.push({
+                licenseName: info.license,
+                libraries: []
+            });
+        }
+        licenseSections[licenseSections.length - 1].libraries.push(info);
+    }
+    for (let license of licenseSections) {
+        license.libraries.sort((a, b) => {
+            return a.name.localeCompare(b.name);
+        });
+    }
+    return licenseSections;
+}
+exports.gatherLicenseSections = gatherLicenseSections;
+function attachMeta(l, m) {
+    return l.map((ls) => {
+        const licenseMeta = m.find((lm) => lm.licenseName === ls.licenseName);
+        return Object.assign(Object.assign({}, ls), licenseMeta);
+    });
+}
+exports.attachMeta = attachMeta;

package/package.json

@@ -1,33 +1,36 @@
-{
-  "name": "@volumegraphics/license-info-collector",
-  "version": "2.0.0",
-  "description": "Collects license information of all dependencies of your project",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "scripts": {
-    "prepublishOnly": "tsc",
-    "build": "tsc"
-  },
-  "author": "Volume Graphics GmbH",
-  "homepage": "https://www.volumegraphics.com/",
-  "license": "MIT",
-  "keywords": [
-    "license",
-    "licensing",
-    "collect",
-    "dependencies"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/VolumeGraphics/license-info-collector.git"
-  },
-  "devDependencies": {
-    "@types/node": "^10.1.0",
-    "@types/semver": "^5.5.0",
-    "ts-node": "^6.0.3",
-    "typescript": "^2.8.3"
-  },
-  "dependencies": {
-    "semver": "^5.5.0"
-  }
-}
+{
+  "name": "@volumegraphics/license-info-collector",
+  "version": "3.0.3",
+  "description": "Collects license information of all dependencies of your project",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "prepublishOnly": "tsc",
+    "build": "tsc"
+  },
+  "author": "Volume Graphics GmbH",
+  "homepage": "https://www.volumegraphics.com/",
+  "license": "MIT",
+  "keywords": [
+    "license",
+    "licensing",
+    "collect",
+    "dependencies"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VolumeGraphics/license-info-collector.git"
+  },
+  "devDependencies": {
+    "@types/node": "^10.17.60",
+    "@types/semver": "^5.5.0",
+    "ts-node": "^6.2.0",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "semver": "^5.7.2"
+  }
+}

package/lib/test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/test.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-const fs = require("fs");
-function authorToString(author) {
-    if (typeof author !== "string") {
-        return author.name;
-    }
-    return author;
-}
-function repositoryToString(repo) {
-    if (typeof repo !== "string") {
-        return repo.url;
-    }
-    return repo;
-}
-function copyrightInfo(p) {
-    if (p.author) {
-        return authorToString(p.author);
-    }
-    else if (p.homepage) {
-        return p.homepage;
-    }
-    else if (p.repository) {
-        return repositoryToString(p.repository);
-    }
-    return undefined;
-}
-function evaluateCopyRightInfo(p) {
-    return copyrightInfo(p) !== undefined;
-}
-function toHtml(productPackageJsonFile, productNodeModulesPaths, licenseFilesPath, configFilePath) {
-    let packageInfos = _1.collectPackageInfos(productPackageJsonFile, productNodeModulesPaths, false);
-    const config = JSON.parse(fs.readFileSync(configFilePath).toString());
-    _1.applyOverrides(packageInfos, config.overrides);
-    const invalidOverrides = _1.findUnusedOverrides(packageInfos, config.overrides);
-    const invalidInfo = _1.findInvalidPackageContent(packageInfos, config.licenses, evaluateCopyRightInfo);
-    const missingPackages = _1.findMissingPackages(packageInfos, false);
-    if (invalidOverrides.homepage.length != 0
-        || invalidOverrides.license.length != 0
-        || missingPackages.length != 0) {
-    }
-    const licenseSections = _1.gatherLicenseSections(packageInfos, config.licenses, licenseFilesPath);
-}
-console.log(toHtml("example/package.json", ["example/node_modules"], "example/license_files", "example/config.json"));