@callstack/licenses 0.2.1

package/build/types/ScanPackageOptions.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Scan options for controlling which dependencies of a package are scanned
+ */
+export type ScanPackageOptions = {
+    /** Whether transitive dependencies should be scanned */
+    includeTransitiveDependencies: boolean;
+    /** Whether to include devDependencies in the scan; includeTransitiveDependencies option applies */
+    includeDevDependencies: boolean;
+    /** Whether to include optionalDependencies in the scan; includeTransitiveDependencies option applies */
+    includeOptionalDependencies: boolean;
+};
+/**
+ * Information about a single package to be scanned
+ */
+export type ScanPackageOptionsFactoryPackageInfo = {
+    /** `true` if the analyzed package.json is the root of the scanned project */
+    isRoot: boolean;
+    /** `true` if the analyzed package.json is a dependency related to the project via a `workspace:...` dependency specifier */
+    isWorkspacePackage: boolean;
+};
+/**
+ * Factory to create a filter for scan options for dependencies of a given package
+ */
+export type ScanPackageOptionsFactory = (packageInfo: ScanPackageOptionsFactoryPackageInfo) => ScanPackageOptions;

package/build/types/ScanPackageOptions.js

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

package/build/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './LicenseObj';
+export * from './AggregatedLicensesObj';
+export * from './AboutLibrariesLibraryJsonPayload';
+export * from './AboutLibrariesLicenseJsonPayload';
+export * from './LicensePlistPayload';
+export * from './AboutLibrariesLikePackageInfo';
+export * from './ScanPackageOptions';
+export * from './ScanPackageCallContext';
+export * from './DependencyType';

package/build/types/index.js

@@ -0,0 +1,25 @@
+"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("./LicenseObj"), exports);
+__exportStar(require("./AggregatedLicensesObj"), exports);
+__exportStar(require("./AboutLibrariesLibraryJsonPayload"), exports);
+__exportStar(require("./AboutLibrariesLicenseJsonPayload"), exports);
+__exportStar(require("./LicensePlistPayload"), exports);
+__exportStar(require("./AboutLibrariesLikePackageInfo"), exports);
+__exportStar(require("./ScanPackageOptions"), exports);
+__exportStar(require("./ScanPackageCallContext"), exports);
+__exportStar(require("./DependencyType"), exports);

package/build/utils/index.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,40 @@
+"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.YamlUtils = exports.RepositoryUtils = exports.MiscUtils = exports.PackageUtils = void 0;
+exports.PackageUtils = __importStar(require("./packageUtils"));
+exports.MiscUtils = __importStar(require("./miscUtils"));
+exports.RepositoryUtils = __importStar(require("./repositoryUtils"));
+exports.YamlUtils = __importStar(require("./yamlUtils"));

package/build/utils/miscUtils.d.ts

@@ -0,0 +1,6 @@
+export declare function sha512(text: string): string;
+export declare function compareObjects(a: unknown, b: unknown): boolean;
+/**
+ * Makes a deep-check between array items and provided object, returns true if array has provided object.
+ */
+export declare function arrayIncludesObject(array?: unknown[], object?: unknown): boolean | undefined;

package/build/utils/miscUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha512 = sha512;
+exports.compareObjects = compareObjects;
+exports.arrayIncludesObject = arrayIncludesObject;
+const crypto_1 = __importDefault(require("crypto"));
+function sha512(text) {
+    return crypto_1.default.createHash('sha512').update(text).digest('hex');
+}
+function compareObjects(a, b) {
+    if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') {
+        return a === b;
+    }
+    const entriesA = Object.entries(a);
+    const entriesB = Object.entries(b);
+    return (entriesA.length === entriesB.length &&
+        entriesA
+            .map(([keyA, valueA]) => {
+            const entry = entriesB.find(([keyB]) => keyA === keyB);
+            if (!entry) {
+                return valueA === entry;
+            }
+            const [, valueB] = entry;
+            return compareObjects(valueA, valueB);
+        })
+            .reduce((acc, curr) => acc && curr, true));
+}
+/**
+ * Makes a deep-check between array items and provided object, returns true if array has provided object.
+ */
+function arrayIncludesObject(array, object) {
+    if (!Array.isArray(array)) {
+        return;
+    }
+    return array.map((item) => compareObjects(item, object)).reduce((acc, curr) => acc || curr, false);
+}

package/build/utils/packageUtils.d.ts

@@ -0,0 +1,26 @@
+import type { LicenseObj, 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 parseAuthorField(json: {
+    author: string | {
+        name: string;
+    };
+}): string | undefined;
+export declare function parseLicenseField(json: {
+    license: string | {
+        type: string;
+    };
+}): string | undefined;
+export declare function parseRepositoryFieldToUrl(json: {
+    repository: string | {
+        url?: string;
+    };
+}): string | undefined;
+/**
+ * Default value consistent with legacy behaviour assumptions for the scan package options factory
+ * used so as not to introduce breaking API changes to the shared package
+ */
+export declare const legacyDefaultScanPackageOptionsFactory: ScanPackageOptionsFactory;

package/build/utils/packageUtils.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyDefaultScanPackageOptionsFactory = void 0;
+exports.getPackageJsonPath = getPackageJsonPath;
+exports.resolvePackageJsonFromEntry = resolvePackageJsonFromEntry;
+exports.findPackageRoot = findPackageRoot;
+exports.normalizePackageName = normalizePackageName;
+exports.prepareAboutLibrariesLicenseField = prepareAboutLibrariesLicenseField;
+exports.parseAuthorField = parseAuthorField;
+exports.parseLicenseField = parseLicenseField;
+exports.parseRepositoryFieldToUrl = parseRepositoryFieldToUrl;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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
+        process.cwd(), // fallback - root node_modules directory home
+    ]; // in order of priority (left-to-right)
+    try {
+        return require.resolve(`${dependency}/package.json`, { paths: rootsToSearch });
+    }
+    catch (error) {
+        for (const root of rootsToSearch) {
+            const pkgJsonInNodeModules = path_1.default.join(root, 'node_modules', dependency, 'package.json');
+            if (fs_1.default.existsSync(pkgJsonInNodeModules)) {
+                return pkgJsonInNodeModules;
+            }
+        }
+        return resolvePackageJsonFromEntry(dependency); // final fallback
+    }
+}
+function resolvePackageJsonFromEntry(dependency) {
+    try {
+        const entryPath = require.resolve(dependency);
+        const packageDir = findPackageRoot(entryPath);
+        if (!packageDir)
+            return null;
+        const packageJsonPath = path_1.default.join(packageDir, 'package.json');
+        return fs_1.default.existsSync(packageJsonPath) ? packageJsonPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findPackageRoot(entryPath) {
+    let currentDir = path_1.default.dirname(entryPath);
+    while (currentDir !== path_1.default.dirname(currentDir)) {
+        if (fs_1.default.existsSync(path_1.default.join(currentDir, 'package.json')))
+            return currentDir;
+        currentDir = path_1.default.dirname(currentDir);
+    }
+}
+function normalizePackageName(packageName) {
+    return packageName.replace('/', '_');
+}
+function prepareAboutLibrariesLicenseField(license) {
+    if (!license.type) {
+        return '';
+    }
+    return `${license.type}_${(0, miscUtils_1.sha512)(license.content ?? license.type)}`;
+}
+function parseAuthorField(json) {
+    if (typeof json.author === 'object' && typeof json.author.name === 'string') {
+        return json.author.name;
+    }
+    if (typeof json.author === 'string') {
+        return json.author;
+    }
+}
+function parseLicenseField(json) {
+    if (typeof json.license === 'object' && typeof json.license.type === 'string') {
+        return json.license.type;
+    }
+    if (typeof json.license === 'string') {
+        return json.license;
+    }
+}
+function parseRepositoryFieldToUrl(json) {
+    if (typeof json.repository === 'object' && typeof json.repository.url === 'string') {
+        return (0, repositoryUtils_1.normalizeRepositoryUrl)(json.repository.url);
+    }
+    if (typeof json.repository === 'string') {
+        return (0, repositoryUtils_1.normalizeRepositoryUrl)(json.repository);
+    }
+}
+/**
+ * Default value consistent with legacy behaviour assumptions for the scan package options factory
+ * used so as not to introduce breaking API changes to the shared package
+ */
+const legacyDefaultScanPackageOptionsFactory = () => ({
+    includeTransitiveDependencies: true,
+    includeDevDependencies: false,
+    includeOptionalDependencies: true,
+});
+exports.legacyDefaultScanPackageOptionsFactory = legacyDefaultScanPackageOptionsFactory;

package/build/utils/repositoryUtils.d.ts

@@ -0,0 +1 @@
+export declare function normalizeRepositoryUrl(url: string): string;

package/build/utils/repositoryUtils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRepositoryUrl = normalizeRepositoryUrl;
+function normalizeRepositoryUrl(url) {
+    return (url
+        .replace('git+ssh://git@', 'git://')
+        .replace('.git', '')
+        .replace('git+https://github.com', 'https://github.com')
+        .replace('.git', '')
+        .replace('git://github.com', 'https://github.com')
+        .replace('.git', '')
+        .replace('git@github.com:', 'https://github.com/')
+        .replace('.git', '')
+        .replace('github:', 'https://github.com/')
+        .replace('.git', '')
+        // below: handling of edge case: git+ssh://git@github.com:X/Y.git -> https://github.com:X/Y
+        .replace('github.com:', 'github.com/'));
+}

package/build/utils/yamlUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function needsQuoting(value: string): boolean;
+export declare function formatYamlKey(key: string): string;
+export declare function formatYamlValue(value: string, indent: number): string;
+export declare function toYaml(obj: unknown, indent?: number): string;

package/build/utils/yamlUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsQuoting = needsQuoting;
+exports.formatYamlKey = formatYamlKey;
+exports.formatYamlValue = formatYamlValue;
+exports.toYaml = toYaml;
+function needsQuoting(value) {
+    return (value === '' || // empty string
+        /^[#:>|-]/.test(value) || // starts with special char
+        /^['"{}[\],&*#?|<>=!%@`]/.test(value) || // starts with indicator chars
+        /^[\s]|[\s]$/.test(value) || // has leading/trailing whitespace
+        /^[\d.+-]/.test(value) || // looks like a number/bool/null
+        /[\n"'\\\s]/.test(value) || // contains newlines, quotes, backslash, or spaces
+        /^(true|false|yes|no|null|on|off)$/i.test(value) // is a YAML keyword
+    );
+}
+function formatYamlKey(key) {
+    return /[@/_.]/.test(key) ? `"${key}"` : key;
+}
+function formatYamlValue(value, indent) {
+    if (value.includes('\n')) {
+        const indentedValue = value
+            .split('\n')
+            .map((line) => `${' '.repeat(indent)}${line}`)
+            .join('\n');
+        // Return the block indicator on the same line as the content
+        return `|${indentedValue ? '\n' + indentedValue : ''}`;
+    }
+    if (needsQuoting(value)) {
+        if (value.includes("'") && !value.includes('"')) {
+            return `"${value.replace(/["\\]/g, '\\$&')}"`;
+        }
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    return value;
+}
+function toYaml(obj, indent = 0) {
+    const spaces = ' '.repeat(indent);
+    if (obj == null)
+        return '';
+    if (Array.isArray(obj)) {
+        return obj.map((item) => `${spaces}- ${toYaml(item, indent + 2).trimStart()}`).join('\n');
+    }
+    if (typeof obj === 'object') {
+        return Object.entries(obj)
+            .filter(([, v]) => v != null)
+            .map(([key, value]) => {
+            const formattedKey = formatYamlKey(key);
+            const formattedValue = toYaml(value, indent + 2);
+            if (Array.isArray(value)) {
+                return `${spaces}${formattedKey}:\n${formattedValue}`;
+            }
+            if (typeof value === 'object' && value !== null) {
+                return `${spaces}${formattedKey}:\n${formattedValue}`;
+            }
+            if (typeof value === 'string' && value.includes('\n')) {
+                return `${spaces}${formattedKey}: ${formattedValue}`;
+            }
+            return `${spaces}${formattedKey}: ${formattedValue}`;
+        })
+            .join('\n');
+    }
+    return typeof obj === 'string' ? formatYamlValue(obj, indent) : String(obj);
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@callstack/licenses",
+  "version": "0.2.1",
+  "description": "Shared code for all packages",
+  "main": "build/index",
+  "module": "build/index",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "rimraf build",
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc --watch -p tsconfig.json"
+  },
+  "keywords": [
+    "nodejs",
+    "oss",
+    "license",
+    "acknowledgements",
+    "license-management"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/callstackincubator/react-native-legal.git",
+    "directory": "packages/shared"
+  },
+  "author": "Mateusz Mędrek <luigimario1913@gmail.com> (https://github.com/mateusz1913)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/callstackincubator/react-native-legal.git/issues"
+  },
+  "homepage": "https://callstackincubator.github.io/react-native-legal/",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "glob": "^7.1.3"
+  },
+  "devDependencies": {
+    "@babel/core": "7.27.4",
+    "@babel/preset-env": "7.27.2",
+    "@babel/preset-typescript": "7.27.1",
+    "@types/glob": "^8.1.0",
+    "@types/jest": "^29.5.5",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  }
+}