@mcamdali/sdkbump 0.0.0-stage → 0.1.3

package/dist/detect/project.js

@@ -0,0 +1,220 @@
+// Recognises what kind of project a folder holds (native iOS, Flutter, React Native or Expo),
+// where its iOS app project is, and the versions that decide which fix applies.
+import { readdir, stat } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { readProjectText } from '../core/files.js';
+import { lowestAllowed } from '../core/versions.js';
+export class ProjectError extends Error {
+    name = 'ProjectError';
+}
+/** npm packages whose version or presence changes the advice. */
+export const WATCHED_PACKAGES = [
+    'react-native',
+    'expo',
+    'expo-build-properties',
+    'react-native-uiscene-bridge',
+    'react-native-xcode27',
+];
+const SKIPPED_FOLDERS = new Set([
+    'Pods',
+    'node_modules',
+    'build',
+    'DerivedData',
+    '.build',
+    'Carthage',
+    '.git',
+    '.symlinks',
+]);
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Parses `path` read with readProjectText; undefined when it is not read or is not JSON. */
+async function readJson(path, root) {
+    const text = await readProjectText(path, root);
+    if (text === null)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+const record = (value) => typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? value
+    : {};
+async function xcodeProjectsIn(folder) {
+    try {
+        const entries = await readdir(folder, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+            .map((entry) => join(folder, entry.name))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Native apps keep the .xcodeproj at the root or one folder down (App/App.xcodeproj). */
+async function nativeXcodeProjects(root) {
+    const top = await xcodeProjectsIn(root);
+    if (top.length > 0)
+        return top;
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const nested = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && !SKIPPED_FOLDERS.has(entry.name))
+        .map((entry) => xcodeProjectsIn(join(root, entry.name))));
+    return nested.flat().sort();
+}
+async function packageVersions(root, manifest) {
+    const declared = {
+        ...record(manifest.devDependencies),
+        ...record(manifest.dependencies),
+    };
+    const lock = record(record(await readJson(join(root, 'package-lock.json'), root)).packages);
+    const result = new Map();
+    for (const name of WATCHED_PACKAGES) {
+        const range = declared[name];
+        if (typeof range !== 'string')
+            continue;
+        // pnpm and workspaces link installed packages from outside the app folder.
+        const installed = record(await readJson(join(root, 'node_modules', name, 'package.json'), null));
+        const locked = record(lock[`node_modules/${name}`]);
+        if (typeof installed.version === 'string') {
+            result.set(name, {
+                name,
+                version: installed.version,
+                source: 'installed',
+                declared: range,
+            });
+        }
+        else if (typeof locked.version === 'string') {
+            result.set(name, {
+                name,
+                version: locked.version,
+                source: 'lockfile',
+                declared: range,
+            });
+        }
+        else {
+            result.set(name, {
+                name,
+                version: lowestAllowed(range),
+                source: 'declared',
+                declared: range,
+            });
+        }
+    }
+    return result;
+}
+function sceneSupportIn(plugins) {
+    if (!Array.isArray(plugins))
+        return false;
+    return plugins.some((plugin) => {
+        if (!Array.isArray(plugin) || plugin[0] !== 'expo-build-properties')
+            return false;
+        return record(record(plugin[1]).ios).enableSceneSupport === true;
+    });
+}
+async function expoConfig(root) {
+    for (const file of ['app.config.ts', 'app.config.js', 'app.config.mjs', 'app.config.cjs']) {
+        if (await exists(join(root, file)))
+            return { file, enableSceneSupport: null };
+    }
+    const json = await readJson(join(root, 'app.json'), root);
+    if (json === undefined)
+        return null;
+    const config = record(json);
+    const expo = 'expo' in config ? record(config.expo) : config;
+    return { file: 'app.json', enableSceneSupport: sceneSupportIn(expo.plugins) };
+}
+async function flutterInfo(root, pubspec) {
+    const fvmrc = record(await readJson(join(root, '.fvmrc'), root));
+    const fvmConfig = record(await readJson(join(root, '.fvm', 'fvm_config.json'), root));
+    const pinned = fvmrc.flutter ?? fvmConfig.flutterSdkVersion;
+    return {
+        version: typeof pinned === 'string' ? pinned : null,
+        migrationDisabled: /^\s+enable-uiscene-migration:\s*false\b/m.test(pubspec),
+        plugin: /^flutter:\s*\n(?:\s.*\n)*?\s+plugin:/m.test(pubspec),
+    };
+}
+/**
+ * Detects the project at `path`: a project folder, or an .xcodeproj folder for a native app.
+ * Throws ProjectError when there is nothing iOS to check.
+ */
+export async function detectProject(path) {
+    const target = resolve(path);
+    const info = await stat(target).catch(() => null);
+    if (!info)
+        throw new ProjectError(`${path} does not exist.`);
+    if (info.isDirectory() && target.endsWith('.xcodeproj')) {
+        return nativeProject(dirname(target), [target]);
+    }
+    if (!info.isDirectory())
+        throw new ProjectError(`${path} is not a folder.`);
+    const pubspec = await readProjectText(join(target, 'pubspec.yaml'), target);
+    if (pubspec !== null && /^\s+sdk:\s*flutter\b|^flutter:/m.test(pubspec)) {
+        const flutter = await flutterInfo(target, pubspec);
+        const iosDir = join(target, flutter.plugin ? join('example', 'ios') : 'ios');
+        const xcodeProjects = await xcodeProjectsIn(iosDir);
+        if (xcodeProjects.length === 0) {
+            throw new ProjectError(`${path} is a Flutter project without an iOS app (no ${iosDir}).`);
+        }
+        const name = /^name:\s*([\w-]+)/m.exec(pubspec)?.[1] ?? basename(target);
+        return {
+            root: target,
+            name,
+            ecosystem: 'flutter',
+            iosDir,
+            xcodeProjects,
+            packages: new Map(),
+            flutter,
+            expoConfig: null,
+        };
+    }
+    const manifest = record(await readJson(join(target, 'package.json'), target));
+    const packages = await packageVersions(target, manifest);
+    if (packages.has('expo') || packages.has('react-native')) {
+        const ecosystem = packages.has('expo') ? 'expo' : 'react-native';
+        const iosDir = join(target, 'ios');
+        const xcodeProjects = await xcodeProjectsIn(iosDir);
+        if (xcodeProjects.length === 0 && ecosystem === 'react-native') {
+            throw new ProjectError(`${path} is a React Native project without ios/.`);
+        }
+        return {
+            root: target,
+            name: typeof manifest.name === 'string' ? manifest.name : basename(target),
+            ecosystem,
+            iosDir: xcodeProjects.length > 0 ? iosDir : null,
+            xcodeProjects,
+            packages,
+            flutter: null,
+            expoConfig: ecosystem === 'expo' ? await expoConfig(target) : null,
+        };
+    }
+    const xcodeProjects = await nativeXcodeProjects(target);
+    if (xcodeProjects.length === 0) {
+        throw new ProjectError(`No iOS project found in ${path}: expected an .xcodeproj, a Flutter pubspec.yaml or a React Native or Expo package.json.`);
+    }
+    return nativeProject(target, xcodeProjects);
+}
+function nativeProject(root, xcodeProjects) {
+    const first = xcodeProjects[0] ?? root;
+    return {
+        root,
+        name: basename(first).replace(/\.xcodeproj$/, ''),
+        ecosystem: 'native',
+        iosDir: dirname(first),
+        xcodeProjects,
+        packages: new Map(),
+        flutter: null,
+        expoConfig: null,
+    };
+}
+//# sourceMappingURL=project.js.map

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Programmatic API. The CLI is a thin layer over these functions; the JSON report format is
+ * `schemaVersion` 0 and may change before 1.0.
+ *
+ * ```ts
+ * import { render, scan } from '@mcamdali/sdkbump';
+ *
+ * const report = await scan('path/to/app');
+ * console.log(report.verdict.text);
+ * console.log(render(report, 'markdown'));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { type AppModel, type AppTarget, collectApp, type InfoPlistFile, sceneManifest, } from './collect/app.js';
+export { type BuildSettings, generatesInfoPlist, infoPlistFiles, iosAppTargets, type OpenStepDict, type OpenStepValue, parseOpenStep, readXcodeProject, type XcodeProject, XcodeProjectError, type XcodeTarget, } from './collect/pbxproj.js';
+export { isDict, type ParsedPlist, type PlistDict, PlistError, type PlistValue, parsePlist, } from './collect/plist.js';
+export { blankCommentsAndStrings, indexSources, type Language, type SourceFile, type SourceIndex, type TypeRegion, } from './collect/sources.js';
+export { compareVersions, lowestAllowed } from './core/versions.js';
+export { detectProject, type Ecosystem, type ExpoConfig, type FlutterInfo, type PackageVersion, type Project, ProjectError, } from './detect/project.js';
+export { type FixAdvice, type Finding, type InfoPlistSource, type Lifecycle, type Mitigation, type Report, SCHEMA_VERSION, type TargetSummary, type Verdict, type VerdictCode, type VersionInfo, } from './model.js';
+export { FORMATS, type Format, render, type TtyOptions } from './report/index.js';
+export { checkApp, type RawFinding } from './rules/check.js';
+export { loadRuleData, parseRuleData, type RuleData, RuleDataError, RuleDataSchema, RULE_IDS, type RuleId, SEVERITIES, type Severity, } from './rules/data.js';
+export { type ScanOptions, scan, verdictOf } from './scan.js';
+export { VERSION } from './version.js';

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * Programmatic API. The CLI is a thin layer over these functions; the JSON report format is
+ * `schemaVersion` 0 and may change before 1.0.
+ *
+ * ```ts
+ * import { render, scan } from '@mcamdali/sdkbump';
+ *
+ * const report = await scan('path/to/app');
+ * console.log(report.verdict.text);
+ * console.log(render(report, 'markdown'));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { collectApp, sceneManifest, } from './collect/app.js';
+export { generatesInfoPlist, infoPlistFiles, iosAppTargets, parseOpenStep, readXcodeProject, XcodeProjectError, } from './collect/pbxproj.js';
+export { isDict, PlistError, parsePlist, } from './collect/plist.js';
+export { blankCommentsAndStrings, indexSources, } from './collect/sources.js';
+export { compareVersions, lowestAllowed } from './core/versions.js';
+export { detectProject, ProjectError, } from './detect/project.js';
+export { SCHEMA_VERSION, } from './model.js';
+export { FORMATS, render } from './report/index.js';
+export { checkApp } from './rules/check.js';
+export { loadRuleData, parseRuleData, RuleDataError, RuleDataSchema, RULE_IDS, SEVERITIES, } from './rules/data.js';
+export { scan, verdictOf } from './scan.js';
+export { VERSION } from './version.js';
+//# sourceMappingURL=index.js.map

package/dist/model.d.ts

@@ -0,0 +1,93 @@
+import type { Ecosystem, RuleId, RuleSource, Severity } from './rules/data.js';
+export declare const SCHEMA_VERSION = 0;
+/** A fix sdkbump suggests, from the `fixes` (or `workarounds`) of the rule data. */
+export interface FixAdvice {
+    id: string;
+    title: string;
+    steps: string[];
+    /** Link to the sdkbump guide for this kind of project. */
+    guide: string;
+    sources: RuleSource[];
+}
+/** A package in the project that works around the finding at run time. */
+export interface Mitigation {
+    package: string;
+    version: string | null;
+    summary: string;
+    limits: string[];
+    sources: RuleSource[];
+}
+export interface Finding {
+    rule: RuleId;
+    severity: Severity;
+    title: string;
+    message: string;
+    /** Path relative to the checked folder, with forward slashes. */
+    file: string;
+    line: number | null;
+    /** The app target the finding belongs to, when it is about one target. */
+    target: string | null;
+    /** Who owns the code: the app itself (dependencies are planned for 0.2). */
+    owner: 'app';
+    fix: FixAdvice | null;
+    alternatives: FixAdvice[];
+    /** Set when an installed workaround package handles this at run time. */
+    mitigation: Mitigation | null;
+    sources: RuleSource[];
+}
+/** `unknown`: sdkbump could not read the target's Info.plist, so it cannot tell. */
+export type Lifecycle = 'app-delegate' | 'scenes' | 'swiftui' | 'unknown';
+/**
+ * Where a target's Info.plist came from: `file` (read from INFOPLIST_FILE), `generated` (Xcode
+ * writes it from build settings) or `not-read` (named but not readable, or not named in the
+ * project file at all, as when an .xcconfig file sets it).
+ */
+export type InfoPlistSource = 'file' | 'generated' | 'not-read';
+export interface TargetSummary {
+    name: string;
+    lifecycle: Lifecycle;
+    /** Info.plist paths relative to the checked folder; empty unless infoPlistSource is `file`. */
+    infoPlists: string[];
+    infoPlistSource: InfoPlistSource;
+}
+export type VerdictCode = 'fails-to-launch' | 'launches-through-workaround' | 'unknown' | 'black-screen' | 'review' | 'no-findings';
+export interface Verdict {
+    code: VerdictCode;
+    text: string;
+}
+export interface VersionInfo {
+    name: string;
+    version: string | null;
+    /** installed, lockfile, declared (lowest version the range allows) or pinned (Flutter). */
+    source: string;
+}
+export interface Report {
+    schemaVersion: typeof SCHEMA_VERSION;
+    tool: {
+        name: 'sdkbump';
+        version: string;
+    };
+    rules: {
+        ruleSet: string;
+        dataVersion: string;
+        sdk: string;
+    };
+    project: {
+        /** The folder as given on the command line. */
+        path: string;
+        name: string;
+        ecosystem: Ecosystem;
+        versions: VersionInfo[];
+        targets: TargetSummary[];
+    };
+    verdict: Verdict;
+    findings: Finding[];
+    /** Things sdkbump could not check or that the reader should know. */
+    notes: string[];
+    summary: {
+        errors: number;
+        warnings: number;
+        info: number;
+        mitigated: number;
+    };
+}

package/dist/model.js

@@ -0,0 +1,2 @@
+export const SCHEMA_VERSION = 0;
+//# sourceMappingURL=model.js.map

package/dist/report/index.d.ts

@@ -0,0 +1,12 @@
+import type { Report } from '../model.js';
+import { type TtyOptions } from './tty.js';
+export declare const FORMATS: readonly ['tty', 'markdown', 'json'];
+export type Format = (typeof FORMATS)[number];
+export type { TtyOptions } from './tty.js';
+/**
+ * Renders a report as terminal text, Markdown or JSON (the report object as-is). This is the one
+ * way out for a report: every string in it has its control characters replaced here, whatever the
+ * format, before it reaches a terminal, a file or a pull request comment. JSON.stringify escapes
+ * only U+0000 to U+001F, so DEL and C1 controls would otherwise reach the JSON output raw.
+ */
+export declare function render(input: Report, format: Format, options?: TtyOptions): string;

package/dist/report/index.js

@@ -0,0 +1,22 @@
+import { renderMarkdown } from './markdown.js';
+import { withoutControlCharacters } from './text.js';
+import { renderTty } from './tty.js';
+export const FORMATS = ['tty', 'markdown', 'json'];
+/**
+ * Renders a report as terminal text, Markdown or JSON (the report object as-is). This is the one
+ * way out for a report: every string in it has its control characters replaced here, whatever the
+ * format, before it reaches a terminal, a file or a pull request comment. JSON.stringify escapes
+ * only U+0000 to U+001F, so DEL and C1 controls would otherwise reach the JSON output raw.
+ */
+export function render(input, format, options = { color: false }) {
+    const report = withoutControlCharacters(input);
+    switch (format) {
+        case 'tty':
+            return renderTty(report, options);
+        case 'markdown':
+            return renderMarkdown(report);
+        case 'json':
+            return `${JSON.stringify(report, null, 2)}\n`;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/report/markdown.d.ts

@@ -0,0 +1,2 @@
+import type { Report } from '../model.js';
+export declare function renderMarkdown(report: Report): string;

package/dist/report/markdown.js

@@ -0,0 +1,113 @@
+import { ECOSYSTEM_LABELS, GUIDES, INFO_PLIST_LABELS, LIFECYCLE_LABELS, plural, REPOSITORY_URL, } from './text.js';
+// Every character that can start Markdown or HTML markup inline: links and images ([ ] ( ) !),
+// emphasis (* _ ~), code (`), headings (#), HTML and autolinks (< >), entities (&), table cells
+// (|) and the backslash itself. A backslash in front makes each one plain text.
+const MARKUP = /[\\`*_[\]()#!<>|~&]/g;
+// GitHub turns bare URLs, www. addresses, e-mail addresses, @names and issue references (#1,
+// owner/repo#1, GH-1) into links or mentions without any markup, also right after a letter or an
+// underscore (x_https://...). A word joiner (U+2060, invisible) after the scheme, the www, the @,
+// the # or the GH stops that and leaves the text as it reads.
+const BARE_LINKS = /(?:https?|ftp)(?=:\/\/)|www(?=\.)|gh(?=-\d)|#(?=\d)|@/gi;
+// A list marker ('- ', '+ ', '12. ') or the start of a rule ('---') at the start of a line.
+const LIST_OR_RULE = /^(?:[-+](?=\s|$)|-(?=-))/;
+const ORDERED_LIST = /^(\d+)\.(?=\s|$)/;
+const WORD_JOINER = '\u2060';
+const BACKTICK_RUNS = /`+/g;
+/**
+ * Text from the checked project (names, versions, paths, plist values) as plain text in a
+ * paragraph, heading or table cell: no line breaks, markup or bare links. Notes and fix steps
+ * start a line, so a leading list marker or `---` is escaped too (it would open a list or a rule),
+ * and leading spaces are dropped (four of them would open a code block).
+ */
+const md = (text) => text
+    .replace(/\s*\n\s*/g, ' ')
+    .trimStart()
+    .replace(MARKUP, '\\$&')
+    .replace(LIST_OR_RULE, '\\$&')
+    .replace(ORDERED_LIST, '$1\\.')
+    .replace(BARE_LINKS, `$&${WORD_JOINER}`);
+/**
+ * Inline code that the value cannot close early: the fence is one backtick longer than the
+ * longest run of backticks in it, and a space pads a value that starts or ends with a backtick or
+ * a space (Markdown strips one space from each side).
+ */
+const code = (text) => {
+    const value = text.replace(/\n/g, ' ');
+    if (!value)
+        return '';
+    const longestRun = Math.max(0, ...(value.match(BACKTICK_RUNS) ?? []).map((run) => run.length));
+    const fence = '`'.repeat(longestRun + 1);
+    const padding = /^[ `]|[ `]$/.test(value) && value.trim() !== '' ? ' ' : '';
+    return `${fence}${padding}${value}${padding}${fence}`;
+};
+/** GitHub splits a table row on every `|` that has no backslash, inside code spans too. */
+const cell = (text) => text.replace(/\|/g, '\\|');
+const where = (item) => code(`${item.file}${item.line ? `:${item.line}` : ''}`);
+function fixLines(fix, heading) {
+    return [
+        `**${heading}: ${md(fix.title)}** ([guide](${fix.guide}))`,
+        '',
+        ...fix.steps.map((step, index) => `${index + 1}. ${md(step)}`),
+        '',
+    ];
+}
+export function renderMarkdown(report) {
+    const { project, rules, summary } = report;
+    const out = [
+        `## sdkbump: ${md(project.name)} (${ECOSYSTEM_LABELS[project.ecosystem]})`,
+        '',
+        `**${md(report.verdict.text)}**`,
+        '',
+    ];
+    const facts = [
+        ...project.targets.map((target) => {
+            const plists = target.infoPlistSource === 'file'
+                ? target.infoPlists.map(code).join(', ')
+                : INFO_PLIST_LABELS[target.infoPlistSource];
+            return `Target ${code(target.name)}: ${LIFECYCLE_LABELS[target.lifecycle]} (${plists})`;
+        }),
+        ...project.versions.map((version) => `${code(version.name)} ${md(version.version ?? 'unknown')} (${md(version.source)})`),
+    ];
+    if (facts.length)
+        out.push(...facts.map((fact) => `- ${fact}`), '');
+    if (report.findings.length > 0) {
+        out.push('| Rule | Severity | Where | Finding |', '| --- | --- | --- | --- |');
+        for (const item of report.findings) {
+            const severity = item.mitigation
+                ? `${item.severity} (handled by ${md(item.mitigation.package)})`
+                : item.severity;
+            out.push(`| ${item.rule} | ${severity} | ${cell(where(item))} | ${md(item.title)} |`);
+        }
+        out.push('', '<details><summary>What each finding means and how to fix it</summary>', '');
+        const printed = new Set();
+        for (const item of report.findings) {
+            out.push(`### ${item.rule}: ${md(item.title)}`, '', `${where(item)}: ${md(item.message)}`, '');
+            if (item.mitigation) {
+                const { mitigation } = item;
+                out.push(`Handled at run time by ${code(mitigation.package)}${mitigation.version ? ` ${md(mitigation.version)}` : ''}. ${md(mitigation.summary)} Limits: ${md(mitigation.limits.join(' '))}`, '');
+            }
+            [item.fix, ...item.alternatives]
+                .filter((fix) => fix !== null)
+                .forEach((fix, index) => {
+                const heading = index === 0 ? 'Fix' : 'Or';
+                if (printed.has(fix.id))
+                    out.push(`**${heading}: ${md(fix.title)}** (steps above)`, '');
+                else
+                    out.push(...fixLines(fix, heading));
+                printed.add(fix.id);
+            });
+            out.push(`Sources: ${item.sources.map((source) => `[${md(source.title)}](${source.url})`).join(', ')}`, '');
+        }
+        out.push('</details>', '');
+    }
+    for (const note of report.notes)
+        out.push(`> ${md(note)}`, '');
+    const counts = [plural(summary.errors, 'error'), plural(summary.warnings, 'warning')];
+    if (summary.info)
+        counts.push(`${summary.info} info`);
+    if (summary.mitigated)
+        counts.push(`${summary.mitigated} handled by a workaround`);
+    out.push(`${counts.join(', ')}. Guide: [${ECOSYSTEM_LABELS[project.ecosystem]}](${GUIDES[project.ecosystem]}).`, '', `<sub>[sdkbump](${REPOSITORY_URL}) ${report.tool.version}, rules ${rules.ruleSet}@${rules.dataVersion} (${md(rules.sdk)}). Static checks; they do not build or run the app.</sub>`);
+    return `${out.join('\n')}\n`;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/report/text.d.ts

@@ -0,0 +1,27 @@
+import type { Ecosystem } from '../rules/data.js';
+export declare const REPOSITORY_URL = "https://github.com/muhittincamdali/sdkbump";
+/** The guide for each kind of project, linked at the end of every report. */
+export declare const GUIDES: Record<Ecosystem, string>;
+export declare const ECOSYSTEM_LABELS: Record<Ecosystem, string>;
+export declare const LIFECYCLE_LABELS: {
+    readonly 'app-delegate': 'app delegate life cycle';
+    readonly scenes: 'scene life cycle';
+    readonly swiftui: 'SwiftUI App (scenes)';
+    readonly unknown: 'life cycle not determined';
+};
+/** How the reports describe a target's Info.plist when it is not a file sdkbump read. */
+export declare const INFO_PLIST_LABELS: {
+    readonly generated: 'Info.plist written by Xcode';
+    readonly 'not-read': 'Info.plist not read';
+};
+/**
+ * Replaces control characters (C0 except tab and newline, DEL, C1) with U+FFFD. File names,
+ * versions and plist values come from the checked project; printed raw, an escape sequence in one
+ * of them could rewrite the terminal.
+ */
+export declare function clean(text: string): string;
+/** A copy of a report (or any part of one) with every string passed through clean(). */
+export declare function withoutControlCharacters<T>(value: T): T;
+/** Splits text into lines of at most `width` columns (a longer word gets a line of its own). */
+export declare function wrap(text: string, width: number): string[];
+export declare const plural: (count: number, word: string) => string;

package/dist/report/text.js

@@ -0,0 +1,63 @@
+export const REPOSITORY_URL = 'https://github.com/muhittincamdali/sdkbump';
+/** The guide for each kind of project, linked at the end of every report. */
+export const GUIDES = {
+    native: `${REPOSITORY_URL}/blob/main/docs/guides/native-ios.md`,
+    flutter: `${REPOSITORY_URL}/blob/main/docs/guides/flutter.md`,
+    'react-native': `${REPOSITORY_URL}/blob/main/docs/guides/react-native-expo.md`,
+    expo: `${REPOSITORY_URL}/blob/main/docs/guides/react-native-expo.md`,
+};
+export const ECOSYSTEM_LABELS = {
+    native: 'native iOS',
+    flutter: 'Flutter',
+    'react-native': 'React Native',
+    expo: 'Expo',
+};
+export const LIFECYCLE_LABELS = {
+    'app-delegate': 'app delegate life cycle',
+    scenes: 'scene life cycle',
+    swiftui: 'SwiftUI App (scenes)',
+    unknown: 'life cycle not determined',
+};
+/** How the reports describe a target's Info.plist when it is not a file sdkbump read. */
+export const INFO_PLIST_LABELS = {
+    generated: 'Info.plist written by Xcode',
+    'not-read': 'Info.plist not read',
+};
+/**
+ * Replaces control characters (C0 except tab and newline, DEL, C1) with U+FFFD. File names,
+ * versions and plist values come from the checked project; printed raw, an escape sequence in one
+ * of them could rewrite the terminal.
+ */
+export function clean(text) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: matching control characters is the point.
+    return text.replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g, '�');
+}
+/** A copy of a report (or any part of one) with every string passed through clean(). */
+export function withoutControlCharacters(value) {
+    if (typeof value === 'string')
+        return clean(value);
+    if (Array.isArray(value))
+        return value.map(withoutControlCharacters);
+    if (value === null || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, withoutControlCharacters(item)]));
+}
+/** Splits text into lines of at most `width` columns (a longer word gets a line of its own). */
+export function wrap(text, width) {
+    const lines = [];
+    let line = '';
+    for (const word of text.split(/\s+/).filter(Boolean)) {
+        if (line && line.length + 1 + word.length > width) {
+            lines.push(line);
+            line = word;
+        }
+        else {
+            line = line ? `${line} ${word}` : word;
+        }
+    }
+    if (line)
+        lines.push(line);
+    return lines;
+}
+export const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;
+//# sourceMappingURL=text.js.map

package/dist/report/tty.d.ts

@@ -0,0 +1,7 @@
+import type { Report } from '../model.js';
+export interface TtyOptions {
+    color: boolean;
+    /** Total width to wrap to (default 100, at least 60). */
+    width?: number;
+}
+export declare function renderTty(report: Report, options: TtyOptions): string;