@swiftbrowser/xcodeproj 0.0.0-stage → 0.2.0

package/dist/plist.js

@@ -0,0 +1,147 @@
+/**
+ * Minimal reader for XML property lists (`Info.plist`).
+ *
+ * Only what the project reader needs: the top-level `<dict>` with string,
+ * integer, real, boolean, date, data, array and nested dict values. Binary
+ * plists (`bplist00`) and the old-style ASCII format are not handled here;
+ * `parseXmlPlist` returns `undefined` for anything it cannot read, and the
+ * caller treats that as "no Info.plist values available".
+ */
+/** Parses an XML plist. Returns `undefined` when the text is not an XML plist. */
+export function parseXmlPlist(text) {
+    if (!/<plist[\s>]/.test(text))
+        return undefined;
+    const reader = new XmlPlistReader(text);
+    try {
+        return reader.read();
+    }
+    catch {
+        return undefined;
+    }
+}
+class XmlPlistReader {
+    text;
+    pos = 0;
+    constructor(text) {
+        this.text = text;
+    }
+    read() {
+        const plist = this.nextTag();
+        if (!plist || plist.name !== 'plist')
+            throw new Error('not a plist');
+        if (plist.selfClosing)
+            return undefined;
+        const value = this.readValue();
+        this.expectClosing('plist');
+        return value;
+    }
+    /** Reads the next opening tag (skipping the prolog, DOCTYPE, comments and whitespace). */
+    nextTag() {
+        for (;;) {
+            const lt = this.text.indexOf('<', this.pos);
+            if (lt < 0)
+                return undefined;
+            if (this.text.startsWith('<?', lt)) {
+                this.pos = this.text.indexOf('?>', lt) + 2;
+                continue;
+            }
+            if (this.text.startsWith('<!--', lt)) {
+                this.pos = this.text.indexOf('-->', lt) + 3;
+                continue;
+            }
+            if (this.text.startsWith('<!', lt)) {
+                this.pos = this.text.indexOf('>', lt) + 1;
+                continue;
+            }
+            const gt = this.text.indexOf('>', lt);
+            if (gt < 0)
+                throw new Error('unterminated tag');
+            let inside = this.text.slice(lt + 1, gt).trim();
+            const selfClosing = inside.endsWith('/');
+            if (selfClosing)
+                inside = inside.slice(0, -1).trim();
+            const name = inside.split(/\s/, 1)[0] ?? '';
+            this.pos = gt + 1;
+            return { name, selfClosing, end: gt + 1 };
+        }
+    }
+    /** Peeks: is the next tag the closing `</name>`? Consumes it when so. */
+    atClosing(name) {
+        const rest = this.text.slice(this.pos);
+        const match = /^\s*<\/\s*([^\s>]+)\s*>/.exec(rest);
+        if (!match || match[1] !== name)
+            return false;
+        this.pos += match[0].length;
+        return true;
+    }
+    expectClosing(name) {
+        if (!this.atClosing(name))
+            throw new Error(`expected </${name}>`);
+    }
+    /** Reads the text content up to `</name>` (entities decoded). */
+    readText(name) {
+        const close = this.text.indexOf(`</${name}>`, this.pos);
+        if (close < 0)
+            throw new Error(`expected </${name}>`);
+        const raw = this.text.slice(this.pos, close);
+        this.pos = close + name.length + 3;
+        return decodeEntities(raw);
+    }
+    readValue() {
+        const tag = this.nextTag();
+        if (!tag)
+            throw new Error('expected a value');
+        switch (tag.name) {
+            case 'string':
+            case 'date':
+            case 'data':
+                return tag.selfClosing ? '' : this.readText(tag.name);
+            case 'integer':
+            case 'real':
+                return tag.selfClosing ? 0 : Number(this.readText(tag.name).trim());
+            case 'true':
+                return true;
+            case 'false':
+                return false;
+            case 'array': {
+                const items = [];
+                if (tag.selfClosing)
+                    return items;
+                while (!this.atClosing('array'))
+                    items.push(this.readValue());
+                return items;
+            }
+            case 'dict': {
+                const dict = {};
+                if (tag.selfClosing)
+                    return dict;
+                while (!this.atClosing('dict')) {
+                    const keyTag = this.nextTag();
+                    if (!keyTag || keyTag.name !== 'key')
+                        throw new Error('expected <key>');
+                    const key = keyTag.selfClosing ? '' : this.readText('key');
+                    dict[key] = this.readValue();
+                }
+                return dict;
+            }
+            default:
+                throw new Error(`unexpected <${tag.name}>`);
+        }
+    }
+}
+const NAMED_ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+};
+function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (whole, body) => {
+        if (body.startsWith('#x'))
+            return String.fromCodePoint(parseInt(body.slice(2), 16));
+        if (body.startsWith('#'))
+            return String.fromCodePoint(parseInt(body.slice(1), 10));
+        return NAMED_ENTITIES[body] ?? whole;
+    });
+}

package/dist/project.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Interprets a parsed `project.pbxproj` (pbxproj.ts) as targets with resolved
+ * file paths and build settings, so a CLI can find an iOS app's Swift sources,
+ * asset catalogs and settings without Xcode.
+ *
+ * Object graph in brief: the `rootObject` is a `PBXProject` with `targets`
+ * (`PBXNativeTarget`), a `mainGroup` (the tree of `PBXGroup`s and
+ * `PBXFileReference`s) and a `buildConfigurationList`. Each target has
+ * `buildPhases` (`PBXSourcesBuildPhase`, `PBXResourcesBuildPhase`, ...) whose
+ * `files` are `PBXBuildFile`s pointing at a `fileRef`, plus its own
+ * `buildConfigurationList` (`XCConfigurationList` -> `XCBuildConfiguration`
+ * with `buildSettings`). Xcode 16 projects can instead point a target at
+ * `PBXFileSystemSynchronizedRootGroup`s: folders whose contents are members of
+ * the target implicitly, minus per-target exception sets.
+ */
+import { type PbxprojDocument } from './pbxproj.js';
+export declare const APPLICATION_PRODUCT_TYPE = "com.apple.product-type.application";
+export interface XcodeProject {
+    /** Absolute path of the `.xcodeproj` bundle. */
+    path: string;
+    /** Directory containing the `.xcodeproj`: the source root, what `$(SRCROOT)` means. */
+    root: string;
+    objectVersion: number;
+    /**
+     * The Swift packages the project references (`PBXProject.packageReferences`):
+     * remote ones (`XCRemoteSwiftPackageReference`, with Xcode's dependency rule)
+     * and local ones (`XCLocalSwiftPackageReference`), in project order.
+     */
+    packages: SwiftPackageReference[];
+    /** Every `PBXNativeTarget`, in project order. */
+    targets: XcodeTarget[];
+    /** The targets whose product is an application (`com.apple.product-type.application`). */
+    appTargets(): XcodeTarget[];
+}
+export interface XcodeTarget {
+    name: string;
+    /** e.g. `com.apple.product-type.application`. */
+    productType: string;
+    /** `PRODUCT_NAME` with `$(TARGET_NAME)` resolved; falls back to the target name. */
+    productName: string;
+    /** `PRODUCT_BUNDLE_IDENTIFIER`. */
+    bundleIdentifier?: string;
+    /**
+     * `INFOPLIST_KEY_CFBundleDisplayName`, else `CFBundleDisplayName` from the
+     * `INFOPLIST_FILE` when that file exists and is an XML plist.
+     */
+    displayName?: string;
+    /** `ASSETCATALOG_COMPILER_APPICON_NAME`. */
+    appIconName?: string;
+    /** `SWIFT_VERSION`. */
+    swiftVersion?: string;
+    /** `IPHONEOS_DEPLOYMENT_TARGET`. */
+    deploymentTarget?: string;
+    /**
+     * Absolute paths of the `.swift` files compiled by the target: the Sources
+     * build phase in project (navigator) order, then the files of synchronized
+     * folders (sorted).
+     */
+    sources: string[];
+    /**
+     * Absolute paths of the Core ML models the target compiles (`.mlmodel`
+     * files, `.mlpackage` bundles): the Sources build phase in project order,
+     * then those in synchronized folders. Xcode generates a Swift class for each.
+     */
+    models: string[];
+    /** Absolute paths of the files and folders in the Resources build phase, in project (navigator) order. */
+    resources: string[];
+    /** Absolute paths of the `*.xcassets` among the resources and in synchronized folders. */
+    assetCatalogs: string[];
+    /**
+     * Absolute paths of the target's localized string sources: string catalogs
+     * (`*.xcstrings`) and `.strings` / `.stringsdict` files (in `<language>.lproj`
+     * folders), among the resources and in synchronized folders. Xcode compiles
+     * them into the app's string tables.
+     */
+    localizations: string[];
+    /** Names of the targets this one depends on (`PBXTargetDependency`). */
+    dependencies: string[];
+    /** Swift package products the target links (`XCSwiftPackageProductDependency.productName`). */
+    packageProducts: string[];
+    /**
+     * The same products with the package each comes from, when the project
+     * records it (`XCSwiftPackageProductDependency.package`; a local package
+     * added as a folder reference by older Xcodes has none).
+     */
+    packageDependencies: SwiftPackageProductDependency[];
+    /**
+     * Merged build settings for a configuration: project-level settings first,
+     * target-level settings on top. `configuration` defaults to the target's
+     * default configuration: `Debug` when it has one, else the configuration
+     * list's `defaultConfigurationName`, else the first configuration.
+     * `$(TARGET_NAME)`, `$(PRODUCT_NAME)`, `$(SRCROOT)` and `$(PROJECT_DIR)` are
+     * expanded; other `$(...)` references are left as they are. An `.xcconfig`
+     * referenced by `baseConfigurationReference` is not read.
+     */
+    settings(configuration?: string): Record<string, string>;
+}
+/**
+ * The version rule of a remote package, as Xcode's "Dependency Rule" stores
+ * it in `XCRemoteSwiftPackageReference.requirement`.
+ */
+export type SwiftPackageRequirement = {
+    kind: 'upToNextMajorVersion';
+    minimumVersion: string;
+} | {
+    kind: 'upToNextMinorVersion';
+    minimumVersion: string;
+} | {
+    kind: 'exactVersion';
+    version: string;
+} | {
+    kind: 'versionRange';
+    minimumVersion: string;
+    maximumVersion: string;
+} | {
+    kind: 'branch';
+    branch: string;
+} | {
+    kind: 'revision';
+    revision: string;
+};
+/**
+ * A Swift package the project references. `identity` is SwiftPM's name for
+ * it: the last path component of the URL (or folder), without `.git`,
+ * lower-cased; it is what `.product(name:package:)` names.
+ */
+export type SwiftPackageReference = {
+    kind: 'remote';
+    url: string;
+    identity: string;
+    /** Absent when the project's rule has a kind this reader does not know. */
+    requirement?: SwiftPackageRequirement;
+} | {
+    kind: 'local';
+    /** Absolute path of the package folder (`relativePath` from the source root). */
+    path: string;
+    identity: string;
+};
+/** A package product a target links, with its package when the project says. */
+export interface SwiftPackageProductDependency {
+    product: string;
+    package?: SwiftPackageReference;
+}
+/** SwiftPM's identity of a package at a URL or path: its last component, without `.git`, lower-cased. */
+export declare function packageIdentity(location: string): string;
+/** Reads `<xcodeprojPath>/project.pbxproj` and interprets it. */
+export declare function readXcodeProject(xcodeprojPath: string): XcodeProject;
+/**
+ * Interprets an already parsed document as the project at `xcodeprojPath`
+ * (which need not exist; its parent directory is the source root).
+ */
+export declare function xcodeProjectFromDocument(doc: PbxprojDocument, xcodeprojPath: string): XcodeProject;
+/**
+ * Replaces `$(NAME)` and `${NAME}` for the names in `variables`; other
+ * references (`$(inherited)`, `$(SDKROOT)`, ...) are kept verbatim.
+ */
+export declare function expandVariables(value: string, variables: Record<string, string>): string;