nativescript 9.1.0-alpha.1 → 9.1.0-alpha.11

package/lib/services/ios-project-service.js

@@ -243,6 +243,10 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
     }
     async buildProject(projectRoot, projectData, buildData) {
         const platformData = this.getPlatformData(projectData);
+        // On a first build, the runtime (and any other Swift packages) download
+        // here. Pre-resolve under a clear spinner so the subsequent
+        // "Xcode build..." step doesn't appear to hang while that happens.
+        await this.$spmService.ensureSPMDependenciesResolved(platformData, projectData);
         const handler = (data) => {
             this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
         };
@@ -265,8 +269,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         return Promise.resolve();
     }
     async isDynamicFramework(frameworkPath) {
-        const isDynamicFrameworkBundle = async (bundlePath, frameworkName) => {
-            const frameworkBinaryPath = path.join(bundlePath, frameworkName);
+        const isDynamicFrameworkBundle = async (frameworkBinaryPath) => {
             const fileResult = (await this.$childProcess.spawnFromEvent("file", [frameworkBinaryPath], "close")).stdout;
             const isDynamicallyLinked = _.includes(fileResult, "dynamically linked");
             return isDynamicallyLinked;
@@ -278,7 +281,11 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 const singlePlatformFramework = path.join(frameworkPath, library.LibraryIdentifier, library.LibraryPath);
                 if (this.$fs.exists(singlePlatformFramework)) {
                     const frameworkName = path.basename(singlePlatformFramework, path.extname(singlePlatformFramework));
-                    isDynamic = await isDynamicFrameworkBundle(singlePlatformFramework, frameworkName);
+                    let frameworkBinaryPath = path.join(singlePlatformFramework, frameworkName);
+                    if (library.BinaryPath) {
+                        frameworkBinaryPath = path.join(frameworkPath, library.LibraryIdentifier, library.BinaryPath);
+                    }
+                    isDynamic = await isDynamicFrameworkBundle(frameworkBinaryPath);
                     break;
                 }
             }
@@ -286,7 +293,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         }
         else {
             const frameworkName = path.basename(frameworkPath, path.extname(frameworkPath));
-            return await isDynamicFrameworkBundle(frameworkPath, frameworkName);
+            return await isDynamicFrameworkBundle(path.join(frameworkPath, frameworkName));
         }
     }
     /**
@@ -353,7 +360,18 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         project.addFramework(relativeStaticLibPath);
         const relativeHeaderSearchPath = path.join(this.getLibSubpathRelativeToProjectPath(headersSubpath, projectData));
         project.addToHeaderSearchPaths({ relativePath: relativeHeaderSearchPath });
-        this.generateModulemap(headersSubpath, libraryName);
+        // Write the generated modulemap into a CLI-managed folder under the
+        // platform root (never into node_modules). The modulemap references the
+        // plugin's headers in-place via relative paths, so nothing is copied.
+        const modulemapDir = path.join(this.getPlatformData(projectData).projectRoot, IOSProjectService.GENERATED_PLUGINS_DIR_NAME, libraryName);
+        const hasModulemap = this.generateModulemap(headersSubpath, libraryName, modulemapDir);
+        if (hasModulemap) {
+            // Put the modulemap dir on the header search path so clang discovers
+            // the module there instead of inside node_modules.
+            project.addToHeaderSearchPaths({
+                relativePath: this.getLibSubpathRelativeToProjectPath(modulemapDir, projectData),
+            });
+        }
         this.savePbxProj(project, projectData);
     }
     async prepareProject(projectData, prepareData) {
@@ -623,6 +641,27 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         await this.prepareFrameworks(pluginPlatformsFolderPath, pluginData, projectData);
         await this.prepareStaticLibs(pluginPlatformsFolderPath, pluginData, projectData);
     }
+    shouldRepreparePlugin(pluginData, projectData) {
+        const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
+        for (const fileName of this.getAllLibsForPluginWithFileExtension(pluginData, ".a")) {
+            const staticLibPath = path.join(pluginPlatformsFolderPath, fileName);
+            const libraryName = path.basename(staticLibPath, ".a");
+            const headersSubpath = path.join(path.dirname(staticLibPath), "include", libraryName);
+            if (!this.$fs.exists(headersSubpath)) {
+                continue;
+            }
+            const headerFiles = this.$fs
+                .readDirectory(headersSubpath)
+                .filter((f) => path.extname(f) === ".h" &&
+                this.$fs.getFsStats(path.join(headersSubpath, f)).isFile());
+            if (headerFiles.length > 0 &&
+                !this.$fs.exists(path.join(headersSubpath, "module.modulemap"))) {
+                this.$logger.trace(`Plugin ${pluginData.name}: modulemap missing at ${headersSubpath}, will re-prepare`);
+                return true;
+            }
+        }
+        return false;
+    }
     async removePluginNativeCode(pluginData, projectData) {
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
         this.removeNativeSourceCode(pluginPlatformsFolderPath, pluginData, projectData);
@@ -881,23 +920,46 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
             project.removeFromHeaderSearchPaths({
                 relativePath: relativeHeaderSearchPath,
             });
+            // Remove the generated modulemap dir search path (see addStaticLibrary)
+            const modulemapDir = path.join(this.getPlatformData(projectData).projectRoot, IOSProjectService.GENERATED_PLUGINS_DIR_NAME, path.basename(staticLibPath, ".a"));
+            project.removeFromHeaderSearchPaths({
+                relativePath: this.getLibSubpathRelativeToProjectPath(modulemapDir, projectData),
+            });
         });
         this.savePbxProj(project, projectData);
     }
-    generateModulemap(headersFolderPath, libraryName) {
+    generateModulemap(headersFolderPath, libraryName, modulemapDir) {
+        const modulemapPath = path.join(modulemapDir, "module.modulemap");
+        // A plugin may ship a `.a` without an `include/{lib}` headers folder. In
+        // that case there's nothing to expose as a module - clean up any stale
+        // modulemap and bail out instead of letting readDirectory throw.
+        if (!this.$fs.exists(headersFolderPath)) {
+            if (this.$fs.exists(modulemapPath)) {
+                this.$fs.deleteFile(modulemapPath);
+            }
+            return false;
+        }
         const headersFilter = (fileName, containingFolderPath) => path.extname(fileName) === ".h" &&
             this.$fs.getFsStats(path.join(containingFolderPath, fileName)).isFile();
         const headersFolderContents = this.$fs.readDirectory(headersFolderPath);
-        let headers = _(headersFolderContents)
-            .filter((item) => headersFilter(item, headersFolderPath))
-            .value();
-        if (!headers.length) {
-            this.$fs.deleteFile(path.join(headersFolderPath, "module.modulemap"));
-            return;
+        const headerFiles = headersFolderContents.filter((item) => headersFilter(item, headersFolderPath));
+        if (!headerFiles.length) {
+            if (this.$fs.exists(modulemapPath)) {
+                this.$fs.deleteFile(modulemapPath);
+            }
+            return false;
         }
-        headers = _.map(headers, (value) => `header "${value}"`);
+        // Reference the plugin's headers (still in node_modules) relative to the
+        // generated modulemap's location, so we don't copy headers or write into
+        // node_modules.
+        const headers = _.map(headerFiles, (value) => {
+            const relativeHeaderPath = path.relative(modulemapDir, path.join(headersFolderPath, value));
+            return `header "${relativeHeaderPath}"`;
+        });
         const modulemap = `module ${libraryName} { explicit module ${libraryName} { ${headers.join(" ")} } }`;
-        this.$fs.writeFile(path.join(headersFolderPath, "module.modulemap"), modulemap);
+        this.$fs.ensureDirectoryExists(modulemapDir);
+        this.$fs.writeFile(modulemapPath, modulemap);
+        return true;
     }
     async mergeProjectXcconfigFiles(projectData) {
         const platformData = this.getPlatformData(projectData);
@@ -971,6 +1033,9 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
 exports.IOSProjectService = IOSProjectService;
 IOSProjectService.IOS_PROJECT_NAME_PLACEHOLDER = "__PROJECT_NAME__";
 IOSProjectService.IOS_PLATFORM_NAME = "ios";
+// CLI-managed folder under the platform root where we write generated
+// artifacts (e.g. plugin modulemaps) so we never write into node_modules
+IOSProjectService.GENERATED_PLUGINS_DIR_NAME = ".plugins";
 __decorate([
     (0, helpers_2.hook)("buildIOS")
 ], IOSProjectService.prototype, "buildProject", null);

package/lib/services/livesync/ios-livesync-service.js

@@ -11,6 +11,7 @@ const path = require("path");
 const ios_device_livesync_service_1 = require("./ios-device-livesync-service");
 const platform_livesync_service_base_1 = require("./platform-livesync-service-base");
 const constants_1 = require("../../constants");
+const constants_2 = require("../../common/constants");
 const decorators_1 = require("../../common/decorators");
 const yok_1 = require("../../common/yok");
 class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSyncServiceBase {
@@ -40,14 +41,124 @@ class IOSLiveSyncService extends platform_livesync_service_base_1.PlatformLiveSy
         await this.$fs.zipFiles(tempZip, filesToTransfer, (res) => {
             return path.join(constants_1.APP_FOLDER_NAME, path.relative(projectFilesPath, res));
         });
-        await device.fileSystem.transferFiles(deviceAppData, [
+        const deviceProjectRootPath = await deviceAppData.getDeviceProjectRootPath();
+        const transferSyncZip = () => device.fileSystem.transferFiles(deviceAppData, [
             {
                 getLocalPath: () => tempZip,
                 getDevicePath: () => deviceAppData.deviceSyncZipPath,
                 getRelativeToProjectBasePath: () => "../sync.zip",
-                deviceProjectRootPath: await deviceAppData.getDeviceProjectRootPath(),
+                deviceProjectRootPath,
             },
         ]);
+        // ── Fail-closed delivery verification ──────────────────────────
+        //
+        // The AFC transfer has been observed to fail without surfacing an
+        // error, leaving the app to boot the stale JavaScript baked into
+        // the installed .app payload with no indication anywhere that the
+        // sync was lost. After the transfer we therefore confirm the zip
+        // is actually present in the app sandbox; one retry covers
+        // transient AFC hiccups, and an unconfirmed delivery fails the
+        // sync loudly instead of printing "Successfully synced" over
+        // stale code (the run-controller surfaces the error; --clean
+        // reinstalls the full package).
+        //
+        // Presence alone is NOT sufficient evidence: a previous run that
+        // transferred the zip but aborted before the app restarted leaves
+        // a LEFTOVER sync.zip behind (the runtime only consumes it at
+        // boot), which would satisfy the check even when THIS upload
+        // failed. So any pre-existing zip is deleted up front — after
+        // that, post-transfer presence can only be produced by this run's
+        // upload.
+        //
+        // NOTE: deviceProjectRootPath is `.../LiveSync/app` (the extracted
+        // app folder); the zip is uploaded one level up, at the LiveSync
+        // root — the listing targets THAT directory.
+        //
+        // Escape hatch: NS_SKIP_IOS_SYNC_VERIFICATION=1 disables the
+        // whole verification for exotic setups where directory listing
+        // misbehaves but uploads are known-good.
+        const syncZipDevicePath = deviceAppData.deviceSyncZipPath;
+        const verificationSupported = !!device.fileSystem.getDirectoryEntries &&
+            process.env.NS_SKIP_IOS_SYNC_VERIFICATION !== "1";
+        const listLiveSyncRoot = () => device.fileSystem.getDirectoryEntries(constants_2.LiveSyncPaths.IOS_DEVICE_PROJECT_ROOT_PATH, deviceAppData.appIdentifier);
+        // Entry shape: ios-device-lib's native `read_dir` recursively joins
+        // `<requested dir>/<entry>` and returns FULL paths rooted at the
+        // requested directory (verified against IOSDeviceLib.cpp and live
+        // device output), so the canonical match is exact equality with
+        // `Library/Application Support/LiveSync/sync.zip`. The bare
+        // `"sync.zip"` equality is defensive cover for listing
+        // implementations that return root-relative names. Deliberately NO
+        // suffix matching — `endsWith("/sync.zip")` would false-positively
+        // accept a nested app asset like `.../LiveSync/app/sync.zip`.
+        const containsSyncZip = (entries) => entries.some((entry) => entry === syncZipDevicePath || entry === "sync.zip");
+        // "delivered" / "missing" are definitive listings; "unknown" means
+        // the listing itself could not be read (after one retry).
+        const checkDelivery = async () => {
+            let entries = await listLiveSyncRoot();
+            if (entries === null) {
+                entries = await listLiveSyncRoot();
+            }
+            if (entries === null) {
+                return "unknown";
+            }
+            return containsSyncZip(entries) ? "delivered" : "missing";
+        };
+        let preListingAvailable = false;
+        let leftoverZipPresent = false;
+        if (verificationSupported) {
+            // Clear any leftover zip so the post-transfer check attributes
+            // presence to this run. Best-effort: AFC "file not found" is
+            // tolerated inside deleteFile.
+            await device.fileSystem.deleteFile(syncZipDevicePath, deviceAppData.appIdentifier);
+            const preEntries = await listLiveSyncRoot();
+            preListingAvailable = Array.isArray(preEntries);
+            leftoverZipPresent = preListingAvailable && containsSyncZip(preEntries);
+        }
+        await transferSyncZip();
+        if (verificationSupported) {
+            if (leftoverZipPresent) {
+                // The pre-transfer delete did not take effect, so presence
+                // can no longer be attributed to this run. Most likely the
+                // upload succeeded too, but say so explicitly rather than
+                // claim verification.
+                this.$logger.warn("A leftover sync.zip from a previous run could not be removed — delivery verification for this sync is inconclusive. " +
+                    "If the app runs stale code, re-run the command or use a clean rebuild (--clean).");
+            }
+            else {
+                let state = await checkDelivery();
+                if (state === "missing") {
+                    this.$logger.warn("sync.zip was not found on the device after transfer — retrying once...");
+                    await transferSyncZip();
+                    state = await checkDelivery();
+                    if (state === "delivered") {
+                        this.$logger.info("sync.zip delivered on retry.");
+                    }
+                }
+                if (state === "missing") {
+                    throw new Error(`Unable to deliver the application payload (sync.zip) to device ${device.deviceInfo.identifier}. ` +
+                        `The app would run stale JavaScript without it. ` +
+                        `Re-run the command, or use a clean rebuild (--clean) to reinstall the full application package.`);
+                }
+                if (state === "unknown") {
+                    if (preListingAvailable) {
+                        // The listing worked moments before the upload and
+                        // broke right after it — the AFC session is
+                        // misbehaving at exactly the point where the upload
+                        // itself is suspect. Fail closed.
+                        throw new Error(`Unable to confirm delivery of the application payload (sync.zip) to device ${device.deviceInfo.identifier}: ` +
+                            `the device directory listing failed right after the transfer. ` +
+                            `Re-run the command, or use a clean rebuild (--clean) to reinstall the full application package. ` +
+                            `(Set NS_SKIP_IOS_SYNC_VERIFICATION=1 to bypass delivery verification.)`);
+                    }
+                    // Listing was unavailable both before and after the
+                    // transfer — verification is unsupported for this
+                    // device/session. This is the single fail-open path,
+                    // and it is loud rather than silent.
+                    this.$logger.warn("Could not verify sync.zip delivery (device directory listing unavailable). " +
+                        "If the transfer failed, the app will run stale JavaScript — re-run the command or use a clean rebuild (--clean).");
+                }
+            }
+        }
         await deviceAppData.device.applicationManager.setTransferredAppFiles(filesToTransfer);
         return {
             deviceAppData,

package/lib/services/plugins-service.js

@@ -107,6 +107,7 @@ class PluginsService {
         }
     }
     async preparePluginNativeCode({ pluginData, platform, projectData, }) {
+        var _a, _b, _c;
         const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(platform);
         if (this.$fs.exists(pluginPlatformsFolderPath)) {
@@ -114,8 +115,10 @@ class PluginsService {
             const allPluginsNativeHashes = this.getAllPluginsNativeHashes(pathToPluginsBuildFile);
             const oldPluginNativeHashes = allPluginsNativeHashes[pluginData.name];
             const currentPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
-            if (!oldPluginNativeHashes ||
-                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
+            const needsReprepare = !oldPluginNativeHashes ||
+                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes) ||
+                ((_c = (_b = (_a = platformData.platformProjectService).shouldRepreparePlugin) === null || _b === void 0 ? void 0 : _b.call(_a, pluginData, projectData)) !== null && _c !== void 0 ? _c : false);
+            if (needsReprepare) {
                 await platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
                 const updatedPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
                 this.setPluginNativeHashes({
@@ -366,7 +369,12 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     getNodeModuleData(module, projectDir) {
         // module can be  modulePath or moduleName
         if (!this.$fs.exists(module) || path.basename(module) !== "package.json") {
-            module = this.getPackageJsonFilePathForModule(module, projectDir);
+            const resolvedPath = this.getPackageJsonFilePathForModule(module, projectDir);
+            if (!resolvedPath) {
+                this.$logger.warn(`Could not find module ${color_1.color.yellow(module)}. It may have been removed or is not installed. Skipping.`);
+                return null;
+            }
+            module = resolvedPath;
         }
         const data = this.$fs.readJson(module);
         return {
@@ -384,7 +392,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     async getAllInstalledModules(projectData) {
         await this.ensure(projectData);
         const nodeModules = this.getDependencies(projectData.projectDir);
-        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir));
+        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir)).filter(Boolean);
     }
     async executeNpmCommand(npmCommandName, npmCommandArguments, projectData) {
         if (npmCommandName === PluginsService.INSTALL_COMMAND_NAME) {

package/lib/services/project-data-service.js

@@ -18,10 +18,11 @@ const yok_1 = require("../common/yok");
 const semver = require("semver");
 const package_path_helper_1 = require("../helpers/package-path-helper");
 class ProjectDataService {
-    constructor($fs, $staticConfig, $logger, $devicePlatformsConstants, $androidResourcesMigrationService, $injector) {
+    constructor($fs, $staticConfig, $logger, $projectData, $devicePlatformsConstants, $androidResourcesMigrationService, $injector) {
         this.$fs = $fs;
         this.$staticConfig = $staticConfig;
         this.$logger = $logger;
+        this.$projectData = $projectData;
         this.$devicePlatformsConstants = $devicePlatformsConstants;
         this.$androidResourcesMigrationService = $androidResourcesMigrationService;
         this.$injector = $injector;
@@ -373,20 +374,20 @@ class ProjectDataService {
         return this.getInstalledRuntimePackage(projectDir, platform);
     }
     getInstalledRuntimePackage(projectDir, platform) {
+        var _a, _b, _c, _d;
         const runtimePackage = this.$pluginsService
             .getDependenciesFromPackageJson(projectDir)
             .devDependencies.find((d) => {
+            var _a, _b, _c, _d;
             if (platform === "ios" /* constants.PlatformTypes.ios */) {
-                return [
-                    constants.SCOPED_IOS_RUNTIME_NAME,
-                    constants.TNS_IOS_RUNTIME_NAME,
-                ].includes(d.name);
+                const packageName = ((_b = (_a = this.$projectData.nsConfig) === null || _a === void 0 ? void 0 : _a.ios) === null || _b === void 0 ? void 0 : _b.runtimePackageName) ||
+                    constants.SCOPED_IOS_RUNTIME_NAME;
+                return [packageName, constants.TNS_IOS_RUNTIME_NAME].includes(d.name);
             }
             else if (platform === "android" /* constants.PlatformTypes.android */) {
-                return [
-                    constants.SCOPED_ANDROID_RUNTIME_NAME,
-                    constants.TNS_ANDROID_RUNTIME_NAME,
-                ].includes(d.name);
+                const packageName = ((_d = (_c = this.$projectData.nsConfig) === null || _c === void 0 ? void 0 : _c.android) === null || _d === void 0 ? void 0 : _d.runtimePackageName) ||
+                    constants.SCOPED_ANDROID_RUNTIME_NAME;
+                return [packageName, constants.TNS_ANDROID_RUNTIME_NAME].includes(d.name);
             }
             else if (platform === "visionos" /* constants.PlatformTypes.visionos */) {
                 return d.name === constants.SCOPED_VISIONOS_RUNTIME_NAME;
@@ -424,13 +425,15 @@ class ProjectDataService {
         this.$logger.trace("Could not find an installed runtime, falling back to default runtimes");
         if (platform === "ios" /* constants.PlatformTypes.ios */) {
             return {
-                name: constants.SCOPED_IOS_RUNTIME_NAME,
+                name: ((_b = (_a = this.$projectData.nsConfig) === null || _a === void 0 ? void 0 : _a.ios) === null || _b === void 0 ? void 0 : _b.runtimePackageName) ||
+                    constants.SCOPED_IOS_RUNTIME_NAME,
                 version: null,
             };
         }
         else if (platform === "android" /* constants.PlatformTypes.android */) {
             return {
-                name: constants.SCOPED_ANDROID_RUNTIME_NAME,
+                name: ((_d = (_c = this.$projectData.nsConfig) === null || _c === void 0 ? void 0 : _c.android) === null || _d === void 0 ? void 0 : _d.runtimePackageName) ||
+                    constants.SCOPED_ANDROID_RUNTIME_NAME,
                 version: null,
             };
         }

package/node_modules/debug/LICENSE

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2018-2021 Josh Junon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the 'Software'), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+