Repository navigation
feat(ios): embed dynamic SwiftPM products with embed - #6169
Draft
edusperoni wants to merge 20 commits into
Draft
edusperoni wants to merge 20 commits into
edusperoni wants to merge 20 commits into
Conversation
Options and arguments are declared on the definition and validated before run. Setup runs ahead of argument enforcement so a definition can derive its arguments; a redeclared CLI option keeps whatever it leaves unspecified; unknown options are tolerated instead of skipping validation; objectOption covers --env.* style values; a missing required argument keeps the command's preamble in the error.
Platform validation, dynamic delegation, native-add and widget, test, create/install/post-install-cli/help, enforced-parameter, device, self-contained, platform, plugin and hooks, open|*, and the rest. Class-based surfaces the migration left without callers are deprecated rather than removed, since extensions may import them.
… type registerCommand takes one shape and registers in one call, off the global binding and into the loading context's injector; built-in commands load on first use through a shared helper; getInjector becomes getRootInjector. Package-manager commands register from their real path, dev-post-install is reachable again, and a mistyped subcommand shows help in the terminal.
A command can run another in process without exiting on failure; a definition's setup state is scoped to one invocation; DeferredCommandResult is a discriminated union; the command-name types an extension needs are exported from the contracts. BREAKING CHANGE: ctx.arguments is now ctx.params on the command context.
ns start's key handling becomes a declarative table over a caller-supplied context, with state on the context and capabilities on the injector; the key-command surface leaves the injector facade. Failures from the spawned run children surface in the parent, and NS_NO_OPEN keeps the CLI from launching a browser where nobody is watching.
KeyShortcutRegistry is a contract with disposable registrations; the engine resolves help and dispatch through it, so an entry registered at runtime takes effect immediately. The shared entries become builders, a defineCommand may declare the keys it answers to, and ns run and ns debug get their own tables behind NS_COMMAND_SHORTCUTS (default off).
Stopping a bundler only sent SIGINT and returned, so a restart could spawn a replacement while the old watcher was still alive. The stale child's exit then evicted the replacement's map entry, and a compilation finishing on it still reached the prepare controller. Await the child's exit (escalating to SIGKILL), detach its output and IPC handlers, and key every eviction on process identity. The prepare controller now keeps its compilation handler per platform, so stopping one platform no longer leaves the other's listener attached.
r restarts the app of the running session without preparing, building or syncing; R prepares again first and rebuilds the native app only if needed; B always rebuilds it. The help hint is repeated once a burst of syncs settles, and a restart stays on the devices the session was given instead of every device attached to the platform.
`class X extends Command({ name, options, ... })` is sugar over the object
form: the definition is read through a static getter, `this.options` and
`this.args` are typed, and a command's services are typed from its setup. The
invocation context is provided under COMMAND_CONTEXT, which is what the class
form's field initializers read.
Each invocation builds one context object that every stage shares. The structured commands move to the class form, whose result type is inferred from `run` and whose meta is validated eagerly; the simple ones are inlined as object definitions; cross-command checks go through canExecuteCommand. The guide describes where a handler gets its services.
CommandsService is the contract a command, a key shortcut or a plugin runs or consults another command through. It takes a registered name or a definition run as given, routes a parent name to its subcommand and fires the full hook name, rejects a dispatch that overlaps a running one while letting them nest, and replaces the free runCommand and canExecuteCommand helpers. `ctx.injector` is the invocation's own injector.
`ctx.fail(message, { help })` replaces the commands' direct use of $errors,
and signing and install options are read from the typed `ctx.options` instead
of the global options object.
A definition declares `providers` for its invocation injector; the container takes `multi: true` providers, which shadow per level as in Angular; and COMMAND_PRECONDITIONS is a multi token run before setup and before the arguments policy. `provideProject()` is how a command declares that it runs inside a project.
- A bare class in `providers` provides itself, as in Angular; the container
expands it to `{ provide: Cls, useClass: Cls }` and the definition rejects
anything that is neither a class nor a `provide` object.
- A COMMAND_PRECONDITIONS entry is a function or a list of functions, checked
with the command's name; the list form is what lets a command keep the
scope's preconditions next to its own.
- An argument's `validate` runs inside the invocation's injection context.
- `runCommand` and `canExecuteCommand` take `{ injector }` for a definition
run as given, defaulting to the caller's injection context, then the root;
a registered name rejects it.
- Option priming happens inside the guarded block, so a throwing
`validateOptions` leaves no command entry behind.
- `getInjector()` stays as a deprecated alias of `getRootInjector()`, and the
compat tests carry their original lines again.
- `provideProject` lives under lib/contracts and is exported from
nativescript/contracts with `CommandReference` and `CommandDispatchOptions`.
- The guide follows the API on every point above.
…iew found `executeCommandInProcess` and `canExecuteCommandInProcess` were renamed on this branch before any release, so they go rather than stay deprecated; the same for the `getInjector()` alias of `getRootInjector()`. The dispatcher's hierarchical branch in option priming was unreachable once parent names were routed to their leaf, the adapter shares `define-command`'s `isPlainObject` instead of carrying a second one, the options service is typed in the adapter, and `classCommandDefinition` is no longer exported.
The deprecation note on disableCommandHelpSuggestion said only that nothing references it, which the declaration already shows; the file goes back to its merge-base content.
- A legacy command's `skipOptionsValidation` still counts, as the deprecated spelling of `allowUnknownOptions`. - Option priming puts the parser back when validation throws, and an error is reported once however many dispatch levels rethrow it. - `open` passes IDE paths as arguments instead of shell strings, resets the visionOS platform override in a `finally`, and logs a failed launch. - `preview` no longer falls through from the bun case to npm. - The prepare controller removes its bundler listener even while the watcher is paused; a restart re-reads the session's device descriptors so a device stopped meanwhile is left alone; `waitForExit` answers at once for a child that has already exited. - The `c` shortcut spawns the CLI through `process.execPath` and reports a spawn failure instead of crashing; shortcuts attach over IPC only when an IPC channel exists; a visionOS child receives forwarded keys and is stopped by `c`. - The guide no longer names the removed in-process aliases and describes the argument specs a definition accepts.
…s `required` `arguments` cannot be bound as an identifier in strict code, so a definition could never be destructured or written with property shorthand; the field is now `params`, the word the context already uses for the same values, and a stale `arguments` key is rejected with a message naming the fix. `ParamSpec`, `ParamsPolicy` and `CommandParamValues` replace the argument-named types, which stay as deprecated aliases; `platformArgument` is `platformParam`. An option spec takes `required: true`: its absence fails the invocation after the params policy and before `canExecute`, and the handler's value type drops `| undefined`, as a `default` already does. The two do not combine.
A Swift package product declared `.library(type: .dynamic)` was linked into the target's Frameworks phase but never copied into the app bundle. Debug simulator builds still ran because Xcode adds an absolute LC_RPATH to the build directory's PackageFrameworks folder; device and archive builds crashed in dyld at launch with "Library not loaded: @rpath/<Product>.framework/<Product>". Xcode records a dynamic package product added through "Frameworks, Libraries, and Embedded Content" twice: once in the Frameworks phase and once in the "Embed Frameworks" copy phase with CodeSignOnCopy. The CLI only ever wrote the first entry. `IosSPMPackageBase` gains `embed?: string[]`, the subset of `libs` to copy into the bundle. For each, the pbxproj service writes a second PBXBuildFile for the same productRef into the target's own "Embed Frameworks" copy phase (dstSubfolderSpec 10), creating the phase when the target has none. Entries are keyed on productRef so re-applying on every prepare stays idempotent. An embed entry that is not in `libs` is warned about and skipped. The option is opt-in: the CLI cannot tell a static product from a dynamic one without parsing Package.swift, and embedding a static product's placeholder breaks the build. The existing post-build architecture strip already walks the bundle's Frameworks folder, so embedded package frameworks get the same treatment as plugin frameworks.
|
Important Draft PR not reviewedDraft PRs are not automatically reviewed by default.
To automatically review draft PRs, update your CodeRabbit configuration: reviews:
auto_review:
drafts: true
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
PR Checklist
What is the current behavior?
Declare a Swift package product as dynamic and reference it from
nativescript.config.ts:The app builds, links, and launches on the simulator. On a device or from an archive it crashes in dyld at launch:
@rpath/MyProduct.framework.app/Frameworksns build ios(Debug, simulator)LC_RPATHtoplatforms/ios/build/…/PackageFrameworksns build ios --release --for-device@executable_path/Frameworksand@loader_path/FrameworksonlyThe framework is built (with its dSYM) and simply never copied into the bundle.
Cause.
SPMPbxprojService.addPackageToTargetwires a product into theXCSwiftPackageProductDependency, aPBXBuildFilewithproductRef, and the target'sPBXFrameworksBuildPhase. Nothing adds it to the "Embed Frameworks"PBXCopyFilesBuildPhase(dstSubfolderSpec = 10). When a package product is added through Xcode's own "Frameworks, Libraries, and Embedded Content" UI, Xcode emits the sameproductReftwice: once in the Frameworks phase, and once in the Embed Frameworks copy phase withsettings = { ATTRIBUTES = (CodeSignOnCopy, ); }. That second entry is what the CLI was missing. Xcode does not infer it from the link phase alone, as the Release build above shows.Verified on
nativescript@9.1.0-next.2026-08-19with Xcode 26.3.What is the new behavior?
IosSPMPackageBasegains an opt-inembed:For each product in
embed,addPackageToTargetnow:dstSubfolderSpec = 10), creating one when the target has none, the same way the link phase is resolved from the target's ownbuildPhasesrather than any target's;PBXBuildFilefor the sameproductRefwithsettings = { ATTRIBUTES = (CodeSignOnCopy, ); }and comment<Product> in Embed Frameworks;files, keyed onproductRefso re-applying on every prepare stays idempotent.An
embedentry that is not inlibsis warned about and skipped, matching how the missing-Frameworks-phase case is reported.What the service writes for an embedded product:
Why opt-in. The CLI cannot tell a static product from a dynamic one without parsing
Package.swift, and embedding a static product's placeholder breaks the build.Nothing else changes.
internal/strip-dynamic-framework-architectures.shalready walks$FRAMEWORKS_FOLDER_PATH, so embedded package frameworks get the same architecture strip and re-sign as plugin.xcframeworks.Docs follow-up (docs.nativescript.org)
The SPM section should say that:
.library(type: .dynamic)products needembed, or they fail in dyld at launch on devices;.library(...)without a type is static and ends up inside the app executable. A Release archive strips the executable's symbol table, so C functions reached from JS by name must then be listed forstrip -sviaSTRIPFLAGSinbuild.xcconfig, or shipped as a dynamic product withembed.Tests
test/services/ios/spm-pbxproj-service.ts:productRef, the latter withCodeSignOnCopy; a linked-only product gets no embed entry;embedentry missing fromlibswarns and is skipped.