@callstack/licenses 0.2.2 → 0.3.1

package/README.md

@@ -30,10 +30,10 @@ You can use `@callstack/licenses` programmatically in your Node.js applications.
 
 ```typescript
 import {
+  Types,
   generateAboutLibrariesNPMOutput,
   generateLicensePlistNPMOutput,
   scanDependencies,
-  Types,
 } from '@callstack/licenses';
 import * as md from 'ts-markdown-builder';
 

package/build/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './licenses';

package/build/constants/index.js

@@ -0,0 +1,17 @@
+"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("./licenses"), exports);

package/build/constants/licenses.d.ts

@@ -0,0 +1,7 @@
+/**
+ * https://spdx.org/licenses
+ */
+export declare const STRONG_COPYLEFT_LICENSES: Set<string>;
+export declare const WEAK_COPYLEFT_LICENSES: Set<string>;
+export declare const STRONG_COPYLEFT_LICENSES_LOWERCASE: Set<string>;
+export declare const WEAK_COPYLEFT_LICENSES_LOWERCASE: Set<string>;

package/build/constants/licenses.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * https://spdx.org/licenses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEAK_COPYLEFT_LICENSES_LOWERCASE = exports.STRONG_COPYLEFT_LICENSES_LOWERCASE = exports.WEAK_COPYLEFT_LICENSES = exports.STRONG_COPYLEFT_LICENSES = void 0;
+exports.STRONG_COPYLEFT_LICENSES = new Set([
+    'GPL',
+    'GPL-1.0',
+    'GPL-1.0+',
+    'GPL-2.0',
+    'GPL-2.0+',
+    'GPL-2.0-only',
+    'GPL-2.0-or-later',
+    'GPL-3.0',
+    'GPL-3.0+',
+    'GPL-3.0-only',
+    'GPL-3.0-or-later',
+    'AGPL-3.0',
+    'AGPL-3.0-only',
+    'AGPL-3.0-or-later',
+    'EUPL-1.0',
+    'EUPL-1.1',
+    'EUPL-1.2',
+    'OSL-1.0',
+    'OSL-1.1',
+    'OSL-2.0',
+    'OSL-2.1',
+    'OSL-3.0',
+]);
+exports.WEAK_COPYLEFT_LICENSES = new Set([
+    'CDDL-1.0',
+    'CDDL-1.1',
+    'EPL-1.0',
+    'EPL-2.0',
+    'LGPL',
+    'LGPL-2.0',
+    'LGPL-2.0+',
+    'LGPL-2.0-only',
+    'LGPL-2.0-or-later',
+    'LGPL-2.1',
+    'LGPL-2.1+',
+    'LGPL-2.1-only',
+    'LGPL-2.1-or-later',
+    'LGPL-3.0',
+    'LGPL-3.0+',
+    'LGPL-3.0-only',
+    'LGPL-3.0-or-later',
+    'MPL-1.1',
+    'MPL-2.0',
+]);
+exports.STRONG_COPYLEFT_LICENSES_LOWERCASE = new Set(Array.from(exports.STRONG_COPYLEFT_LICENSES).map((license) => license.toLowerCase()));
+exports.WEAK_COPYLEFT_LICENSES_LOWERCASE = new Set(Array.from(exports.WEAK_COPYLEFT_LICENSES).map((license) => license.toLowerCase()));

package/build/index.d.ts

@@ -1,3 +1,4 @@
-export * from './common';
 export * as Types from './types';
 export * from './utils';
+export * from './licenses';
+export * from './constants';

package/build/index.js

@@ -15,9 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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);
-};
 var __importStar = (this && this.__importStar) || (function () {
     var ownKeys = function(o) {
         ownKeys = Object.getOwnPropertyNames || function (o) {
@@ -35,8 +32,12 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+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 });
 exports.Types = void 0;
-__exportStar(require("./common"), exports);
 exports.Types = __importStar(require("./types"));
 __exportStar(require("./utils"), exports);
+__exportStar(require("./licenses"), exports);
+__exportStar(require("./constants"), exports);

package/build/licenses/LicenseCategory.d.ts

@@ -0,0 +1,6 @@
+export declare enum LicenseCategory {
+    STRONG_COPYLEFT = "strong copyleft",
+    WEAK_COPYLEFT = "weak copyleft",
+    PERMISSIVE = "permissive",
+    UNKNOWN = "unknown"
+}

package/build/licenses/LicenseCategory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseCategory = void 0;
+var LicenseCategory;
+(function (LicenseCategory) {
+    LicenseCategory["STRONG_COPYLEFT"] = "strong copyleft";
+    LicenseCategory["WEAK_COPYLEFT"] = "weak copyleft";
+    LicenseCategory["PERMISSIVE"] = "permissive";
+    LicenseCategory["UNKNOWN"] = "unknown";
+})(LicenseCategory || (exports.LicenseCategory = LicenseCategory = {}));

package/build/licenses/descriptions.d.ts

@@ -0,0 +1,16 @@
+import { LicenseCategory } from './LicenseCategory';
+export declare function getGraphStateInfo(stats: Record<LicenseCategory, number>): {
+    description: string;
+    categoriesPresence: {
+        hasAnyUnknown: boolean;
+        hasAnyWeakCopyleft: boolean;
+        hasAnyStrongCopyleft: boolean;
+        hasAllPermissive: boolean;
+    };
+};
+/**
+ * Gets a human-readable description of the license category
+ * @param category the license category
+ * @returns the human-readable description of the license category
+ */
+export declare function getLicenseCategoryDescription(category: LicenseCategory): string;

package/build/licenses/descriptions.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphStateInfo = getGraphStateInfo;
+exports.getLicenseCategoryDescription = getLicenseCategoryDescription;
+const LicenseCategory_1 = require("./LicenseCategory");
+function getGraphStateInfo(stats) {
+    const hasAnyUnknown = stats[LicenseCategory_1.LicenseCategory.UNKNOWN] > 0;
+    const hasAnyWeakCopyleft = stats[LicenseCategory_1.LicenseCategory.WEAK_COPYLEFT] > 0;
+    const hasAnyStrongCopyleft = stats[LicenseCategory_1.LicenseCategory.STRONG_COPYLEFT] > 0;
+    const hasAllPermissive = !hasAnyUnknown && !hasAnyStrongCopyleft && !hasAnyWeakCopyleft;
+    let description = '';
+    if (hasAnyWeakCopyleft || hasAnyStrongCopyleft) {
+        description = `Some detected licenses are ${[
+            hasAnyWeakCopyleft ? 'weak' : null,
+            hasAnyStrongCopyleft ? 'strong' : null,
+        ]
+            .filter((x) => !!x)
+            .map((x) => `${x}-`)
+            .join(' and ')}copyleft`;
+    }
+    else {
+        description = `${hasAllPermissive ? 'All' : stats[LicenseCategory_1.LicenseCategory.PERMISSIVE]} detected licenses are permissive`;
+    }
+    if (hasAnyUnknown) {
+        description += `, ${hasAllPermissive ? 'but ' : ''}${stats[LicenseCategory_1.LicenseCategory.UNKNOWN]} are unknown.`;
+    }
+    return {
+        description,
+        categoriesPresence: {
+            hasAnyUnknown,
+            hasAnyWeakCopyleft,
+            hasAnyStrongCopyleft,
+            hasAllPermissive,
+        },
+    };
+}
+/**
+ * Gets a human-readable description of the license category
+ * @param category the license category
+ * @returns the human-readable description of the license category
+ */
+function getLicenseCategoryDescription(category) {
+    switch (category) {
+        case LicenseCategory_1.LicenseCategory.STRONG_COPYLEFT:
+            return 'Strong Copyleft';
+        case LicenseCategory_1.LicenseCategory.WEAK_COPYLEFT:
+            return 'Weak Copyleft';
+        case LicenseCategory_1.LicenseCategory.PERMISSIVE:
+            return 'Permissive';
+        case LicenseCategory_1.LicenseCategory.UNKNOWN:
+            return 'Unknown';
+    }
+}

package/build/licenses/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LicenseCategory';
+export * from './descriptions';
+export * from './licenseAnalysis';

package/build/licenses/index.js

@@ -0,0 +1,19 @@
+"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("./LicenseCategory"), exports);
+__exportStar(require("./descriptions"), exports);
+__exportStar(require("./licenseAnalysis"), exports);

package/build/licenses/licenseAnalysis.d.ts

@@ -0,0 +1,15 @@
+import type { AggregatedLicensesMapping } from '../types';
+import type { LicenseAnalysisResult } from '../types/LicenseAnalysisResult';
+import { LicenseCategory } from './LicenseCategory';
+/**
+ * Categorizes a license based on its copyleft characteristics.
+ * @param licenseType the license type
+ * @returns the license category
+ */
+export declare function categorizeLicense(licenseType?: string): LicenseCategory;
+/**
+ * Analyzes license data and returns comprehensive statistics.
+ * @param report the licenses report data
+ * @returns the license analysis result
+ */
+export declare function analyzeLicenses(report: AggregatedLicensesMapping): LicenseAnalysisResult;

package/build/licenses/licenseAnalysis.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorizeLicense = categorizeLicense;
+exports.analyzeLicenses = analyzeLicenses;
+const licenses_1 = require("../constants/licenses");
+const LicenseCategory_1 = require("./LicenseCategory");
+const descriptions_1 = require("./descriptions");
+/**
+ * Categorizes a license based on its copyleft characteristics.
+ * @param licenseType the license type
+ * @returns the license category
+ */
+function categorizeLicense(licenseType) {
+    if (!licenseType || licenseType === 'unknown') {
+        return LicenseCategory_1.LicenseCategory.UNKNOWN;
+    }
+    // check for strong copyleft licenses
+    if (licenses_1.STRONG_COPYLEFT_LICENSES_LOWERCASE.has(licenseType.toLowerCase())) {
+        return LicenseCategory_1.LicenseCategory.STRONG_COPYLEFT;
+    }
+    // check for weak copyleft licenses
+    if (licenses_1.WEAK_COPYLEFT_LICENSES_LOWERCASE.has(licenseType.toLowerCase())) {
+        return LicenseCategory_1.LicenseCategory.WEAK_COPYLEFT;
+    }
+    // everything else is considered permissive
+    return LicenseCategory_1.LicenseCategory.PERMISSIVE;
+}
+/**
+ * Analyzes license data and returns comprehensive statistics.
+ * @param report the licenses report data
+ * @returns the license analysis result
+ */
+function analyzeLicenses(report) {
+    const byCategory = {
+        [LicenseCategory_1.LicenseCategory.STRONG_COPYLEFT]: 0,
+        [LicenseCategory_1.LicenseCategory.WEAK_COPYLEFT]: 0,
+        [LicenseCategory_1.LicenseCategory.PERMISSIVE]: 0,
+        [LicenseCategory_1.LicenseCategory.UNKNOWN]: 0,
+    };
+    const byLicense = {};
+    const categorizedLicenses = {};
+    Object.entries(report).forEach(([packageKey, license]) => {
+        const licenseType = license.type;
+        const category = categorizeLicense(licenseType);
+        // stats by category
+        byCategory[category]++;
+        // stats by specific license
+        {
+            const key = licenseType ?? 'unknown';
+            byLicense[key] = (byLicense[key] ?? 0) + 1;
+        }
+        // memoization for lookup
+        categorizedLicenses[packageKey] = category;
+    });
+    const total = Object.keys(report).length;
+    const { categoriesPresence, description } = (0, descriptions_1.getGraphStateInfo)(byCategory);
+    return {
+        total,
+        byCategory,
+        byLicense,
+        description,
+        categoriesPresence,
+        categorizedLicenses,
+    };
+}

package/build/{common.d.ts → node/common.d.ts}

@@ -1,4 +1,4 @@
-import type { AboutLibrariesLikePackageInfo, AggregatedLicensesObj, ScanPackageOptionsFactory } from './types';
+import type { AboutLibrariesLikePackageInfo, AggregatedLicensesMapping, ScanPackageOptionsFactory } from '../types';
 /**
  * Scans `package.json` and searches for all packages under `dependencies` field. Supports monorepo projects.
  *
@@ -6,7 +6,7 @@ import type { AboutLibrariesLikePackageInfo, AggregatedLicensesObj, ScanPackageO
  * @param scanOptionsFactory Factory function to create scan options for dependencies; defaults to {@link PackageUtils.legacyDefaultScanPackageOptionsFactory}
  * @returns Aggregated licenses object containing all scanned dependencies and their license information
  */
-export declare function scanDependencies(appPackageJsonPath: string, scanOptionsFactory?: ScanPackageOptionsFactory): AggregatedLicensesObj;
+export declare function scanDependencies(appPackageJsonPath: string, scanOptionsFactory?: ScanPackageOptionsFactory): AggregatedLicensesMapping;
 /**
  * Generates LicensePlist-compatible metadata for NPM dependencies as a YAML string.
  *
@@ -16,7 +16,7 @@ export declare function scanDependencies(appPackageJsonPath: string, scanOptions
  * @param iosProjectPath Path to the iOS project directory
  * @see {@link writeLicensePlistNPMOutput}
  */
-export declare function generateLicensePlistNPMOutput(licenses: AggregatedLicensesObj, iosProjectPath: string): string;
+export declare function generateLicensePlistNPMOutput(licenses: AggregatedLicensesMapping, iosProjectPath: string): string;
 /**
  * Writes LicensePlist-compatible metadata for NPM dependencies to a file
  *
@@ -37,7 +37,7 @@ export declare function generateLicensePlistNPMOutput(licenses: AggregatedLicens
  * @param plistLikeOutput Optional pre-generated string output to use instead of generating it using `generateLicensePlistNPMOutput`
  * @see {@link generateLicensePlistNPMOutput}
  */
-export declare function writeLicensePlistNPMOutput(licenses: AggregatedLicensesObj, iosProjectPath: string, plistLikeOutput?: string): void;
+export declare function writeLicensePlistNPMOutput(licenses: AggregatedLicensesMapping, iosProjectPath: string, plistLikeOutput?: string): void;
 /**
  * Generates AboutLibraries-compatible metadata for NPM dependencies
  *
@@ -47,7 +47,7 @@ export declare function writeLicensePlistNPMOutput(licenses: AggregatedLicensesO
  * @returns Array of AboutLibrariesLikePackage objects, each representing a NPM dependency
  * @see {@link writeAboutLibrariesNPMOutput}
  */
-export declare function generateAboutLibrariesNPMOutput(licenses: AggregatedLicensesObj): AboutLibrariesLikePackageInfo[];
+export declare function generateAboutLibrariesNPMOutput(licenses: AggregatedLicensesMapping): AboutLibrariesLikePackageInfo[];
 /**
  * Generates AboutLibraries-compatible metadata for NPM dependencies
  *
@@ -68,4 +68,4 @@ export declare function generateAboutLibrariesNPMOutput(licenses: AggregatedLice
  * @param aboutLibrariesLikeOutput Optional pre-generated output to use instead of generating it using `generateAboutLibrariesNPMOutput`
  * @see {@link generateAboutLibrariesNPMOutput}
  */
-export declare function writeAboutLibrariesNPMOutput(licenses: AggregatedLicensesObj, androidProjectPath: string, aboutLibrariesLikeOutput?: AboutLibrariesLikePackageInfo[]): void;
+export declare function writeAboutLibrariesNPMOutput(licenses: AggregatedLicensesMapping, androidProjectPath: string, aboutLibrariesLikeOutput?: AboutLibrariesLikePackageInfo[]): void;

package/build/{common.js → node/common.js}

@@ -8,10 +8,11 @@ exports.generateLicensePlistNPMOutput = generateLicensePlistNPMOutput;
 exports.writeLicensePlistNPMOutput = writeLicensePlistNPMOutput;
 exports.generateAboutLibrariesNPMOutput = generateAboutLibrariesNPMOutput;
 exports.writeAboutLibrariesNPMOutput = writeAboutLibrariesNPMOutput;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const glob_1 = __importDefault(require("glob"));
-const utils_1 = require("./utils");
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
 /**
  * Scans a single package and its dependencies for license information
  *
@@ -23,7 +24,7 @@ const utils_1 = require("./utils");
  * @param isOptionalDependency Whether the package is an optional dependency, in which case a warning will not be logged if the corresponding package.json is not found; defaults to `false`
  * @param parentPackageRoot Optional path to the parent package root, has priority over default root to lock for dependencies in; used to discover different versions of the same package installed in nested node_modules, e.g. suppose `X@1`, `Y@1` where `Y@1` -> `X@2`; then, node_modules would have `X@1`, `Y@1` and `X@2` would be installed to `node_modules/Y/node_modules/X@2`
  */
-function scanPackage(packageName, requiredVersion, processedPackages, result, scanOptionsFactory = utils_1.PackageUtils.legacyDefaultScanPackageOptionsFactory, { parentPackageRoot, parentPackageName, dependencyType, parentPackageRequiredVersion, parentPackageResolvedVersion, }) {
+function scanPackage(packageName, requiredVersion, processedPackages, result, scanOptionsFactory = utils_2.PackageUtils.legacyDefaultScanPackageOptionsFactory, { parentPackageRoot, parentPackageName, dependencyType, parentPackageRequiredVersion, parentPackageResolvedVersion, }) {
     const requiredVersionPackageKey = `${packageName}@${requiredVersion}`;
     // Skip if already processed to avoid circular dependencies
     if (processedPackages.has(requiredVersionPackageKey)) {
@@ -35,7 +36,7 @@ function scanPackage(packageName, requiredVersion, processedPackages, result, sc
     }
     processedPackages.add(requiredVersionPackageKey);
     try {
-        const localPackageJsonPath = utils_1.PackageUtils.getPackageJsonPath(packageName, parentPackageRoot);
+        const localPackageJsonPath = utils_2.PackageUtils.getPackageJsonPath(packageName, parentPackageRoot);
         if (!localPackageJsonPath) {
             // do not warn if the package is an optional dependency, it's normal it may not be installed
             if (!dependencyType.toLowerCase().includes('optional')) {
@@ -43,31 +44,47 @@ function scanPackage(packageName, requiredVersion, processedPackages, result, sc
             }
             return;
         }
-        const localPackageJson = require(path_1.default.resolve(localPackageJsonPath));
+        const localPackageJson = require(node_path_1.default.resolve(localPackageJsonPath));
         if (localPackageJson.private !== true) {
             const licenseFiles = glob_1.default.sync('LICEN{S,C}E{.md,}', {
-                cwd: path_1.default.dirname(localPackageJsonPath),
+                cwd: node_path_1.default.dirname(localPackageJsonPath),
                 absolute: true,
                 nocase: true,
                 nodir: true,
                 ignore: '**/{__tests__,__fixtures__,__mocks__}/**',
             });
             const resolvedVersionPackageKey = `${packageName}@${localPackageJson.version}`;
-            result[resolvedVersionPackageKey] = {
-                name: packageName,
-                author: utils_1.PackageUtils.parseAuthorField(localPackageJson),
-                content: licenseFiles?.[0] ? fs_1.default.readFileSync(licenseFiles[0], { encoding: 'utf-8' }) : undefined,
-                file: licenseFiles?.[0] ? licenseFiles[0] : undefined,
-                description: localPackageJson.description,
-                type: utils_1.PackageUtils.parseLicenseField(localPackageJson),
-                url: utils_1.PackageUtils.parseRepositoryFieldToUrl(localPackageJson),
-                version: localPackageJson.version,
-                requiredVersion,
-                parentPackageName,
-                parentPackageRequiredVersion,
-                parentPackageResolvedVersion,
-                dependencyType,
-            };
+            let parentPackageInfo;
+            if (parentPackageName && parentPackageRequiredVersion && parentPackageResolvedVersion) {
+                parentPackageInfo = {
+                    name: parentPackageName,
+                    requiredVersion: parentPackageRequiredVersion,
+                    resolvedVersion: parentPackageResolvedVersion,
+                };
+            }
+            if (parentPackageInfo && resolvedVersionPackageKey in result) {
+                result[resolvedVersionPackageKey].parentPackages = [
+                    ...(result[resolvedVersionPackageKey].parentPackages ?? []),
+                    parentPackageInfo,
+                ];
+            }
+            else {
+                result[resolvedVersionPackageKey] = {
+                    name: packageName,
+                    author: utils_2.PackageUtils.parseAuthorField(localPackageJson),
+                    content: licenseFiles?.[0] ? node_fs_1.default.readFileSync(licenseFiles[0], { encoding: 'utf-8' }) : undefined,
+                    file: licenseFiles?.[0] ? licenseFiles[0] : undefined,
+                    description: localPackageJson.description,
+                    type: utils_2.PackageUtils.parseLicenseField(localPackageJson),
+                    url: utils_2.PackageUtils.parseRepositoryFieldToUrl(localPackageJson),
+                    version: localPackageJson.version,
+                    requiredVersion,
+                    parentPackages: parentPackageInfo ? [parentPackageInfo] : [],
+                    parentPackageRequiredVersion,
+                    parentPackageResolvedVersion,
+                    dependencyType,
+                };
+            }
         }
         const dependencies = localPackageJson.dependencies;
         const devDependencies = localPackageJson.devDependencies;
@@ -82,7 +99,7 @@ function scanPackage(packageName, requiredVersion, processedPackages, result, sc
             return;
         }
         // helper used for finding nested dependencies installed with different versions for a given package, see docstring of scanPackage
-        const currentPackageRoot = path_1.default.dirname(localPackageJsonPath);
+        const currentPackageRoot = node_path_1.default.dirname(localPackageJsonPath);
         for (const { dependencyType, packages } of [
             {
                 dependencyType: 'transitiveDependency',
@@ -119,8 +136,8 @@ function scanPackage(packageName, requiredVersion, processedPackages, result, sc
  * @param scanOptionsFactory Factory function to create scan options for dependencies; defaults to {@link PackageUtils.legacyDefaultScanPackageOptionsFactory}
  * @returns Aggregated licenses object containing all scanned dependencies and their license information
  */
-function scanDependencies(appPackageJsonPath, scanOptionsFactory = utils_1.PackageUtils.legacyDefaultScanPackageOptionsFactory) {
-    const appPackageJson = require(path_1.default.resolve(appPackageJsonPath));
+function scanDependencies(appPackageJsonPath, scanOptionsFactory = utils_2.PackageUtils.legacyDefaultScanPackageOptionsFactory) {
+    const appPackageJson = require(node_path_1.default.resolve(appPackageJsonPath));
     const dependencies = appPackageJson.dependencies;
     const devDependencies = appPackageJson.devDependencies;
     const optionalDependencies = appPackageJson.optionalDependencies;
@@ -149,6 +166,7 @@ function scanDependencies(appPackageJsonPath, scanOptionsFactory = utils_1.Packa
     }
     return result;
 }
+const PODSPEC_NAME_REGEX = /(Pod::Spec\.new\s+do\s+\|(?<specref>.*)\|).*(\k<specref>\.name\s+=\s+(?<quote>["'])(?<specname>[a-zA-Z0-9_\-@]+)\k<quote>)/;
 /**
  * Generates LicensePlist-compatible metadata for NPM dependencies as a YAML string.
  *
@@ -160,24 +178,54 @@ function scanDependencies(appPackageJsonPath, scanOptionsFactory = utils_1.Packa
  */
 function generateLicensePlistNPMOutput(licenses, iosProjectPath) {
     const renames = {};
-    const licenseEntries = Object.entries(licenses).map(([packageKey, licenseObj]) => {
-        const normalizedPackageNameWithVersion = utils_1.PackageUtils.normalizePackageName(packageKey);
-        if (licenseObj.name !== normalizedPackageNameWithVersion) {
-            renames[normalizedPackageNameWithVersion] = licenseObj.name;
+    const licenseEntries = Object.entries(licenses).map(([packageKey, license]) => {
+        const normalizedPackageNameWithVersion = utils_2.PackageUtils.normalizePackageName(packageKey);
+        if (license.name !== normalizedPackageNameWithVersion) {
+            renames[normalizedPackageNameWithVersion] = license.name;
         }
-        const relativeLicenseFile = licenseObj.file ? path_1.default.relative(iosProjectPath, licenseObj.file) : undefined;
+        const relativeLicenseFile = license.file ? node_path_1.default.relative(iosProjectPath, license.file) : undefined;
         return {
             name: normalizedPackageNameWithVersion,
-            version: licenseObj.version,
-            ...(licenseObj.url && { source: licenseObj.url }),
-            ...(licenseObj.file
-                ? { file: relativeLicenseFile }
-                : { body: licenseObj.content ?? licenseObj.type ?? 'UNKNOWN' }),
+            version: license.version,
+            ...(license.url && { source: license.url }),
+            ...(license.file ? { file: relativeLicenseFile } : { body: license.content ?? license.type ?? 'UNKNOWN' }),
         };
     });
+    const excludedEntries = Object.values(licenses).reduce((acc, license) => {
+        const packageName = license.name;
+        const localPackageJsonPath = utils_2.PackageUtils.getPackageJsonPath(packageName);
+        if (!localPackageJsonPath) {
+            return acc;
+        }
+        const podspecFiles = glob_1.default.sync('**.podspec', {
+            cwd: node_path_1.default.dirname(localPackageJsonPath),
+            absolute: true,
+            nocase: true,
+            nodir: true,
+            ignore: '**/{__tests__,__fixtures__,__mocks__}/**',
+        });
+        if (!podspecFiles) {
+            return acc;
+        }
+        const podspecEntries = podspecFiles.map((podspecFile) => {
+            const podspecContent = node_fs_1.default.readFileSync(podspecFile, { encoding: 'utf-8' });
+            const podspecContentShrinked = podspecContent.replace(/\n/g, ' ');
+            const { specname } = PODSPEC_NAME_REGEX.exec(podspecContentShrinked)?.groups ?? {};
+            return { name: specname ?? packageName };
+        });
+        return [...acc, ...podspecEntries];
+    }, []);
     const yamlDoc = {
         ...(Object.keys(renames).length > 0 && { rename: renames }),
         manual: licenseEntries,
+        /**
+         * Adding excludes to prevent duplicates - NPM packages with iOS Podspecs are already
+         * manually included in the `licenseEntries`. However License Plist is automatically including all
+         * the entries detected via Pods-<project-name>-acknowledgements.plist, which also
+         * includes the NPM package with iOS Podspecs - let's filter them out,
+         * so that only the manual NPM entries are displayed
+         */
+        exclude: excludedEntries,
     };
     const yamlContent = [
         '# BEGIN Generated NPM license entries',
@@ -210,7 +258,7 @@ function writeLicensePlistNPMOutput(licenses, iosProjectPath, plistLikeOutput) {
     if (!plistLikeOutput) {
         plistLikeOutput = generateLicensePlistNPMOutput(licenses, iosProjectPath);
     }
-    fs_1.default.writeFileSync(path_1.default.join(iosProjectPath, 'license_plist.yml'), plistLikeOutput, { encoding: 'utf-8' });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(iosProjectPath, 'license_plist.yml'), plistLikeOutput, { encoding: 'utf-8' });
 }
 /**
  * Generates AboutLibraries-compatible metadata for NPM dependencies
@@ -223,18 +271,18 @@ function writeLicensePlistNPMOutput(licenses, iosProjectPath, plistLikeOutput) {
  */
 function generateAboutLibrariesNPMOutput(licenses) {
     return Object.entries(licenses)
-        .map(([packageKey, licenseObj]) => {
+        .map(([packageKey, license]) => {
         return {
-            artifactVersion: licenseObj.version,
-            content: licenseObj.content ?? '',
-            description: licenseObj.description ?? '',
-            developers: [{ name: licenseObj.author ?? '', organisationUrl: '' }],
-            licenses: [utils_1.PackageUtils.prepareAboutLibrariesLicenseField(licenseObj)],
-            name: licenseObj.name,
+            artifactVersion: license.version,
+            content: license.content ?? '',
+            description: license.description ?? '',
+            developers: [{ name: license.author ?? '', organisationUrl: '' }],
+            licenses: [utils_2.PackageUtils.prepareAboutLibrariesLicenseField(license)],
+            name: license.name,
             tag: '',
-            type: licenseObj.type,
-            uniqueId: utils_1.PackageUtils.normalizePackageName(packageKey),
-            website: licenseObj.url,
+            type: license.type,
+            uniqueId: utils_2.PackageUtils.normalizePackageName(packageKey),
+            website: license.url,
         };
     })
         .map((jsonPayload) => {
@@ -282,27 +330,27 @@ function generateAboutLibrariesNPMOutput(licenses) {
  * @see {@link generateAboutLibrariesNPMOutput}
  */
 function writeAboutLibrariesNPMOutput(licenses, androidProjectPath, aboutLibrariesLikeOutput) {
-    const aboutLibrariesConfigDirPath = path_1.default.join(androidProjectPath, 'config');
-    const aboutLibrariesConfigLibrariesDirPath = path_1.default.join(aboutLibrariesConfigDirPath, 'libraries');
-    const aboutLibrariesConfigLicensesDirPath = path_1.default.join(aboutLibrariesConfigDirPath, 'licenses');
-    if (!fs_1.default.existsSync(aboutLibrariesConfigDirPath)) {
-        fs_1.default.mkdirSync(aboutLibrariesConfigDirPath);
+    const aboutLibrariesConfigDirPath = node_path_1.default.join(androidProjectPath, 'config');
+    const aboutLibrariesConfigLibrariesDirPath = node_path_1.default.join(aboutLibrariesConfigDirPath, 'libraries');
+    const aboutLibrariesConfigLicensesDirPath = node_path_1.default.join(aboutLibrariesConfigDirPath, 'licenses');
+    if (!node_fs_1.default.existsSync(aboutLibrariesConfigDirPath)) {
+        node_fs_1.default.mkdirSync(aboutLibrariesConfigDirPath);
     }
-    if (!fs_1.default.existsSync(aboutLibrariesConfigLibrariesDirPath)) {
-        fs_1.default.mkdirSync(aboutLibrariesConfigLibrariesDirPath);
+    if (!node_fs_1.default.existsSync(aboutLibrariesConfigLibrariesDirPath)) {
+        node_fs_1.default.mkdirSync(aboutLibrariesConfigLibrariesDirPath);
     }
-    if (!fs_1.default.existsSync(aboutLibrariesConfigLicensesDirPath)) {
-        fs_1.default.mkdirSync(aboutLibrariesConfigLicensesDirPath);
+    if (!node_fs_1.default.existsSync(aboutLibrariesConfigLicensesDirPath)) {
+        node_fs_1.default.mkdirSync(aboutLibrariesConfigLicensesDirPath);
     }
     if (!aboutLibrariesLikeOutput) {
         aboutLibrariesLikeOutput = generateAboutLibrariesNPMOutput(licenses);
     }
     aboutLibrariesLikeOutput.forEach(({ normalizedPackageNameWithVersion, libraryJsonPayload, licenseJsonPayload }) => {
-        const libraryJsonFilePath = path_1.default.join(aboutLibrariesConfigLibrariesDirPath, `${normalizedPackageNameWithVersion}.json`);
-        const licenseJsonFilePath = path_1.default.join(aboutLibrariesConfigLicensesDirPath, `${licenseJsonPayload.hash}.json`);
-        fs_1.default.writeFileSync(libraryJsonFilePath, JSON.stringify(libraryJsonPayload));
-        if (!fs_1.default.existsSync(licenseJsonFilePath)) {
-            fs_1.default.writeFileSync(licenseJsonFilePath, JSON.stringify(licenseJsonPayload));
+        const libraryJsonFilePath = node_path_1.default.join(aboutLibrariesConfigLibrariesDirPath, `${normalizedPackageNameWithVersion}.json`);
+        const licenseJsonFilePath = node_path_1.default.join(aboutLibrariesConfigLicensesDirPath, `${licenseJsonPayload.hash}.json`);
+        node_fs_1.default.writeFileSync(libraryJsonFilePath, JSON.stringify(libraryJsonPayload));
+        if (!node_fs_1.default.existsSync(licenseJsonFilePath)) {
+            node_fs_1.default.writeFileSync(licenseJsonFilePath, JSON.stringify(licenseJsonPayload));
         }
     });
 }

package/build/node/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './utils';
+export * from '../';