@swiftbrowser/xcodeproj 0.1.0 → 0.2.0

package/README.md

@@ -20,10 +20,13 @@ app.appIconName; // ASSETCATALOG_COMPILER_APPICON_NAME
 app.swiftVersion; // SWIFT_VERSION
 app.deploymentTarget; // IPHONEOS_DEPLOYMENT_TARGET
 app.sources; // absolute paths of the .swift files, in navigator order
+app.models; // the Core ML models (.mlmodel, .mlpackage) it compiles
 app.resources; // absolute paths of the Resources build phase entries
 app.assetCatalogs; // the *.xcassets among them (and in synchronized folders)
 app.dependencies; // names of target dependencies
 app.packageProducts; // Swift package products the target links
+app.packageDependencies; // the same, each with its package (URL and version rule, or local path)
+project.packages; // the project's Swift package references
 app.settings('Release'); // merged build settings for a configuration
 ```
 
@@ -32,7 +35,9 @@ app.settings('Release'); // merged build settings for a configuration
 - `readXcodeProject(xcodeprojPath)` parses `<xcodeprojPath>/project.pbxproj` and
   returns an `XcodeProject`: `path`, `root` (the directory containing the
   bundle, what `$(SRCROOT)` means), `objectVersion`, `targets` (every
-  `PBXNativeTarget`) and `appTargets()`.
+  `PBXNativeTarget`), `packages` (its `XCRemoteSwiftPackageReference`s, with
+  the dependency rule, and `XCLocalSwiftPackageReference`s, with the absolute
+  path; each with SwiftPM's identity, see `packageIdentity`) and `appTargets()`.
 - `parsePbxproj(text)` returns the raw object graph: `{ objectVersion,
   rootObject, objects }`, where each object has an `isa` plus arbitrary fields
   (strings, arrays, nested dictionaries). `parseOldStylePlist(text)` parses any

package/dist/index.d.ts

@@ -7,6 +7,6 @@
  * - `findXcodeProjects(dir)` locates `.xcodeproj` bundles.
  */
 export { parsePbxproj, parseOldStylePlist, tokenizePbxproj, PbxprojSyntaxError, type PbxValue, type PbxDict, type PbxObject, type PbxprojDocument, } from './pbxproj.js';
-export { readXcodeProject, xcodeProjectFromDocument, expandVariables, APPLICATION_PRODUCT_TYPE, type XcodeProject, type XcodeTarget, } from './project.js';
+export { readXcodeProject, xcodeProjectFromDocument, expandVariables, packageIdentity, APPLICATION_PRODUCT_TYPE, type XcodeProject, type XcodeTarget, type SwiftPackageReference, type SwiftPackageRequirement, type SwiftPackageProductDependency, } from './project.js';
 export { findXcodeProjects } from './find.js';
 export { parseXmlPlist, type PlistValue, type PlistDict } from './plist.js';

package/dist/index.js

@@ -7,6 +7,6 @@
  * - `findXcodeProjects(dir)` locates `.xcodeproj` bundles.
  */
 export { parsePbxproj, parseOldStylePlist, tokenizePbxproj, PbxprojSyntaxError, } from './pbxproj.js';
-export { readXcodeProject, xcodeProjectFromDocument, expandVariables, APPLICATION_PRODUCT_TYPE, } from './project.js';
+export { readXcodeProject, xcodeProjectFromDocument, expandVariables, packageIdentity, APPLICATION_PRODUCT_TYPE, } from './project.js';
 export { findXcodeProjects } from './find.js';
 export { parseXmlPlist } from './plist.js';

package/dist/project.d.ts

@@ -21,6 +21,12 @@ export interface XcodeProject {
     /** 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`). */
@@ -51,14 +57,33 @@ export interface XcodeTarget {
      * 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
@@ -70,6 +95,54 @@ export interface XcodeTarget {
      */
     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;
 /**

package/dist/project.js

@@ -18,6 +18,11 @@ import * as path from 'node:path';
 import { isDict, parsePbxproj } from './pbxproj.js';
 import { parseXmlPlist } from './plist.js';
 export const APPLICATION_PRODUCT_TYPE = 'com.apple.product-type.application';
+/** SwiftPM's identity of a package at a URL or path: its last component, without `.git`, lower-cased. */
+export function packageIdentity(location) {
+    const last = location.replace(/[/\\]+$/, '').split(/[/\\:]/).pop() ?? location;
+    return last.replace(/\.git$/i, '').toLowerCase();
+}
 /** Reads `<xcodeprojPath>/project.pbxproj` and interprets it. */
 export function readXcodeProject(xcodeprojPath) {
     const absolute = path.resolve(xcodeprojPath);
@@ -106,10 +111,14 @@ class ProjectReader {
             if (target?.isa === 'PBXNativeTarget')
                 targets.push(this.readTarget(id, target));
         }
+        const packages = strings(this.project['packageReferences'])
+            .map((id) => this.packageReference(id))
+            .filter((reference) => reference !== undefined);
         return {
             path: this.xcodeprojPath,
             root: this.root,
             objectVersion: this.doc.objectVersion,
+            packages,
             targets,
             appTargets: () => targets.filter((target) => target.productType === APPLICATION_PRODUCT_TYPE),
         };
@@ -188,13 +197,16 @@ class ProjectReader {
     }
     // --- Synchronized folders (Xcode 16) ---
     /**
-     * The `.swift` files and `.xcassets` folders under the target's synchronized
-     * folders, read from disk (sorted, recursive), minus the target's membership
-     * exceptions. A folder missing on disk contributes nothing.
+     * The `.swift` files, Core ML models and `.xcassets` folders under the
+     * target's synchronized folders, read from disk (sorted, recursive), minus
+     * the target's membership exceptions. A folder missing on disk contributes
+     * nothing.
      */
     synchronizedMembers(targetId, target) {
         const sources = [];
+        const models = [];
         const assetCatalogs = [];
+        const localizations = [];
         for (const groupId of strings(target['fileSystemSynchronizedGroups'])) {
             const group = this.objects[groupId];
             if (!group || !SYNCHRONIZED_GROUP_ISAS.has(group.isa))
@@ -217,12 +229,16 @@ class ProjectReader {
                     return false;
                 if (entry.endsWith('.swift'))
                     sources.push(entry);
+                else if (isCoreMLModel(entry))
+                    models.push(entry);
                 else if (entry.endsWith('.xcassets'))
                     assetCatalogs.push(entry);
+                else if (isLocalization(entry))
+                    localizations.push(entry);
                 return true;
             });
         }
-        return { sources, assetCatalogs };
+        return { sources, models, assetCatalogs, localizations };
     }
     // --- Build settings ---
     configurations(listId) {
@@ -295,7 +311,8 @@ class ProjectReader {
             return result;
         };
         const defaults = settings();
-        const phaseSources = this.buildPhaseFiles(target, 'PBXSourcesBuildPhase').filter((p) => p.endsWith('.swift'));
+        const phaseFiles = this.buildPhaseFiles(target, 'PBXSourcesBuildPhase');
+        const phaseSources = phaseFiles.filter((p) => p.endsWith('.swift'));
         const resources = this.buildPhaseFiles(target, 'PBXResourcesBuildPhase');
         const synchronized = this.synchronizedMembers(targetId, target);
         const productName = defaults['PRODUCT_NAME'] || str(target['productName']) || name;
@@ -304,10 +321,13 @@ class ProjectReader {
             productType: str(target['productType']) ?? '',
             productName,
             sources: [...phaseSources, ...synchronized.sources],
+            models: [...phaseFiles.filter(isCoreMLModel), ...synchronized.models],
             resources,
             assetCatalogs: [...resources.filter((p) => p.endsWith('.xcassets')), ...synchronized.assetCatalogs],
+            localizations: [...localizationFiles(resources), ...synchronized.localizations],
             dependencies: this.dependencyNames(target),
             packageProducts: this.packageProductNames(target),
+            packageDependencies: this.packageProductDependencies(target),
             settings,
         };
         const bundleIdentifier = defaults['PRODUCT_BUNDLE_IDENTIFIER'];
@@ -383,6 +403,124 @@ class ProjectReader {
         }
         return [...names];
     }
+    /** `packageProductNames` with the package of each product, when recorded. */
+    packageProductDependencies(target) {
+        const seen = new Set();
+        const out = [];
+        const add = (productRefId) => {
+            const product = productRefId ? this.objects[productRefId] : undefined;
+            if (product?.isa !== 'XCSwiftPackageProductDependency')
+                return;
+            const name = str(product['productName']);
+            if (!name || seen.has(name))
+                return;
+            seen.add(name);
+            const reference = this.packageReference(str(product['package'])) ?? this.folderPackage(name);
+            out.push(reference ? { product: name, package: reference } : { product: name });
+        };
+        for (const id of strings(target['packageProductDependencies']))
+            add(id);
+        for (const phaseId of strings(target['buildPhases'])) {
+            const phase = this.objects[phaseId];
+            if (phase?.isa !== 'PBXFrameworksBuildPhase')
+                continue;
+            for (const buildFileId of strings(phase['files']))
+                add(str(this.objects[buildFileId]?.['productRef']));
+        }
+        return out;
+    }
+    /**
+     * Local packages added to the project as folders (how Xcode added a local
+     * package before `XCLocalSwiftPackageReference`, and still does when one is
+     * dragged in): a file reference to a folder holding a `Package.swift`. The
+     * product dependency then names no package, so the package is the folder
+     * whose manifest declares a library of that name (read from the manifest's
+     * text: `.library(name: "…"`), or, failing that, the folder of that name.
+     */
+    folderPackagesByProduct;
+    folderPackage(product) {
+        if (!this.folderPackagesByProduct) {
+            const byProduct = new Map();
+            const byFolder = new Map();
+            for (const [id, object] of Object.entries(this.objects)) {
+                if (object.isa !== 'PBXFileReference')
+                    continue;
+                const type = str(object['lastKnownFileType']) ?? str(object['explicitFileType']);
+                if (type !== undefined && type !== 'wrapper' && type !== 'folder')
+                    continue;
+                const dir = this.resolvePath(id);
+                if (!dir)
+                    continue;
+                let manifest;
+                try {
+                    manifest = fs.readFileSync(path.join(dir, 'Package.swift'), 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                const reference = { kind: 'local', path: dir, identity: packageIdentity(dir) };
+                byFolder.set(path.basename(dir), reference);
+                for (const match of manifest.matchAll(/\.library\(\s*name:\s*"([^"]+)"/g)) {
+                    if (!byProduct.has(match[1]))
+                        byProduct.set(match[1], reference);
+                }
+            }
+            for (const [name, reference] of byFolder)
+                if (!byProduct.has(name))
+                    byProduct.set(name, reference);
+            this.folderPackagesByProduct = byProduct;
+        }
+        return this.folderPackagesByProduct.get(product);
+    }
+    /** An `XCRemoteSwiftPackageReference` or `XCLocalSwiftPackageReference`. */
+    packageReference(id) {
+        const object = id ? this.objects[id] : undefined;
+        if (object?.isa === 'XCRemoteSwiftPackageReference') {
+            const url = str(object['repositoryURL']);
+            if (!url)
+                return undefined;
+            const requirement = packageRequirement(object['requirement']);
+            return requirement ? { kind: 'remote', url, identity: packageIdentity(url), requirement } : { kind: 'remote', url, identity: packageIdentity(url) };
+        }
+        if (object?.isa === 'XCLocalSwiftPackageReference') {
+            const relative = str(object['relativePath']);
+            if (!relative)
+                return undefined;
+            const absolute = path.resolve(this.root, relative);
+            return { kind: 'local', path: absolute, identity: packageIdentity(absolute) };
+        }
+        return undefined;
+    }
+}
+/** Xcode's dependency rule; undefined for a kind it does not spell out here. */
+function packageRequirement(value) {
+    if (!isDict(value))
+        return undefined;
+    const minimumVersion = str(value['minimumVersion']);
+    switch (str(value['kind'])) {
+        case 'upToNextMajorVersion':
+            return minimumVersion ? { kind: 'upToNextMajorVersion', minimumVersion } : undefined;
+        case 'upToNextMinorVersion':
+            return minimumVersion ? { kind: 'upToNextMinorVersion', minimumVersion } : undefined;
+        case 'exactVersion': {
+            const version = str(value['version']);
+            return version ? { kind: 'exactVersion', version } : undefined;
+        }
+        case 'versionRange': {
+            const maximumVersion = str(value['maximumVersion']);
+            return minimumVersion && maximumVersion ? { kind: 'versionRange', minimumVersion, maximumVersion } : undefined;
+        }
+        case 'branch': {
+            const branch = str(value['branch']);
+            return branch ? { kind: 'branch', branch } : undefined;
+        }
+        case 'revision': {
+            const revision = str(value['revision']);
+            return revision ? { kind: 'revision', revision } : undefined;
+        }
+        default:
+            return undefined;
+    }
 }
 // ----- Helpers ----------------------------------------------------------------
 /**
@@ -397,6 +535,25 @@ export function expandVariables(value, variables) {
  * whether to descend into a directory; `.xcassets` bundles and dot-entries are
  * never descended into. Unreadable directories are skipped.
  */
+/** A string catalog, or a `.strings` / `.stringsdict` table. */
+function isLocalization(file) {
+    return /\.(xcstrings|strings|stringsdict)$/.test(file);
+}
+/** The localization files among resources: catalogs and tables, and the tables in `.lproj` folders. */
+function localizationFiles(resources) {
+    const out = [];
+    for (const resource of resources) {
+        if (isLocalization(resource)) {
+            out.push(resource);
+        }
+        else if (resource.endsWith('.lproj') && fs.existsSync(resource) && fs.statSync(resource).isDirectory()) {
+            for (const name of fs.readdirSync(resource).sort())
+                if (isLocalization(name))
+                    out.push(path.join(resource, name));
+        }
+    }
+    return out;
+}
 function walkSynchronizedFolder(dir, visit) {
     let entries;
     try {
@@ -411,7 +568,11 @@ function walkSynchronizedFolder(dir, visit) {
             continue;
         const full = path.join(dir, entry.name);
         const descend = visit(full);
-        if (descend && entry.isDirectory() && !entry.name.endsWith('.xcassets'))
+        if (descend && entry.isDirectory() && !entry.name.endsWith('.xcassets') && !entry.name.endsWith('.mlpackage'))
             walkSynchronizedFolder(full, visit);
     }
 }
+/** A Core ML model Xcode compiles into a class: an `.mlmodel` file or an `.mlpackage` bundle. */
+function isCoreMLModel(file) {
+    return file.endsWith('.mlmodel') || file.endsWith('.mlpackage');
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@swiftbrowser/xcodeproj",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Reads Xcode projects (project.pbxproj): app targets, their Swift sources, asset catalogs and build settings. Pure TypeScript, no Xcode needed.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/dabbott/SwiftBrowser.git",
+    "url": "git+https://github.com/noya-app/SwiftBrowser.git",
     "directory": "packages/xcodeproj"
   },
   "type": "module",