@mcamdali/podexit 0.0.0-stage → 0.1.2

package/dist/core/classify.js

@@ -0,0 +1,71 @@
+import { publisherFor } from './policy.js';
+const NOT_AFFECTED = new Set(['path', 'git', 'podspec', 'spec-repo']);
+/** Update status from the lockfile and the publisher policy alone; needs no network. */
+export function classifyUpdates(pod, policy) {
+    if (NOT_AFFECTED.has(pod.source.kind))
+        return { status: 'not-affected' };
+    if (pod.source.kind !== 'trunk')
+        return { status: 'unknown' };
+    const publisher = publisherFor(policy, pod.name);
+    return publisher ? { status: 'capped', publisher } : { status: 'frozen-on-trunk' };
+}
+/**
+ * Update status of every pod in a lockfile. Pods are classified one by one, then trunk pods that a
+ * capped pod depends on (directly or not) are capped too when the publisher's source says its
+ * stop covers subdependencies. Breadth-first from the listed pods, so `via` names the nearest one.
+ */
+export function classifyLockfile(pods, policy) {
+    const result = new Map(pods.map((pod) => [pod.name, classifyUpdates(pod, policy)]));
+    const byName = new Map(pods.map((pod) => [pod.name, pod]));
+    const queue = pods
+        .filter((pod) => result.get(pod.name)?.publisher?.includesSubdependencies)
+        .map((pod) => ({ pod, root: pod.name }));
+    for (let next = queue.shift(); next; next = queue.shift()) {
+        const { pod, root } = next;
+        const publisher = result.get(root)?.publisher;
+        if (!publisher)
+            continue;
+        for (const name of pod.dependencies) {
+            const dependency = byName.get(name);
+            if (!dependency || result.get(name)?.status !== 'frozen-on-trunk')
+                continue;
+            result.set(name, { status: 'capped', publisher, via: root });
+            queue.push({ pod: dependency, root });
+        }
+    }
+    return result;
+}
+/** One sentence for each update status, used by every report format. */
+export function describeUpdates(status, pod, publisher, via) {
+    switch (status) {
+        case 'frozen-on-trunk':
+            return 'Published on trunk: no new versions after trunk goes read-only on 2026-12-02.';
+        case 'capped':
+            if (publisher && via) {
+                return `Subdependency of ${via}: ${publisher.name} stops publishing its pods and their subdependencies to CocoaPods (${publisher.stoppedPublishing}).`;
+            }
+            return publisher
+                ? `${publisher.name} stopped at ${publisher.lastMajorOnCocoaPods}.x on CocoaPods (${publisher.stoppedPublishing}); newer versions ship through Swift Package Manager.`
+                : 'The publisher stopped releasing to CocoaPods.';
+        case 'not-affected':
+            return describeSource(pod);
+        case 'unknown':
+            return 'The lockfile does not list a source for this pod.';
+    }
+}
+function describeSource(pod) {
+    const { source } = pod;
+    switch (source.kind) {
+        case 'path':
+            return `Local path (${source.path}); updated with the package that provides it, not through trunk.`;
+        case 'git':
+            return `Git repository (${source.url}); trunk going read-only does not affect it.`;
+        case 'podspec':
+            return `Podspec file (${source.url}); trunk going read-only does not affect it.`;
+        case 'spec-repo':
+            return `Private specs repository (${source.url}); trunk going read-only does not affect it.`;
+        default:
+            return 'Not published through trunk.';
+    }
+}
+//# sourceMappingURL=classify.js.map

package/dist/core/lockfile.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Where CocoaPods resolved a pod from, read from `SPEC REPOS` and `EXTERNAL SOURCES`.
+ *
+ * - `trunk`: the public CocoaPods Specs repository (CDN or the old git mirror). These pods are
+ *   the ones that stop getting new versions when trunk goes read-only.
+ * - `spec-repo`: a private or third-party specs repository.
+ * - `path`, `git`, `podspec`: an external source declared in the Podfile, for example a Flutter
+ *   plugin under `.symlinks/plugins` or a React Native module under `node_modules`.
+ */
+export type SourceKind = 'trunk' | 'spec-repo' | 'path' | 'git' | 'podspec' | 'unknown';
+export interface PodSource {
+    kind: SourceKind;
+    /** Specs repository URL (`spec-repo`), git URL (`git`) or podspec location (`podspec`). */
+    url?: string;
+    /** Local path for `path` sources, as written in the lockfile. */
+    path?: string;
+    tag?: string;
+    branch?: string;
+    commit?: string;
+}
+/** One pod from `PODS`, with its subspecs folded into the root pod. */
+export interface LockedPod {
+    /** Root pod name: `Firebase` for `Firebase/Analytics`. */
+    name: string;
+    version: string;
+    /** Subspecs in use, e.g. `["Analytics", "CoreOnly"]`. */
+    subspecs: string[];
+    /** Root names of the pods this pod depends on. */
+    dependencies: string[];
+    /** Root names of the pods that depend on this pod. */
+    requiredBy: string[];
+    /** Listed in the Podfile (`DEPENDENCIES`), as opposed to pulled in by another pod. */
+    direct: boolean;
+    source: PodSource;
+}
+export interface Lockfile {
+    pods: LockedPod[];
+    cocoapodsVersion: string | null;
+    podfileChecksum: string | null;
+}
+export declare class LockfileError extends Error {
+    name: string;
+}
+/** `Firebase/Analytics` -> `Firebase`. */
+export declare function rootName(name: string): string;
+/** Parses the text of a `Podfile.lock`. Throws {@link LockfileError} when it is not one. */
+export declare function parseLockfile(text: string): Lockfile;

package/dist/core/lockfile.js

@@ -0,0 +1,164 @@
+import { parse as parseYaml } from 'yaml';
+export class LockfileError extends Error {
+    name = 'LockfileError';
+}
+const NOT_A_LOCKFILE = 'This file has no PODS section, so it is not a Podfile.lock.';
+const PODS_KEY = /^PODS:/m;
+const TRUNK_REPOSITORIES = [
+    /^trunk$/i,
+    /^https?:\/\/(?:www\.)?github\.com\/cocoapods\/specs(?:\.git)?\/?$/i,
+];
+const ENTRY = /^(?<name>.+?) \((?<version>[^)]+)\)$/;
+/** `Firebase/Analytics` -> `Firebase`. */
+export function rootName(name) {
+    return name.split('/')[0] ?? name;
+}
+function dependencyName(requirement) {
+    // "FirebaseCore (~> 12.4.0)" or "Flutter (from `Flutter`)" or "Alamofire"
+    return rootName(requirement.replace(/\s*\(.*\)\s*$/, '').trim());
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringList(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
+function rawPods(value) {
+    if (!Array.isArray(value))
+        throw new LockfileError('PODS is missing or is not a list.');
+    return value.map((item) => {
+        if (typeof item === 'string')
+            return { entry: item, dependencies: [] };
+        if (isRecord(item)) {
+            const [entry, dependencies] = Object.entries(item)[0] ?? [];
+            if (entry)
+                return { entry, dependencies: stringList(dependencies) };
+        }
+        throw new LockfileError(`Unexpected PODS entry: ${JSON.stringify(item)}`);
+    });
+}
+function specRepos(value) {
+    const sources = new Map();
+    if (!isRecord(value))
+        return sources;
+    for (const [repository, pods] of Object.entries(value)) {
+        const trunk = TRUNK_REPOSITORIES.some((pattern) => pattern.test(repository));
+        const source = trunk ? { kind: 'trunk' } : { kind: 'spec-repo', url: repository };
+        for (const pod of stringList(pods))
+            sources.set(pod, source);
+    }
+    return sources;
+}
+function optionalString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function externalSource(options) {
+    const path = optionalString(options, ':path');
+    if (path !== undefined)
+        return { kind: 'path', path };
+    const git = optionalString(options, ':git');
+    if (git !== undefined) {
+        const source = { kind: 'git', url: git };
+        for (const key of ['tag', 'branch', 'commit']) {
+            const value = optionalString(options, `:${key}`);
+            if (value !== undefined)
+                source[key] = value;
+        }
+        return source;
+    }
+    const podspec = optionalString(options, ':podspec');
+    if (podspec !== undefined)
+        return { kind: 'podspec', url: podspec };
+    return { kind: 'unknown' };
+}
+function externalSources(value, checkout) {
+    const sources = new Map();
+    if (!isRecord(value))
+        return sources;
+    const pinned = isRecord(checkout) ? checkout : {};
+    for (const [pod, options] of Object.entries(value)) {
+        if (!isRecord(options))
+            continue;
+        const source = externalSource(options);
+        // CHECKOUT OPTIONS records the commit a branch or tag resolved to at install time.
+        const resolved = pinned[pod];
+        if (source.kind === 'git' && isRecord(resolved)) {
+            const commit = optionalString(resolved, ':commit');
+            if (commit !== undefined)
+                source.commit = commit;
+        }
+        sources.set(pod, source);
+    }
+    return sources;
+}
+function scalar(value) {
+    return typeof value === 'string' || typeof value === 'number' ? String(value) : null;
+}
+/** Parses the text of a `Podfile.lock`. Throws {@link LockfileError} when it is not one. */
+export function parseLockfile(text) {
+    let document;
+    try {
+        // The failsafe schema keeps every scalar a string, so `COCOAPODS: 1.10` stays "1.10".
+        document = parseYaml(text, { schema: 'failsafe' });
+    }
+    catch (error) {
+        // A README or a CI config often fails as YAML long before it would fail as a lockfile; the
+        // parser's message ("Implicit keys need to be on a single line") says nothing useful then.
+        if (!PODS_KEY.test(text))
+            throw new LockfileError(NOT_A_LOCKFILE);
+        const reason = error.message.split('\n')[0];
+        throw new LockfileError(`This Podfile.lock is not valid YAML: ${reason}`);
+    }
+    if (!isRecord(document) || !('PODS' in document))
+        throw new LockfileError(NOT_A_LOCKFILE);
+    const repos = specRepos(document['SPEC REPOS']);
+    const external = externalSources(document['EXTERNAL SOURCES'], document['CHECKOUT OPTIONS']);
+    const direct = new Set(stringList(document.DEPENDENCIES).map(dependencyName));
+    const pods = new Map();
+    for (const { entry, dependencies } of rawPods(document.PODS)) {
+        const match = ENTRY.exec(entry.trim());
+        if (!match?.groups)
+            throw new LockfileError(`Unexpected PODS entry: ${entry}`);
+        const fullName = match.groups.name ?? '';
+        const name = rootName(fullName);
+        const pod = pods.get(name) ?? {
+            name,
+            version: match.groups.version ?? '',
+            subspecs: [],
+            dependencies: [],
+            requiredBy: [],
+            direct: direct.has(name),
+            source: external.get(name) ?? repos.get(name) ?? { kind: 'unknown' },
+        };
+        const subspec = fullName.slice(name.length + 1);
+        if (subspec && !pod.subspecs.includes(subspec))
+            pod.subspecs.push(subspec);
+        for (const dependency of dependencies.map(dependencyName)) {
+            if (dependency !== name && !pod.dependencies.includes(dependency))
+                pod.dependencies.push(dependency);
+        }
+        pods.set(name, pod);
+    }
+    for (const pod of pods.values()) {
+        for (const dependency of pod.dependencies) {
+            const target = pods.get(dependency);
+            if (target && !target.requiredBy.includes(pod.name))
+                target.requiredBy.push(pod.name);
+        }
+    }
+    const sorted = [...pods.values()].sort((a, b) => a.name.localeCompare(b.name, 'en'));
+    for (const pod of sorted) {
+        pod.subspecs.sort();
+        pod.dependencies.sort();
+        pod.requiredBy.sort();
+    }
+    return {
+        pods: sorted,
+        cocoapodsVersion: scalar(document.COCOAPODS),
+        podfileChecksum: scalar(document['PODFILE CHECKSUM']),
+    };
+}
+//# sourceMappingURL=lockfile.js.map

package/dist/core/policy.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+/**
+ * A publisher that stopped releasing to CocoaPods before trunk itself goes read-only, with the
+ * page that says so. Every entry must cite its source.
+ */
+export declare const Publisher: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    pods: z.ZodArray<z.ZodString>;
+    lastMajorOnCocoaPods: z.ZodNumber;
+    stoppedPublishing: z.ZodString;
+    summary: z.ZodString;
+    includesSubdependencies: z.ZodOptional<z.ZodBoolean>;
+    swiftPackage: z.ZodOptional<z.ZodObject<{
+        url: z.ZodURL;
+        note: z.ZodString;
+    }, z.core.$strip>>;
+    source: z.ZodURL;
+    checked: z.ZodISODate;
+}, z.core.$strip>;
+export type Publisher = z.infer<typeof Publisher>;
+export declare const PublisherPolicy: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    dataVersion: z.ZodString;
+    publishers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        pods: z.ZodArray<z.ZodString>;
+        lastMajorOnCocoaPods: z.ZodNumber;
+        stoppedPublishing: z.ZodString;
+        summary: z.ZodString;
+        includesSubdependencies: z.ZodOptional<z.ZodBoolean>;
+        swiftPackage: z.ZodOptional<z.ZodObject<{
+            url: z.ZodURL;
+            note: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodURL;
+        checked: z.ZodISODate;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PublisherPolicy = z.infer<typeof PublisherPolicy>;
+/** Validates policy data; throws a zod error naming the offending field. */
+export declare function parsePublisherPolicy(data: unknown): PublisherPolicy;
+/** The publisher whose policy covers a root pod name, if any. */
+export declare function publisherFor(policy: PublisherPolicy, podName: string): Publisher | undefined;

package/dist/core/policy.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+const httpsUrl = z.url({ protocol: /^https$/ });
+const isoDate = z.iso.date();
+/**
+ * A publisher that stopped releasing to CocoaPods before trunk itself goes read-only, with the
+ * page that says so. Every entry must cite its source.
+ */
+export const Publisher = z.object({
+    id: z.string().regex(/^[a-z0-9-]+$/),
+    name: z.string().min(1),
+    pods: z.array(z.string().min(1)).min(1),
+    lastMajorOnCocoaPods: z.number().int().nonnegative(),
+    /** Month the last CocoaPods release is expected, `YYYY-MM`. */
+    stoppedPublishing: z.string().regex(/^\d{4}-\d{2}$/),
+    summary: z.string().min(1),
+    /**
+     * True when the source says the stop also covers the pods these pods depend on (Firebase:
+     * "all of the following pods and their subdependencies"). Those pods are then capped too.
+     */
+    includesSubdependencies: z.boolean().optional(),
+    swiftPackage: z.object({ url: httpsUrl, note: z.string().min(1) }).optional(),
+    source: httpsUrl,
+    /** Date someone last read the source and confirmed the entry. */
+    checked: isoDate,
+});
+export const PublisherPolicy = z.object({
+    $schema: z.string().optional(),
+    /** Version of the data, separate from the package version: `YYYY.MM.DD` of the last change. */
+    dataVersion: z.string().regex(/^\d{4}\.\d{2}\.\d{2}$/),
+    publishers: z.array(Publisher),
+});
+/** Validates policy data; throws a zod error naming the offending field. */
+export function parsePublisherPolicy(data) {
+    return PublisherPolicy.parse(data);
+}
+/** The publisher whose policy covers a root pod name, if any. */
+export function publisherFor(policy, podName) {
+    return policy.publishers.find((publisher) => publisher.pods.includes(podName));
+}
+//# sourceMappingURL=policy.js.map

package/dist/core/project.d.ts

@@ -0,0 +1,13 @@
+import type { LockedPod } from './lockfile.js';
+/** The kind of project a Podfile.lock belongs to; it decides which migration guide applies. */
+export type ProjectKind = 'native' | 'flutter-app' | 'flutter-plugin' | 'react-native' | 'expo';
+export declare const GUIDES: Record<ProjectKind, {
+    title: string;
+    path: string;
+}>;
+/**
+ * Detects the project kind from the pods CocoaPods installed: Flutter apps have a `Flutter` pod
+ * from a local path, React Native apps have `React-Core`, and Expo apps add `ExpoModulesCore`.
+ * A Flutter lockfile under `example/ios/` is a plugin's example app.
+ */
+export declare function detectProjectKind(pods: readonly LockedPod[], lockfilePath?: string): ProjectKind;

package/dist/core/project.js

@@ -0,0 +1,25 @@
+export const GUIDES = {
+    native: { title: 'Native iOS: CocoaPods to SwiftPM', path: 'docs/guides/native-ios.md' },
+    'flutter-app': { title: 'Flutter apps and plugins', path: 'docs/guides/flutter.md' },
+    'flutter-plugin': { title: 'Flutter apps and plugins', path: 'docs/guides/flutter.md' },
+    'react-native': { title: 'React Native and Expo', path: 'docs/guides/react-native-expo.md' },
+    expo: { title: 'React Native and Expo', path: 'docs/guides/react-native-expo.md' },
+};
+const EXAMPLE_APP = /(?:^|[\\/])example[\\/]ios[\\/]Podfile\.lock$/;
+/**
+ * Detects the project kind from the pods CocoaPods installed: Flutter apps have a `Flutter` pod
+ * from a local path, React Native apps have `React-Core`, and Expo apps add `ExpoModulesCore`.
+ * A Flutter lockfile under `example/ios/` is a plugin's example app.
+ */
+export function detectProjectKind(pods, lockfilePath = '') {
+    const names = new Set(pods.map(({ name }) => name));
+    const flutter = pods.some(({ name, source }) => name === 'Flutter' && source.kind === 'path');
+    if (flutter)
+        return EXAMPLE_APP.test(lockfilePath) ? 'flutter-plugin' : 'flutter-app';
+    if (names.has('ExpoModulesCore') || names.has('Expo'))
+        return 'expo';
+    if (names.has('React-Core') || names.has('React'))
+        return 'react-native';
+    return 'native';
+}
+//# sourceMappingURL=project.js.map

package/dist/core/timeline.d.ts

@@ -0,0 +1,16 @@
+/** Dates from the CocoaPods announcement. They are the maintainers' plan, not a guarantee. */
+export declare const TIMELINE: {
+    /** "I will trigger a test run, giving automation a chance to break early." */
+    readonly trialRun: {
+        readonly from: '2026-11-01';
+        readonly to: '2026-11-07';
+    };
+    /** "I will switch trunk to not accept new Podspecs permanently." */
+    readonly readOnly: '2026-12-02';
+    readonly source: 'https://blog.cocoapods.org/CocoaPods-Specs-Repo/';
+};
+/**
+ * Printed with every report, so "frozen" is never read as "broken". From the same announcement:
+ * the Specs repo and CDN keep serving, and existing builds keep working.
+ */
+export declare const BUILDS_KEEP_WORKING = "Builds keep working: pods already on trunk stay installable after December 2, 2026. Trunk only stops accepting new versions.";

package/dist/core/timeline.js

@@ -0,0 +1,14 @@
+/** Dates from the CocoaPods announcement. They are the maintainers' plan, not a guarantee. */
+export const TIMELINE = {
+    /** "I will trigger a test run, giving automation a chance to break early." */
+    trialRun: { from: '2026-11-01', to: '2026-11-07' },
+    /** "I will switch trunk to not accept new Podspecs permanently." */
+    readOnly: '2026-12-02',
+    source: 'https://blog.cocoapods.org/CocoaPods-Specs-Repo/',
+};
+/**
+ * Printed with every report, so "frozen" is never read as "broken". From the same announcement:
+ * the Specs repo and CDN keep serving, and existing builds keep working.
+ */
+export const BUILDS_KEEP_WORKING = 'Builds keep working: pods already on trunk stay installable after December 2, 2026. Trunk only stops accepting new versions.';
+//# sourceMappingURL=timeline.js.map

package/dist/core/versions.d.ts

@@ -0,0 +1,11 @@
+/** True when the version has a letter segment, e.g. `5.0.0-beta.1` or `2.0.0.rc.1`. */
+export declare function isPrerelease(version: string): boolean;
+/** Orders two CocoaPods versions: negative when `left` is older, positive when newer. */
+export declare function compareVersions(left: string, right: string): number;
+/**
+ * The newest release in a list of versions. Pre-releases count only when the list has nothing
+ * else, so a `6.0.0-beta.1` does not hide the `5.10.2` most projects should compare against.
+ */
+export declare function latestVersion(versions: readonly string[]): string | null;
+/** Major version number, e.g. 12 for `12.4.0`; null when the version does not start with one. */
+export declare function majorVersion(version: string): number | null;

package/dist/core/versions.js

@@ -0,0 +1,57 @@
+// CocoaPods versions look like semver ("5.10.2", "5.0.0-beta.1") but also allow more segments
+// ("2024.10.14.00") and dots before a pre-release tag ("5.0.0.beta.1"). Comparison follows the
+// rules of RubyGems' Gem::Version, which CocoaPods uses: numeric segments compare as numbers,
+// and a segment with letters marks a pre-release that sorts before the release.
+function segments(version) {
+    return version
+        .trim()
+        .split(/[.-]/)
+        .filter((part) => part !== '')
+        .flatMap((part) => part.match(/\d+|[a-z]+/gi) ?? [])
+        .map((part) => (/^\d+$/.test(part) ? Number(part) : part.toLowerCase()));
+}
+/** True when the version has a letter segment, e.g. `5.0.0-beta.1` or `2.0.0.rc.1`. */
+export function isPrerelease(version) {
+    return segments(version).some((segment) => typeof segment === 'string');
+}
+function compareSegment(left, right) {
+    if (left === right)
+        return 0;
+    // A missing segment counts as 0 against a number ("1.0" == "1.0.0") and as a release against a
+    // pre-release tag ("1.0" > "1.0.beta").
+    if (left === undefined)
+        return typeof right === 'string' ? 1 : compareSegment(0, right);
+    if (right === undefined)
+        return -compareSegment(right, left);
+    if (typeof left === 'number' && typeof right === 'number')
+        return Math.sign(left - right);
+    if (typeof left === 'string' && typeof right === 'string')
+        return left < right ? -1 : 1;
+    return typeof left === 'string' ? -1 : 1;
+}
+/** Orders two CocoaPods versions: negative when `left` is older, positive when newer. */
+export function compareVersions(left, right) {
+    const a = segments(left);
+    const b = segments(right);
+    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+        const result = compareSegment(a[index], b[index]);
+        if (result !== 0)
+            return result;
+    }
+    return 0;
+}
+/**
+ * The newest release in a list of versions. Pre-releases count only when the list has nothing
+ * else, so a `6.0.0-beta.1` does not hide the `5.10.2` most projects should compare against.
+ */
+export function latestVersion(versions) {
+    const releases = versions.filter((version) => !isPrerelease(version));
+    const pool = releases.length > 0 ? releases : versions;
+    return pool.reduce((latest, version) => latest === null || compareVersions(version, latest) > 0 ? version : latest, null);
+}
+/** Major version number, e.g. 12 for `12.4.0`; null when the version does not start with one. */
+export function majorVersion(version) {
+    const first = segments(version)[0];
+    return typeof first === 'number' ? first : null;
+}
+//# sourceMappingURL=versions.js.map

package/dist/data.d.ts

@@ -0,0 +1,3 @@
+import { type PublisherPolicy } from './core/policy.js';
+/** Reads and validates the publisher policy shipped in the package's data/ folder. */
+export declare function loadPublisherPolicy(url?: URL): PublisherPolicy;

package/dist/data.js

@@ -0,0 +1,9 @@
+import { readFileSync } from 'node:fs';
+import { parsePublisherPolicy } from './core/policy.js';
+// data/ sits next to src/ and dist/, so this resolves from source and from the published package.
+const POLICY_URL = new URL('../data/publisher-policy.json', import.meta.url);
+/** Reads and validates the publisher policy shipped in the package's data/ folder. */
+export function loadPublisherPolicy(url = POLICY_URL) {
+    return parsePublisherPolicy(JSON.parse(readFileSync(url, 'utf8')));
+}
+//# sourceMappingURL=data.js.map

package/dist/index.d.ts

@@ -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 { analyzeLockfile, buildReport, CachedFetcher, HttpFetcher, loadPublisherPolicy, render } from '@mcamdali/podexit';
+ *
+ * const policy = loadPublisherPolicy();
+ * const fetcher = new CachedFetcher(new HttpFetcher({ userAgent: 'my-tool' }), { directory: '.cache' });
+ * const lockfile = await analyzeLockfile(text, 'ios/Podfile.lock', { fetcher, policy });
+ * console.log(render(buildReport([lockfile], { policy, offline: false }), 'markdown'));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { type AnalyzeOptions, analyzeLockfile, buildReport, type LockfileReport, type PodReport, type Report, type ReportContext, SCHEMA_VERSION, type Summary, type SwiftPackageReport, summarize, type UpdatesReport, } from './analyze.js';
+export { classifyLockfile, classifyUpdates, describeUpdates, type SwiftPackageStatus, type UpdateClassification, type UpdateStatus, } from './core/classify.js';
+export { type LockedPod, type Lockfile, LockfileError, type PodSource, parseLockfile, rootName, type SourceKind, } from './core/lockfile.js';
+export { parsePublisherPolicy, Publisher, PublisherPolicy, publisherFor } from './core/policy.js';
+export { detectProjectKind, GUIDES, type ProjectKind } from './core/project.js';
+export { BUILDS_KEEP_WORKING, TIMELINE } from './core/timeline.js';
+export { compareVersions, isPrerelease, latestVersion, majorVersion } from './core/versions.js';
+export { loadPublisherPolicy } from './data.js';
+export { type CacheOptions, CachedFetcher, defaultCacheDirectory } from './net/cache.js';
+export { type Fetcher, HttpFetcher, type HttpFetcherOptions, OfflineFetcher, type RequestOptions, type Response, } from './net/fetcher.js';
+export { FORMATS, type Format, render, type TtyOptions } from './report/index.js';
+export { VERSION } from './version.js';

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * 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 { analyzeLockfile, buildReport, CachedFetcher, HttpFetcher, loadPublisherPolicy, render } from '@mcamdali/podexit';
+ *
+ * const policy = loadPublisherPolicy();
+ * const fetcher = new CachedFetcher(new HttpFetcher({ userAgent: 'my-tool' }), { directory: '.cache' });
+ * const lockfile = await analyzeLockfile(text, 'ios/Podfile.lock', { fetcher, policy });
+ * console.log(render(buildReport([lockfile], { policy, offline: false }), 'markdown'));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { analyzeLockfile, buildReport, SCHEMA_VERSION, summarize, } from './analyze.js';
+export { classifyLockfile, classifyUpdates, describeUpdates, } from './core/classify.js';
+export { LockfileError, parseLockfile, rootName, } from './core/lockfile.js';
+export { parsePublisherPolicy, Publisher, PublisherPolicy, publisherFor } from './core/policy.js';
+export { detectProjectKind, GUIDES } from './core/project.js';
+export { BUILDS_KEEP_WORKING, TIMELINE } from './core/timeline.js';
+export { compareVersions, isPrerelease, latestVersion, majorVersion } from './core/versions.js';
+export { loadPublisherPolicy } from './data.js';
+export { CachedFetcher, defaultCacheDirectory } from './net/cache.js';
+export { HttpFetcher, OfflineFetcher, } from './net/fetcher.js';
+export { FORMATS, render } from './report/index.js';
+export { VERSION } from './version.js';
+//# sourceMappingURL=index.js.map

package/dist/net/cache.d.ts

@@ -0,0 +1,28 @@
+import type { Fetcher, RequestOptions, Response } from './fetcher.js';
+export interface CacheOptions {
+    directory: string;
+    /** Entries younger than this are used without asking the network. Default: 24 hours. */
+    ttlMs?: number;
+    /** Ignore cached entries and fetch again (the fresh answers are still stored). */
+    refresh?: boolean;
+    now?: () => Date;
+}
+/** `$XDG_CACHE_HOME/podexit`, or `~/.cache/podexit`. */
+export declare function defaultCacheDirectory(env?: NodeJS.ProcessEnv): string;
+/** Where a URL is stored: one JSON file per request, grouped by host so recordings are readable. */
+export declare function cachePath(directory: string, url: string, method?: 'GET' | 'HEAD'): string;
+/**
+ * Disk cache in front of another fetcher. The same files serve as the recorded responses that
+ * make `--offline` and the tests work without a network: with an {@link OfflineFetcher} behind
+ * it, every answer comes from disk regardless of age.
+ */
+export declare class CachedFetcher implements Fetcher {
+    private readonly inner;
+    private readonly options;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(inner: Fetcher, options: CacheOptions);
+    get(url: string, { method }?: RequestOptions): Promise<Response | null>;
+    private read;
+    private write;
+}