@callstack/licenses 0.2.2 → 0.3.0

package/build/node/utils/index.js

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiscUtils = exports.PackageUtils = void 0;
+exports.PackageUtils = __importStar(require("./packageUtils"));
+exports.MiscUtils = __importStar(require("./miscUtils"));

package/build/{utils → node/utils}/packageUtils.d.ts

@@ -1,9 +1,9 @@
-import type { LicenseObj, ScanPackageOptionsFactory } from '../types';
+import type { License, ScanPackageOptionsFactory } from '../../types';
 export declare function getPackageJsonPath(dependency: string, root?: string): string | null;
 export declare function resolvePackageJsonFromEntry(dependency: string): string | null;
 export declare function findPackageRoot(entryPath: string): string | undefined;
 export declare function normalizePackageName(packageName: string): string;
-export declare function prepareAboutLibrariesLicenseField(license: LicenseObj): string;
+export declare function prepareAboutLibrariesLicenseField(license: License): string;
 export declare function parseAuthorField(json: {
     author: string | {
         name: string;

package/build/{utils → node/utils}/packageUtils.js

@@ -14,8 +14,8 @@ exports.parseLicenseField = parseLicenseField;
 exports.parseRepositoryFieldToUrl = parseRepositoryFieldToUrl;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const repositoryUtils_1 = require("../../utils/repositoryUtils");
 const miscUtils_1 = require("./miscUtils");
-const repositoryUtils_1 = require("./repositoryUtils");
 function getPackageJsonPath(dependency, root) {
     const rootsToSearch = [
         ...(root ? [root] : []), // provided for purpose of nested node_modules resolution inside a package dir, in a subdirectory inside the root node_modules dir

package/build/types/AggregatedLicensesMapping.d.ts

@@ -0,0 +1,6 @@
+import type { License } from './License';
+/**
+ * Mapping from package keys in format `<package-name>@<package-version>` to license objects.
+ * @see {@link License}
+ */
+export type AggregatedLicensesMapping = Record<string, License>;

package/build/types/{LicenseObj.d.ts → License.d.ts}

@@ -1,6 +1,7 @@
 import type { DependencyType } from './DependencyType';
+import type { ParentPackageInfo } from './ParentPackageInfo';
 import type { ScanPackageCallContext } from './ScanPackageCallContext';
-export type LicenseObj = {
+export type License = {
     /** Package name */
     name: string;
     /** Package author */
@@ -21,4 +22,9 @@ export type LicenseObj = {
     dependencyType: DependencyType;
     /** The required version specified in package.json */
     requiredVersion: string;
-} & Pick<ScanPackageCallContext, 'parentPackageName' | 'parentPackageRequiredVersion' | 'parentPackageResolvedVersion'>;
+    /**
+     * The name(s) of the package(s) that introduced the package as a dependency (of any type);
+     * empty array if the package is a dependency of the root package
+     */
+    parentPackages: ParentPackageInfo[];
+} & Pick<ScanPackageCallContext, 'parentPackageRequiredVersion' | 'parentPackageResolvedVersion'>;

package/build/types/LicenseAnalysisResult.d.ts

@@ -0,0 +1,5 @@
+import type { LicenseCategory } from '../licenses/LicenseCategory';
+import type { LicenseStats } from './LicenseStats';
+export interface LicenseAnalysisResult extends LicenseStats {
+    categorizedLicenses: Record<string, LicenseCategory>;
+}

package/build/types/LicenseAnalysisResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/LicenseStats.d.ts

@@ -0,0 +1,28 @@
+import type { LicenseCategory } from '../licenses/LicenseCategory';
+export interface LicenseStats {
+    /**
+     * Total number of packages
+     */
+    total: number;
+    /**
+     * Mapping of license category to count of packages in that category
+     */
+    byCategory: Record<LicenseCategory, number>;
+    /**
+     * Mapping of license name to count of packages with that license
+     */
+    byLicense: Record<string, number>;
+    /**
+     * Information about the presence of different license categories
+     */
+    categoriesPresence: {
+        hasAnyUnknown: boolean;
+        hasAnyWeakCopyleft: boolean;
+        hasAnyStrongCopyleft: boolean;
+        hasAllPermissive: boolean;
+    };
+    /**
+     * Description of the graph state based on the license categories
+     */
+    description: string;
+}

package/build/types/LicenseStats.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/ParentPackageInfo.d.ts

@@ -0,0 +1,14 @@
+export type ParentPackageInfo = {
+    /**
+     * The name of the package
+     */
+    name: string;
+    /**
+     * The required version, as specified in package.json
+     */
+    requiredVersion: string;
+    /**
+     * The resolved version, as specified in package.json
+     */
+    resolvedVersion: string;
+};

package/build/types/ParentPackageInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/index.d.ts

@@ -1,5 +1,5 @@
-export * from './LicenseObj';
-export * from './AggregatedLicensesObj';
+export * from './License';
+export * from './AggregatedLicensesMapping';
 export * from './AboutLibrariesLibraryJsonPayload';
 export * from './AboutLibrariesLicenseJsonPayload';
 export * from './LicensePlistPayload';
@@ -7,3 +7,6 @@ export * from './AboutLibrariesLikePackageInfo';
 export * from './ScanPackageOptions';
 export * from './ScanPackageCallContext';
 export * from './DependencyType';
+export * from './ParentPackageInfo';
+export * from './LicenseAnalysisResult';
+export * from './LicenseStats';

package/build/types/index.js

@@ -14,8 +14,8 @@ 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("./LicenseObj"), exports);
-__exportStar(require("./AggregatedLicensesObj"), exports);
+__exportStar(require("./License"), exports);
+__exportStar(require("./AggregatedLicensesMapping"), exports);
 __exportStar(require("./AboutLibrariesLibraryJsonPayload"), exports);
 __exportStar(require("./AboutLibrariesLicenseJsonPayload"), exports);
 __exportStar(require("./LicensePlistPayload"), exports);
@@ -23,3 +23,6 @@ __exportStar(require("./AboutLibrariesLikePackageInfo"), exports);
 __exportStar(require("./ScanPackageOptions"), exports);
 __exportStar(require("./ScanPackageCallContext"), exports);
 __exportStar(require("./DependencyType"), exports);
+__exportStar(require("./ParentPackageInfo"), exports);
+__exportStar(require("./LicenseAnalysisResult"), exports);
+__exportStar(require("./LicenseStats"), exports);

package/build/utils/index.d.ts

@@ -1,4 +1,2 @@
-export * as PackageUtils from './packageUtils';
-export * as MiscUtils from './miscUtils';
 export * as RepositoryUtils from './repositoryUtils';
 export * as YamlUtils from './yamlUtils';

package/build/utils/index.js

@@ -33,8 +33,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YamlUtils = exports.RepositoryUtils = exports.MiscUtils = exports.PackageUtils = void 0;
-exports.PackageUtils = __importStar(require("./packageUtils"));
-exports.MiscUtils = __importStar(require("./miscUtils"));
+exports.YamlUtils = exports.RepositoryUtils = void 0;
 exports.RepositoryUtils = __importStar(require("./repositoryUtils"));
 exports.YamlUtils = __importStar(require("./yamlUtils"));

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "@callstack/licenses",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "API package that exposes functionalities for programmatic scanning of licenses in Node.js projects.",
-  "main": "build/index",
-  "module": "build/index",
-  "types": "build/index.d.ts",
+  "browser": "./build/index.js",
+  "main": "./build/node/index.js",
   "exports": {
     ".": {
-      "source": "./src/index.ts",
-      "types": "./build/index.d.ts",
-      "default": "./build/index.js"
+      "import": {
+        "source": "./src/index.ts",
+        "types": "./build/index.d.ts",
+        "default": "./build/index.js"
+      },
+      "require": {
+        "source": "./src/node/index.ts",
+        "types": "./build/node/index.d.ts",
+        "default": "./build/node/index.js"
+      }
+    },
+    "./node": {
+      "import": {
+        "source": "./src/node/index.ts",
+        "types": "./build/node/index.d.ts",
+        "default": "./build/node/index.js"
+      }
     },
     "./package.json": "./package.json"
   },

package/src/constants/index.ts

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

package/src/constants/licenses.ts

@@ -0,0 +1,58 @@
+/**
+ * https://spdx.org/licenses
+ */
+
+export const 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',
+]);
+
+export const 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',
+]);
+
+export const STRONG_COPYLEFT_LICENSES_LOWERCASE = new Set(
+  Array.from(STRONG_COPYLEFT_LICENSES).map((license) => license.toLowerCase()),
+);
+
+export const WEAK_COPYLEFT_LICENSES_LOWERCASE = new Set(
+  Array.from(WEAK_COPYLEFT_LICENSES).map((license) => license.toLowerCase()),
+);

package/src/index.ts

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

package/src/licenses/LicenseCategory.ts

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

package/src/licenses/descriptions.ts

@@ -0,0 +1,56 @@
+import { LicenseCategory } from './LicenseCategory';
+
+export function getGraphStateInfo(stats: Record<LicenseCategory, number>) {
+  const hasAnyUnknown = stats[LicenseCategory.UNKNOWN] > 0;
+  const hasAnyWeakCopyleft = stats[LicenseCategory.WEAK_COPYLEFT] > 0;
+  const hasAnyStrongCopyleft = stats[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.PERMISSIVE]} detected licenses are permissive`;
+  }
+
+  if (hasAnyUnknown) {
+    description += `, ${hasAllPermissive ? 'but ' : ''}${stats[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
+ */
+export function getLicenseCategoryDescription(category: LicenseCategory): string {
+  switch (category) {
+    case LicenseCategory.STRONG_COPYLEFT:
+      return 'Strong Copyleft';
+
+    case LicenseCategory.WEAK_COPYLEFT:
+      return 'Weak Copyleft';
+
+    case LicenseCategory.PERMISSIVE:
+      return 'Permissive';
+
+    case LicenseCategory.UNKNOWN:
+      return 'Unknown';
+  }
+}

package/src/licenses/index.ts

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

package/src/licenses/licenseAnalysis.ts

@@ -0,0 +1,78 @@
+import { STRONG_COPYLEFT_LICENSES_LOWERCASE, WEAK_COPYLEFT_LICENSES_LOWERCASE } from '../constants/licenses';
+import type { AggregatedLicensesMapping } from '../types';
+import type { LicenseAnalysisResult } from '../types/LicenseAnalysisResult';
+
+import { LicenseCategory } from './LicenseCategory';
+import { getGraphStateInfo } from './descriptions';
+
+/**
+ * Categorizes a license based on its copyleft characteristics.
+ * @param licenseType the license type
+ * @returns the license category
+ */
+export function categorizeLicense(licenseType?: string): LicenseCategory {
+  if (!licenseType || licenseType === 'unknown') {
+    return LicenseCategory.UNKNOWN;
+  }
+
+  // check for strong copyleft licenses
+  if (STRONG_COPYLEFT_LICENSES_LOWERCASE.has(licenseType.toLowerCase())) {
+    return LicenseCategory.STRONG_COPYLEFT;
+  }
+
+  // check for weak copyleft licenses
+  if (WEAK_COPYLEFT_LICENSES_LOWERCASE.has(licenseType.toLowerCase())) {
+    return LicenseCategory.WEAK_COPYLEFT;
+  }
+
+  // everything else is considered permissive
+  return LicenseCategory.PERMISSIVE;
+}
+
+/**
+ * Analyzes license data and returns comprehensive statistics.
+ * @param report the licenses report data
+ * @returns the license analysis result
+ */
+export function analyzeLicenses(report: AggregatedLicensesMapping): LicenseAnalysisResult {
+  const byCategory: Record<LicenseCategory, number> = {
+    [LicenseCategory.STRONG_COPYLEFT]: 0,
+    [LicenseCategory.WEAK_COPYLEFT]: 0,
+    [LicenseCategory.PERMISSIVE]: 0,
+    [LicenseCategory.UNKNOWN]: 0,
+  };
+
+  const byLicense: Record<string, number> = {};
+  const categorizedLicenses: Record<string, LicenseCategory> = {};
+
+  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 } = getGraphStateInfo(byCategory);
+
+  return {
+    total,
+    byCategory,
+    byLicense,
+    description,
+    categoriesPresence,
+    categorizedLicenses,
+  };
+}

package/src/{common.ts → node/common.ts}

@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 
 import glob from 'glob';
 
@@ -7,13 +7,16 @@ import type {
   AboutLibrariesLibraryJsonPayload,
   AboutLibrariesLicenseJsonPayload,
   AboutLibrariesLikePackageInfo,
-  AggregatedLicensesObj,
+  AggregatedLicensesMapping,
   DependencyType,
   LicensePlistPayload,
+  ParentPackageInfo,
   ScanPackageCallContext,
   ScanPackageOptionsFactory,
-} from './types';
-import { PackageUtils, YamlUtils } from './utils';
+} from '../types';
+import { YamlUtils } from '../utils';
+
+import { PackageUtils } from './utils';
 
 type InternalScanGroupSpecifier = { packages: [depName: string, depVersion: string][]; dependencyType: DependencyType };
 
@@ -32,7 +35,7 @@ function scanPackage(
   packageName: string,
   requiredVersion: string,
   processedPackages: Set<string>,
-  result: AggregatedLicensesObj,
+  result: AggregatedLicensesMapping,
   scanOptionsFactory: ScanPackageOptionsFactory = PackageUtils.legacyDefaultScanPackageOptionsFactory,
   {
     parentPackageRoot,
@@ -83,21 +86,37 @@ function scanPackage(
 
       const resolvedVersionPackageKey = `${packageName}@${localPackageJson.version}`;
 
-      result[resolvedVersionPackageKey] = {
-        name: packageName,
-        author: PackageUtils.parseAuthorField(localPackageJson),
-        content: licenseFiles?.[0] ? fs.readFileSync(licenseFiles[0], { encoding: 'utf-8' }) : undefined,
-        file: licenseFiles?.[0] ? licenseFiles[0] : undefined,
-        description: localPackageJson.description,
-        type: PackageUtils.parseLicenseField(localPackageJson),
-        url: PackageUtils.parseRepositoryFieldToUrl(localPackageJson),
-        version: localPackageJson.version,
-        requiredVersion,
-        parentPackageName,
-        parentPackageRequiredVersion,
-        parentPackageResolvedVersion,
-        dependencyType,
-      };
+      let parentPackageInfo: ParentPackageInfo | undefined;
+      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: PackageUtils.parseAuthorField(localPackageJson),
+          content: licenseFiles?.[0] ? fs.readFileSync(licenseFiles[0], { encoding: 'utf-8' }) : undefined,
+          file: licenseFiles?.[0] ? licenseFiles[0] : undefined,
+          description: localPackageJson.description,
+          type: PackageUtils.parseLicenseField(localPackageJson),
+          url: PackageUtils.parseRepositoryFieldToUrl(localPackageJson),
+          version: localPackageJson.version,
+          requiredVersion,
+          parentPackages: parentPackageInfo ? [parentPackageInfo] : [],
+          parentPackageRequiredVersion,
+          parentPackageResolvedVersion,
+          dependencyType,
+        };
+      }
     }
 
     const dependencies: MaybeDependencyMapping = localPackageJson.dependencies;
@@ -161,12 +180,12 @@ type MaybeDependencyMapping = DependencyMapping | undefined;
 export function scanDependencies(
   appPackageJsonPath: string,
   scanOptionsFactory: ScanPackageOptionsFactory = PackageUtils.legacyDefaultScanPackageOptionsFactory,
-): AggregatedLicensesObj {
+): AggregatedLicensesMapping {
   const appPackageJson = require(path.resolve(appPackageJsonPath));
   const dependencies: MaybeDependencyMapping = appPackageJson.dependencies;
   const devDependencies: MaybeDependencyMapping = appPackageJson.devDependencies;
   const optionalDependencies: MaybeDependencyMapping = appPackageJson.optionalDependencies;
-  const result: AggregatedLicensesObj = {};
+  const result: AggregatedLicensesMapping = {};
   const processedPackages = new Set<string>();
 
   const rootScanOptions = scanOptionsFactory({ isRoot: true, isWorkspacePackage: false });
@@ -205,24 +224,22 @@ export function scanDependencies(
  * @param iosProjectPath Path to the iOS project directory
  * @see {@link writeLicensePlistNPMOutput}
  */
-export function generateLicensePlistNPMOutput(licenses: AggregatedLicensesObj, iosProjectPath: string): string {
+export function generateLicensePlistNPMOutput(licenses: AggregatedLicensesMapping, iosProjectPath: string): string {
   const renames: Record<string, string> = {};
-  const licenseEntries = Object.entries(licenses).map(([packageKey, licenseObj]) => {
+  const licenseEntries = Object.entries(licenses).map(([packageKey, license]) => {
     const normalizedPackageNameWithVersion = PackageUtils.normalizePackageName(packageKey);
 
-    if (licenseObj.name !== normalizedPackageNameWithVersion) {
-      renames[normalizedPackageNameWithVersion] = licenseObj.name;
+    if (license.name !== normalizedPackageNameWithVersion) {
+      renames[normalizedPackageNameWithVersion] = license.name;
     }
 
-    const relativeLicenseFile = licenseObj.file ? path.relative(iosProjectPath, licenseObj.file) : undefined;
+    const relativeLicenseFile = license.file ? path.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' }),
     } as LicensePlistPayload;
   });
 
@@ -261,7 +278,7 @@ export function generateLicensePlistNPMOutput(licenses: AggregatedLicensesObj, i
  * @see {@link generateLicensePlistNPMOutput}
  */
 export function writeLicensePlistNPMOutput(
-  licenses: AggregatedLicensesObj,
+  licenses: AggregatedLicensesMapping,
   iosProjectPath: string,
   plistLikeOutput?: string,
 ) {
@@ -281,20 +298,20 @@ export function writeLicensePlistNPMOutput(
  * @returns Array of AboutLibrariesLikePackage objects, each representing a NPM dependency
  * @see {@link writeAboutLibrariesNPMOutput}
  */
-export function generateAboutLibrariesNPMOutput(licenses: AggregatedLicensesObj): AboutLibrariesLikePackageInfo[] {
+export function generateAboutLibrariesNPMOutput(licenses: AggregatedLicensesMapping): AboutLibrariesLikePackageInfo[] {
   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: [PackageUtils.prepareAboutLibrariesLicenseField(licenseObj)],
-        name: licenseObj.name,
+        artifactVersion: license.version,
+        content: license.content ?? '',
+        description: license.description ?? '',
+        developers: [{ name: license.author ?? '', organisationUrl: '' }],
+        licenses: [PackageUtils.prepareAboutLibrariesLicenseField(license)],
+        name: license.name,
         tag: '',
-        type: licenseObj.type,
+        type: license.type,
         uniqueId: PackageUtils.normalizePackageName(packageKey),
-        website: licenseObj.url,
+        website: license.url,
       };
     })
     .map((jsonPayload) => {
@@ -344,7 +361,7 @@ export function generateAboutLibrariesNPMOutput(licenses: AggregatedLicensesObj)
  * @see {@link generateAboutLibrariesNPMOutput}
  */
 export function writeAboutLibrariesNPMOutput(
-  licenses: AggregatedLicensesObj,
+  licenses: AggregatedLicensesMapping,
   androidProjectPath: string,
   aboutLibrariesLikeOutput?: AboutLibrariesLikePackageInfo[],
 ) {

package/src/node/index.ts

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

package/src/node/utils/index.ts

@@ -0,0 +1,2 @@
+export * as PackageUtils from './packageUtils';
+export * as MiscUtils from './miscUtils';