@mcamdali/sdkbump 0.0.0-stage → 0.1.3

package/dist/collect/regions.js

@@ -0,0 +1,108 @@
+function matchingBrace(code, open) {
+    let depth = 0;
+    for (let index = open; index < code.length; index++) {
+        if (code[index] === '{')
+            depth++;
+        else if (code[index] === '}' && --depth === 0)
+            return index;
+    }
+    return code.length;
+}
+const KEYWORDS = new Set([
+    'func',
+    'var',
+    'let',
+    'subscript',
+    'init',
+    'deinit',
+    'static',
+    'override',
+]);
+const baseName = (type) => type
+    .replace(/<[^>]*>/g, '')
+    .replace(/^(?:any|some|@\w+)\s+/g, '')
+    .trim()
+    .split('.')
+    .at(-1) ?? '';
+export function swiftRegions(file) {
+    const regions = [];
+    const declaration = /\b(class|struct|enum|actor|extension)\s+([A-Za-z_][\w.]*)\s*(?:<[^>{]*>)?\s*(?::\s*([^{]*?))?\s*(?:\bwhere\b[^{]*)?\{/g;
+    for (let match = declaration.exec(file.code); match; match = declaration.exec(file.code)) {
+        const [, kind, name = '', inherits] = match;
+        if (KEYWORDS.has(name))
+            continue;
+        const open = match.index + match[0].length - 1;
+        const before = file.code.slice(Math.max(0, match.index - 200), match.index);
+        const attributes = before.slice(Math.max(before.lastIndexOf('}'), before.lastIndexOf(';')) + 1);
+        regions.push({
+            file,
+            kind: kind,
+            name: baseName(name),
+            inherits: (inherits ?? '').split(',').map(baseName).filter(Boolean),
+            start: open,
+            end: matchingBrace(file.code, open),
+            line: file.lineAt(match.index),
+            main: /@(?:main|UIApplicationMain)\b/.test(attributes),
+        });
+    }
+    return regions;
+}
+export function objcRegions(file) {
+    const regions = [];
+    const declaration = /@(interface|implementation)\s+(\w+)\s*(?::\s*(\w+))?\s*(?:\(\s*\w*\s*\))?\s*(?:<([^>]*)>)?/g;
+    for (let match = declaration.exec(file.code); match; match = declaration.exec(file.code)) {
+        const [, kind, name = '', superclass, protocols] = match;
+        const endIndex = file.code.indexOf('@end', match.index);
+        regions.push({
+            file,
+            kind: kind,
+            name,
+            inherits: [superclass, ...(protocols ?? '').split(',')]
+                .map((item) => item?.trim() ?? '')
+                .filter(Boolean),
+            start: match.index,
+            end: endIndex === -1 ? file.code.length : endIndex,
+            line: file.lineAt(match.index),
+            main: false,
+        });
+    }
+    return regions;
+}
+/** Classes that derive, directly or through other classes in the app, from one of `bases`. */
+export function derivedFrom(regions, bases) {
+    const names = new Set(bases);
+    const found = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const region of regions) {
+            if (region.kind === 'struct' || found.has(region.name))
+                continue;
+            if (region.inherits.some((parent) => names.has(parent))) {
+                found.add(region.name);
+                names.add(region.name);
+                changed = true;
+            }
+        }
+    }
+    return found;
+}
+/** The innermost type region of `file` that contains `offset`. */
+export function regionAt(index, file, offset) {
+    let best;
+    for (const region of index.regions) {
+        if (region.file !== file || offset < region.start || offset > region.end)
+            continue;
+        if (!best || region.start >= best.start)
+            best = region;
+    }
+    return best;
+}
+/** Whether `offset` in `file` is inside the body of a type in `names` (class or extension). */
+export function insideTypeNamed(index, file, offset, names) {
+    return index.regions.some((region) => region.file === file &&
+        offset >= region.start &&
+        offset <= region.end &&
+        names.has(region.name));
+}
+//# sourceMappingURL=regions.js.map

package/dist/collect/sources.d.ts

@@ -0,0 +1,45 @@
+export { blankCommentsAndStrings } from './blank.js';
+export { insideTypeNamed, regionAt } from './regions.js';
+export type Language = 'swift' | 'objc';
+export interface SourceFile {
+    path: string;
+    language: Language;
+    /** The file as written. */
+    text: string;
+    /** The same text with comments and string contents replaced by spaces; offsets and lines match. */
+    code: string;
+    /** 1-based line of an offset. */
+    lineAt(offset: number): number;
+}
+export interface TypeRegion {
+    file: SourceFile;
+    kind: 'class' | 'struct' | 'enum' | 'actor' | 'extension' | 'interface' | 'implementation';
+    name: string;
+    /** Superclass and protocols as written, without module prefixes or generic arguments. */
+    inherits: string[];
+    /** Offsets of the body: from `{` (or the declaration for Objective-C) to its end. */
+    start: number;
+    end: number;
+    line: number;
+    /** Swift: the declaration carries `@main` or `@UIApplicationMain`. */
+    main: boolean;
+}
+export interface SourceIndex {
+    files: SourceFile[];
+    regions: TypeRegion[];
+    appDelegates: ReadonlySet<string>;
+    sceneDelegates: ReadonlySet<string>;
+    /** Structs that conform to SwiftUI's App. */
+    swiftUIApps: TypeRegion[];
+}
+/** Superclasses and protocols that make a class an app delegate. */
+export declare const APP_DELEGATE_BASES: readonly ['UIApplicationDelegate', 'FlutterAppDelegate', 'ExpoAppDelegate', 'RCTAppDelegate', 'EXAppDelegateWrapper'];
+/** Superclasses and protocols that make a class a scene delegate. */
+export declare const SCENE_DELEGATE_BASES: readonly ['UIWindowSceneDelegate', 'UISceneDelegate', 'FlutterSceneDelegate', 'ExpoAppSceneDelegate'];
+/** Every Swift and Objective-C file under `folder`, skipping dependencies, builds and tests. */
+export declare function listSourceFiles(folder: string): Promise<string[]>;
+export declare function sourceFile(path: string, text: string): SourceFile;
+/** Builds the index for the given files (already read), e.g. from listSourceFiles. */
+export declare function indexFiles(files: SourceFile[]): SourceIndex;
+/** Reads and indexes every source file under the given folders. */
+export declare function indexSources(folders: readonly string[]): Promise<SourceIndex>;

package/dist/collect/sources.js

@@ -0,0 +1,99 @@
+// Swift and Objective-C sources of an app: comments and string literals blanked out (so a pattern
+// never matches inside them), the classes, structs and extensions they declare, and which of
+// those are app delegates, scene delegates or a SwiftUI App.
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { lineIndex } from '../core/lines.js';
+import { blankCommentsAndStrings } from './blank.js';
+import { derivedFrom, objcRegions, swiftRegions } from './regions.js';
+export { blankCommentsAndStrings } from './blank.js';
+export { insideTypeNamed, regionAt } from './regions.js';
+/** Superclasses and protocols that make a class an app delegate. */
+export const APP_DELEGATE_BASES = [
+    'UIApplicationDelegate',
+    'FlutterAppDelegate',
+    'ExpoAppDelegate',
+    'RCTAppDelegate',
+    'EXAppDelegateWrapper',
+];
+/** Superclasses and protocols that make a class a scene delegate. */
+export const SCENE_DELEGATE_BASES = [
+    'UIWindowSceneDelegate',
+    'UISceneDelegate',
+    'FlutterSceneDelegate',
+    'ExpoAppSceneDelegate',
+];
+const SOURCE_EXTENSIONS = {
+    '.swift': 'swift',
+    '.m': 'objc',
+    '.mm': 'objc',
+    '.h': 'objc',
+};
+/** Folders that hold dependencies, build output or tests rather than the app's own code. */
+const SKIPPED = /^(Pods|node_modules|build|DerivedData|\.build|Carthage|\.git|\.symlinks|Flutter|.*Tests|.*\.xcodeproj|.*\.xcworkspace|.*\.xcassets|.*\.framework|.*\.xcframework)$/;
+/** Every Swift and Objective-C file under `folder`, skipping dependencies, builds and tests. */
+export async function listSourceFiles(folder) {
+    const found = [];
+    const walk = async (dir, depth) => {
+        if (depth > 12)
+            return;
+        const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!SKIPPED.test(entry.name))
+                    await walk(join(dir, entry.name), depth + 1);
+            }
+            else if (entry.isFile() && SOURCE_EXTENSIONS[extname(entry.name)]) {
+                found.push(join(dir, entry.name));
+            }
+        }
+    };
+    await walk(folder, 0);
+    return found.sort();
+}
+/** App delegates named outside their declaration: SwiftUI's adaptor and UIApplicationMain. */
+function namedAppDelegates(files) {
+    const names = [];
+    for (const file of files) {
+        for (const match of file.code.matchAll(/@UIApplicationDelegateAdaptor\s*\(\s*(\w+)\.self/g)) {
+            if (match[1])
+                names.push(match[1]);
+        }
+        for (const match of file.code.matchAll(/UIApplicationMain\s*\([^;]*NSStringFromClass\s*\(\s*\[\s*(\w+)\s+class\s*\]\s*\)/g)) {
+            if (match[1])
+                names.push(match[1]);
+        }
+    }
+    return names;
+}
+export function sourceFile(path, text) {
+    const language = SOURCE_EXTENSIONS[extname(path)] ?? 'swift';
+    return {
+        path,
+        language,
+        text,
+        code: blankCommentsAndStrings(text, language),
+        lineAt: lineIndex(text),
+    };
+}
+/** Builds the index for the given files (already read), e.g. from listSourceFiles. */
+export function indexFiles(files) {
+    const regions = files.flatMap((file) => file.language === 'swift' ? swiftRegions(file) : objcRegions(file));
+    const appDelegates = derivedFrom(regions, APP_DELEGATE_BASES);
+    for (const name of namedAppDelegates(files))
+        appDelegates.add(name);
+    return {
+        files,
+        regions,
+        appDelegates,
+        sceneDelegates: derivedFrom(regions, SCENE_DELEGATE_BASES),
+        swiftUIApps: regions.filter((region) => region.kind === 'struct' && region.inherits.includes('App')),
+    };
+}
+/** Reads and indexes every source file under the given folders. */
+export async function indexSources(folders) {
+    const paths = [...new Set((await Promise.all(folders.map(listSourceFiles))).flat())].sort();
+    const files = await Promise.all(paths.map(async (path) => sourceFile(path, await readFile(path, 'utf8'))));
+    return indexFiles(files);
+}
+//# sourceMappingURL=sources.js.map

package/dist/core/files.d.ts

@@ -0,0 +1,22 @@
+export type ProjectFile = {
+    found: true;
+    bytes: Buffer;
+} | {
+    found: false;
+    reason: 'missing' | 'outside' | 'not-file';
+};
+/** How a report says why a file was not read, after the file's name. */
+export declare const NOT_READ: {
+    readonly missing: 'does not exist.';
+    readonly outside: 'is outside the project; it was not read.';
+    readonly 'not-file': 'is not a file; it was not read.';
+};
+/** Whether `path` is `folder` or inside it (both already resolved with realpath). */
+export declare function isInside(path: string, folder: string): boolean;
+/**
+ * Reads `path` when it is a regular file inside `root`. With `root` null only the regular-file
+ * check applies, for files a package manager may link from outside the project (node_modules).
+ */
+export declare function readProjectFile(path: string, root: string | null): Promise<ProjectFile>;
+/** The text of `path` (see readProjectFile), or null when it is not read. */
+export declare function readProjectText(path: string, root: string | null): Promise<string | null>;

package/dist/core/files.js

@@ -0,0 +1,47 @@
+// Reads files of the checked project. Their names and symbolic links come from the project, so a
+// file is read only when it is a regular file and, unless the caller says otherwise, inside the
+// project folder: a link to /dev/zero or a FIFO would never end, and a link out of the project
+// would read a file the user did not ask to check.
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { isAbsolute, relative, sep } from 'node:path';
+/** How a report says why a file was not read, after the file's name. */
+export const NOT_READ = {
+    missing: 'does not exist.',
+    outside: 'is outside the project; it was not read.',
+    'not-file': 'is not a file; it was not read.',
+};
+/** Whether `path` is `folder` or inside it (both already resolved with realpath). */
+export function isInside(path, folder) {
+    const rest = relative(folder, path);
+    return rest !== '..' && !rest.startsWith(`..${sep}`) && !isAbsolute(rest);
+}
+/**
+ * Reads `path` when it is a regular file inside `root`. With `root` null only the regular-file
+ * check applies, for files a package manager may link from outside the project (node_modules).
+ */
+export async function readProjectFile(path, root) {
+    let real;
+    try {
+        real = await realpath(path);
+    }
+    catch {
+        return { found: false, reason: 'missing' };
+    }
+    if (root !== null && !isInside(real, await realpath(root).catch(() => root))) {
+        return { found: false, reason: 'outside' };
+    }
+    try {
+        if (!(await stat(real)).isFile())
+            return { found: false, reason: 'not-file' };
+        return { found: true, bytes: await readFile(real) };
+    }
+    catch {
+        return { found: false, reason: 'missing' };
+    }
+}
+/** The text of `path` (see readProjectFile), or null when it is not read. */
+export async function readProjectText(path, root) {
+    const file = await readProjectFile(path, root);
+    return file.found ? file.bytes.toString('utf8') : null;
+}
+//# sourceMappingURL=files.js.map

package/dist/core/lines.d.ts

@@ -0,0 +1,2 @@
+/** Returns a function from a 0-based offset in `text` to its 1-based line. */
+export declare function lineIndex(text: string): (offset: number) => number;

package/dist/core/lines.js

@@ -0,0 +1,21 @@
+// Line numbers for offsets into a text, for reports that point at a line of a file.
+/** Returns a function from a 0-based offset in `text` to its 1-based line. */
+export function lineIndex(text) {
+    const starts = [0];
+    for (let index = text.indexOf('\n'); index !== -1; index = text.indexOf('\n', index + 1)) {
+        starts.push(index + 1);
+    }
+    return (offset) => {
+        let low = 0;
+        let high = starts.length - 1;
+        while (low < high) {
+            const middle = (low + high + 1) >> 1;
+            if ((starts[middle] ?? 0) <= offset)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        return low + 1;
+    };
+}
+//# sourceMappingURL=lines.js.map

package/dist/core/versions.d.ts

@@ -0,0 +1,18 @@
+export interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+}
+export declare function parseVersion(text: string): Version | null;
+/** Semantic version order; a prerelease sorts before its release. Unparsable text sorts first. */
+export declare function compareVersions(left: string, right: string): number;
+export declare const atLeast: (version: string, minimum: string) => boolean;
+/**
+ * The lowest version a declared npm range allows, when that can be read without the registry:
+ * "0.87.1", "^0.87.1", "~57.0.29", ">=0.88.0-rc.1", "57.x". Returns null for tags ("latest"),
+ * "*", URLs, workspace and file references, and ranges with "||" or "<".
+ */
+export declare function lowestAllowed(range: string): string | null;
+/** The major version, e.g. 57 for "57.0.29". */
+export declare function majorOf(version: string): number | null;

package/dist/core/versions.js

@@ -0,0 +1,63 @@
+// Version numbers as npm and Flutter write them: compare them and find the lowest version a
+// declared range (^1.2.3, ~57.0.29, >=0.88.0-rc.1) allows.
+const VERSION = /^v?(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+export function parseVersion(text) {
+    const match = VERSION.exec(text.trim());
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3] ?? 0),
+        prerelease: match[4] ? match[4].split('.') : [],
+    };
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return Math.sign(right.length - left.length);
+    for (let index = 0; index < Math.max(left.length, right.length); index++) {
+        const a = left[index];
+        const b = right[index];
+        if (a === undefined)
+            return -1;
+        if (b === undefined)
+            return 1;
+        const numeric = /^\d+$/.test(a) && /^\d+$/.test(b);
+        const order = numeric ? Number(a) - Number(b) : a < b ? -1 : a > b ? 1 : 0;
+        if (order !== 0)
+            return Math.sign(order);
+    }
+    return 0;
+}
+/** Semantic version order; a prerelease sorts before its release. Unparsable text sorts first. */
+export function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return a ? 1 : b ? -1 : 0;
+    return (Math.sign(a.major - b.major) ||
+        Math.sign(a.minor - b.minor) ||
+        Math.sign(a.patch - b.patch) ||
+        comparePrerelease(a.prerelease, b.prerelease));
+}
+export const atLeast = (version, minimum) => compareVersions(version, minimum) >= 0;
+/**
+ * The lowest version a declared npm range allows, when that can be read without the registry:
+ * "0.87.1", "^0.87.1", "~57.0.29", ">=0.88.0-rc.1", "57.x". Returns null for tags ("latest"),
+ * "*", URLs, workspace and file references, and ranges with "||" or "<".
+ */
+export function lowestAllowed(range) {
+    const text = range.trim();
+    if (text.includes('||') || text.includes('<') || /[:/]/.test(text))
+        return null;
+    const match = /^(?:\^|~|>=|=)?\s*v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?(-[0-9A-Za-z.-]+)?$/.exec(text);
+    if (!match)
+        return null;
+    const part = (value) => value === undefined || /[x*]/.test(value) ? '0' : value;
+    return `${match[1]}.${part(match[2])}.${part(match[3])}${match[4] ?? ''}`;
+}
+/** The major version, e.g. 57 for "57.0.29". */
+export function majorOf(version) {
+    return parseVersion(version)?.major ?? null;
+}
+//# sourceMappingURL=versions.js.map

package/dist/detect/project.d.ts

@@ -0,0 +1,46 @@
+export type Ecosystem = 'native' | 'flutter' | 'react-native' | 'expo';
+export interface PackageVersion {
+    name: string;
+    /** Exact version when installed or locked, otherwise the lowest the declared range allows. */
+    version: string | null;
+    /** Where `version` came from. */
+    source: 'installed' | 'lockfile' | 'declared';
+    /** The range in package.json. */
+    declared: string;
+}
+export interface FlutterInfo {
+    /** From .fvmrc or .fvm/fvm_config.json; null when the project does not pin one. */
+    version: string | null;
+    /** pubspec.yaml sets `enable-uiscene-migration: false`. */
+    migrationDisabled: boolean;
+    plugin: boolean;
+}
+export interface ExpoConfig {
+    /** app.json (read) or app.config.js/ts (not evaluated). */
+    file: string;
+    /** expo-build-properties `ios.enableSceneSupport`; null when the config cannot be read. */
+    enableSceneSupport: boolean | null;
+}
+export interface Project {
+    root: string;
+    name: string;
+    ecosystem: Ecosystem;
+    /** The folder with the iOS app's Xcode project; null for an Expo app without ios/. */
+    iosDir: string | null;
+    /** Absolute paths of the .xcodeproj folders of the app. */
+    xcodeProjects: string[];
+    /** npm packages that decide the fix (react-native, expo, workarounds), when present. */
+    packages: ReadonlyMap<string, PackageVersion>;
+    flutter: FlutterInfo | null;
+    expoConfig: ExpoConfig | null;
+}
+export declare class ProjectError extends Error {
+    name: string;
+}
+/** npm packages whose version or presence changes the advice. */
+export declare const WATCHED_PACKAGES: readonly ['react-native', 'expo', 'expo-build-properties', 'react-native-uiscene-bridge', 'react-native-xcode27'];
+/**
+ * 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 declare function detectProject(path: string): Promise<Project>;