@callstack/licenses 0.2.1

package/src/utils/packageUtils.ts

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+
+import type { LicenseObj, ScanPackageOptionsFactory } from '../types';
+
+import { sha512 } from './miscUtils';
+import { normalizeRepositoryUrl } from './repositoryUtils';
+
+export function getPackageJsonPath(dependency: string, root?: string) {
+  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.join(root, 'node_modules', dependency, 'package.json');
+
+      if (fs.existsSync(pkgJsonInNodeModules)) {
+        return pkgJsonInNodeModules;
+      }
+    }
+
+    return resolvePackageJsonFromEntry(dependency); // final fallback
+  }
+}
+
+export function resolvePackageJsonFromEntry(dependency: string) {
+  try {
+    const entryPath = require.resolve(dependency);
+    const packageDir = findPackageRoot(entryPath);
+
+    if (!packageDir) return null;
+
+    const packageJsonPath = path.join(packageDir, 'package.json');
+
+    return fs.existsSync(packageJsonPath) ? packageJsonPath : null;
+  } catch {
+    return null;
+  }
+}
+
+export function findPackageRoot(entryPath: string) {
+  let currentDir = path.dirname(entryPath);
+  while (currentDir !== path.dirname(currentDir)) {
+    if (fs.existsSync(path.join(currentDir, 'package.json'))) return currentDir;
+    currentDir = path.dirname(currentDir);
+  }
+}
+
+export function normalizePackageName(packageName: string): string {
+  return packageName.replace('/', '_');
+}
+
+export function prepareAboutLibrariesLicenseField(license: LicenseObj) {
+  if (!license.type) {
+    return '';
+  }
+
+  return `${license.type}_${sha512(license.content ?? license.type)}`;
+}
+
+export function parseAuthorField(json: { author: string | { name: string } }) {
+  if (typeof json.author === 'object' && typeof json.author.name === 'string') {
+    return json.author.name;
+  }
+
+  if (typeof json.author === 'string') {
+    return json.author;
+  }
+}
+
+export function parseLicenseField(json: { license: string | { type: string } }) {
+  if (typeof json.license === 'object' && typeof json.license.type === 'string') {
+    return json.license.type;
+  }
+
+  if (typeof json.license === 'string') {
+    return json.license;
+  }
+}
+
+export function parseRepositoryFieldToUrl(json: { repository: string | { url?: string } }) {
+  if (typeof json.repository === 'object' && typeof json.repository.url === 'string') {
+    return normalizeRepositoryUrl(json.repository.url);
+  }
+
+  if (typeof json.repository === 'string') {
+    return 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
+ */
+export const legacyDefaultScanPackageOptionsFactory: ScanPackageOptionsFactory = () => ({
+  includeTransitiveDependencies: true,
+  includeDevDependencies: false,
+  includeOptionalDependencies: true,
+});

package/src/utils/repositoryUtils.ts

@@ -0,0 +1,17 @@
+export function normalizeRepositoryUrl(url: string) {
+  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/src/utils/yamlUtils.ts

@@ -0,0 +1,73 @@
+export function needsQuoting(value: string) {
+  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
+  );
+}
+
+export function formatYamlKey(key: string) {
+  return /[@/_.]/.test(key) ? `"${key}"` : key;
+}
+
+export function formatYamlValue(value: string, indent: number) {
+  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;
+}
+
+export function toYaml(obj: unknown, indent = 0): string {
+  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);
+}