nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/services/extensibility-service.js

@@ -12,7 +12,55 @@ const _ = require("lodash");
 const decorators_1 = require("../common/decorators");
 const constants = require("../constants");
 const helpers_1 = require("../common/helpers");
+const deprecation_1 = require("../common/deprecation");
 const yok_1 = require("../common/yok");
+const constants_1 = require("../common/constants");
+const inject_1 = require("../common/di/inject");
+const contracts_1 = require("../common/contracts");
+const define_command_1 = require("../common/define-command");
+const command_definition_adapter_1 = require("../common/services/command-definition-adapter");
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isCommandsMap(commands) {
+    return !!commands && typeof commands === "object" && !Array.isArray(commands);
+}
+function getEntryModulePath(value) {
+    if (isNonEmptyString(value)) {
+        return value;
+    }
+    if (value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        isNonEmptyString(value.path)) {
+        return value.path;
+    }
+    return null;
+}
+const isDefaultCommandName = (name) => name.indexOf(constants_1.CommandsDelimiters.DefaultHierarchicalCommand) !== -1;
+function describeRejection(rejection) {
+    switch (rejection.reason) {
+        case "invalid-name":
+            return rejection.detail;
+        case "claimed":
+            return `it is already registered by extension ${rejection.owner}`;
+        case "built-in":
+            return "it is already provided by the CLI";
+        case "subcommand-parent":
+            return "it is already in use as the parent of its subcommands";
+        case "parent-is-command":
+            return `'${rejection.parent}' is already registered as a command of its own, so the subcommand could never be reached`;
+    }
+}
+function getDeclaredCommandNames(commands, opts) {
+    if (Array.isArray(commands)) {
+        return opts && opts.copy ? commands.slice() : commands;
+    }
+    if (isCommandsMap(commands)) {
+        return _.keys(commands);
+    }
+    return null;
+}
 class ExtensibilityService {
     get pathToPackageJson() {
         return path.join(this.pathToExtensions, constants.PACKAGE_JSON_FILE_NAME);
@@ -24,13 +72,15 @@ class ExtensibilityService {
     set pathToExtensions(pathToExtensions) {
         this.customPathToExtensions = pathToExtensions;
     }
-    constructor($fs, $logger, $packageManager, $settingsService, $requireService) {
+    constructor($fs, $logger, $packageManager, $settingsService, $requireService, $injector) {
         this.$fs = $fs;
         this.$logger = $logger;
         this.$packageManager = $packageManager;
         this.$settingsService = $settingsService;
         this.$requireService = $requireService;
+        this.$injector = $injector;
         this.customPathToExtensions = null;
+        this.commandRegistry = (0, inject_1.inject)(contracts_1.CommandRegistry);
     }
     async installExtension(extensionName) {
         this.$logger.trace(`Start installation of extension '${extensionName}'.`);
@@ -83,18 +133,36 @@ class ExtensibilityService {
             packageJsonData.nativescript &&
             packageJsonData.nativescript.docs &&
             path.join(pathToExtension, packageJsonData.nativescript.docs);
-        return {
+        const result = {
             extensionName: packageJsonData.name,
             version: packageJsonData.version,
             docs,
             pathToExtension,
         };
+        const commands = getDeclaredCommandNames(packageJsonData &&
+            packageJsonData.nativescript &&
+            packageJsonData.nativescript.commands);
+        if (commands) {
+            result.commands = commands;
+        }
+        return result;
     }
     async loadExtension(extensionName) {
         try {
             await this.assertExtensionIsInstalled(extensionName);
             const pathToExtension = this.getPathToExtension(extensionName);
-            this.$requireService.require(pathToExtension);
+            const commandsMap = this.getDeclaredCommandsMap(extensionName);
+            if (commandsMap) {
+                this.registerDeclaredCommands(extensionName, pathToExtension, commandsMap);
+            }
+            else {
+                (0, deprecation_1.reportDeprecation)({
+                    api: "extensions.require-time-registration",
+                    detail: extensionName,
+                    logger: this.$logger,
+                });
+                this.$requireService.require(pathToExtension);
+            }
             return this.getInstalledExtensionData(extensionName);
         }
         catch (error) {
@@ -119,17 +187,12 @@ class ExtensibilityService {
         for (const extensionData of allExtensions) {
             const extensionName = extensionData.package.name;
             try {
-                // now get full package.json for the latest version of the package
                 const registryData = await this.$packageManager.getRegistryPackageData(extensionName);
                 const latestPackageData = registryData.versions[registryData["dist-tags"].latest];
-                const commands = latestPackageData &&
+                const commands = getDeclaredCommandNames(latestPackageData &&
                     latestPackageData.nativescript &&
-                    latestPackageData.nativescript.commands;
+                    latestPackageData.nativescript.commands, { copy: true });
                 if (commands && commands.length) {
-                    // For each default command we need to add its short syntax in the array of commands.
-                    // For example in case there's a default command called devices list, the commands array will contain devices|*list.
-                    // However, in case the user executes just ns devices, CLI will still execute the ns devices list command.
-                    // So we need to add the devices command as well.
                     _.filter(commands, (command) => command.indexOf(inputOpts.defaultCommandDelimiter) !== -1).forEach((defaultCommand) => {
                         commands.push(defaultCommand.replace(defaultCommandRegExp, ""));
                     });
@@ -151,12 +214,64 @@ class ExtensibilityService {
                 }
             }
             catch (err) {
-                // We do not want to stop the whole process in case we are unable to find data for one of the extensions.
                 this.$logger.trace(`Unable to get data for ${extensionName}. Error is: ${err}`);
             }
         }
         return null;
     }
+    getDeclaredCommandsMap(extensionName) {
+        let commands;
+        try {
+            const packageJsonData = this.getExtensionPackageJsonData(extensionName);
+            commands =
+                packageJsonData &&
+                    packageJsonData.nativescript &&
+                    packageJsonData.nativescript.commands;
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to read the package.json of extension ${extensionName}. Error is: ${err}`);
+            return null;
+        }
+        return isCommandsMap(commands) ? commands : null;
+    }
+    registerDeclaredCommands(extensionName, pathToExtension, commands) {
+        const commandNames = _.sortBy(_.keys(commands), (commandName) => isDefaultCommandName(commandName) ? 0 : 1);
+        for (const commandName of commandNames) {
+            const modulePath = getEntryModulePath(commands[commandName]);
+            if (!isNonEmptyString(commandName) || !modulePath) {
+                this.$logger.warn(`Extension ${extensionName} declares an invalid command in its nativescript.commands: '${commandName}': ${JSON.stringify(commands[commandName])}. The command name must be a non-empty string and its value either the path to its module or an object with a non-empty 'path'. Skipping this command.`);
+                continue;
+            }
+            const absoluteModulePath = path.join(pathToExtension, modulePath);
+            const result = this.commandRegistry.registerDeferredCommand(commandName, {
+                owner: extensionName,
+                source: absoluteModulePath,
+                load: () => this.loadDeclaredCommand(extensionName, commandName, absoluteModulePath),
+            });
+            if (!result.registered) {
+                this.$logger.warn(`Extension ${extensionName} is unable to register command '${commandName}': ${describeRejection(result.rejection)}.`);
+            }
+        }
+    }
+    loadDeclaredCommand(extensionName, commandName, absoluteModulePath) {
+        var _a;
+        const exported = require(absoluteModulePath);
+        const candidate = (_a = (exported && exported.default)) !== null && _a !== void 0 ? _a : exported;
+        if (!(0, define_command_1.isCommandDefinition)(candidate)) {
+            return;
+        }
+        this.warnOnDeclaredNameMismatch(extensionName, commandName, absoluteModulePath, candidate);
+        (0, command_definition_adapter_1.registerDefinitionAs)(commandName, candidate, this.$injector);
+    }
+    warnOnDeclaredNameMismatch(extensionName, commandName, absoluteModulePath, definition) {
+        const declaredNames = Array.isArray(definition.name)
+            ? definition.name
+            : [definition.name];
+        if (_.includes(declaredNames, commandName)) {
+            return;
+        }
+        this.$logger.warn(`Extension ${extensionName} declares command '${commandName}' in its package.json, but the definition in ${absoluteModulePath} names itself '${declaredNames.join("', '")}'. The command runs as '${commandName}' - the manifest decides how it is invoked.`);
+    }
     getPathToExtension(extensionName) {
         return path.join(this.pathToExtensions, constants.NODE_MODULES_FOLDER_NAME, extensionName);
     }
@@ -184,7 +299,6 @@ class ExtensibilityService {
         this.assertExtensionsDirExists();
         if (!this.$fs.exists(this.pathToPackageJson)) {
             this.$logger.trace(`Creating ${this.pathToPackageJson}.`);
-            // create default package.json
             this.$fs.writeJson(this.pathToPackageJson, {
                 name: "nativescript-extensibility",
                 version: "1.0.0",
@@ -206,4 +320,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], ExtensibilityService.prototype, "assertPackageJsonExists", null);
 yok_1.injector.register("extensibilityService", ExtensibilityService);
-//# sourceMappingURL=extensibility-service.js.map

package/lib/services/files-hash-service.d.ts

@@ -0,0 +1,17 @@
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IPlatformData } from "../definitions/platform";
+import { IFileSystem, IStringDictionary } from "../common/declarations";
+import { IOptions } from "../declarations";
+export declare class FilesHashService implements IFilesHashService {
+    private $fs;
+    private $logger;
+    private $options;
+    constructor($fs: IFileSystem, $logger: ILogger, $options: IOptions);
+    generateHashes(files: string[]): Promise<IStringDictionary>;
+    generateHashesForProject(platformData: IPlatformData): Promise<IStringDictionary>;
+    saveHashesForProject(platformData: IPlatformData, hashesFileDirectory: string): Promise<IStringDictionary>;
+    getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary>;
+    hasChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): boolean;
+    saveHashes(hashes: IStringDictionary, hashesFileDirectory: string): void;
+    getChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): IStringDictionary;
+}

package/lib/services/files-hash-service.js

@@ -61,4 +61,3 @@ class FilesHashService {
 }
 exports.FilesHashService = FilesHashService;
 yok_1.injector.register("filesHashService", FilesHashService);
-//# sourceMappingURL=files-hash-service.js.map

package/lib/services/hmr-status-service.d.ts

@@ -0,0 +1,19 @@
+export declare class HmrStatusService implements IHmrStatusService {
+    private $logParserService;
+    private $devicePlatformsConstants;
+    private $logger;
+    static HMR_STATUS_LOG_REGEX: RegExp;
+    static STARTED_MESSAGE: string;
+    static SUCCESS_MESSAGE: string;
+    static FAILED_MESSAGE: string;
+    private hashOperationStatuses;
+    private intervals;
+    constructor($logParserService: ILogParserService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logger: ILogger);
+    getHmrStatus(deviceId: string, operationHash: string): Promise<number>;
+    watchHmrStatus(deviceId: string, operationHash: string): void;
+    attachToHmrStatusEvent(): void;
+    private handleAppCrash;
+    private handleHmrStatusFound;
+    private getStatusByKey;
+    private setData;
+}

package/lib/services/hmr-status-service.js

@@ -56,7 +56,6 @@ class HmrStatusService {
             name: "failedLiveSync",
             platform: this.$devicePlatformsConstants.iOS.toLowerCase(),
         });
-        // webpack5
         const statusStringMap = {
             success: constants_1.HmrConstants.HMR_SUCCESS_STATUS,
             failure: constants_1.HmrConstants.HMR_ERROR_STATUS,
@@ -127,4 +126,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], HmrStatusService.prototype, "attachToHmrStatusEvent", null);
 yok_1.injector.register("hmrStatusService", HmrStatusService);
-//# sourceMappingURL=hmr-status-service.js.map

package/lib/services/info-service.d.ts

@@ -0,0 +1,6 @@
+import { IInfoService, IVersionsService } from "../declarations";
+export declare class InfoService implements IInfoService {
+    private $versionsService;
+    constructor($versionsService: IVersionsService);
+    printComponentsInfo(): Promise<void>;
+}

package/lib/services/info-service.js

@@ -12,4 +12,3 @@ class InfoService {
 }
 exports.InfoService = InfoService;
 yok_1.injector.register("infoService", InfoService);
-//# sourceMappingURL=info-service.js.map

package/lib/services/initialize-service.d.ts

@@ -0,0 +1,8 @@
+import { IInitializeOptions, IInitializeService } from "../definitions/initialize-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class InitializeService implements IInitializeService {
+    private $injector;
+    constructor($injector: IInjector);
+    initialize(initOpts?: IInitializeOptions): Promise<void>;
+    private showWarnings;
+}

package/lib/services/initialize-service.js

@@ -5,9 +5,8 @@ const os_1 = require("os");
 const _ = require("lodash");
 const constants_1 = require("../constants");
 const yok_1 = require("../common/yok");
+const system_warnings_1 = require("../definitions/system-warnings");
 class InitializeService {
-    // NOTE: Do not inject anything here, use $injector.resolve in the code
-    // Injecting something may lead to logger initialization, but we want to initialize it from here.
     constructor($injector) {
         this.$injector = $injector;
     }
@@ -35,7 +34,6 @@ class InitializeService {
             }
         }
         if ($options.json) {
-            // speed up --json commands by not gathering system warnings...
             $logger.trace("Skipping system warnings for --json commands");
         }
         else {
@@ -47,7 +45,7 @@ class InitializeService {
         const systemWarnings = await $sysInfo.getSystemWarnings();
         _.each(systemWarnings, (systemWarning) => {
             const message = `${os_1.EOL}${systemWarning.message}${os_1.EOL}`;
-            if (systemWarning.severity === "high" /* SystemWarningsSeverity.high */) {
+            if (systemWarning.severity === system_warnings_1.SystemWarningsSeverity.high) {
                 $logger.error(message);
             }
             else {
@@ -58,4 +56,3 @@ class InitializeService {
 }
 exports.InitializeService = InitializeService;
 yok_1.injector.register("initializeService", InitializeService);
-//# sourceMappingURL=initialize-service.js.map

package/lib/services/ios/export-options-plist-service.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData, IBuildConfig } from "../../definitions/project";
+import { IFileSystem } from "../../common/declarations";
+import { ITempService } from "../../definitions/temp-service";
+export declare class ExportOptionsPlistService implements IExportOptionsPlistService {
+    private $fs;
+    private $tempService;
+    private $projectData;
+    constructor($fs: IFileSystem, $tempService: ITempService, $projectData: IProjectData);
+    private getExtensionProvisions;
+    createDevelopmentExportOptionsPlist(archivePath: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<IExportOptionsPlistOutput>;
+    createDistributionExportOptionsPlist(archivePath: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<IExportOptionsPlistOutput>;
+    private getExportOptionsMethod;
+}

package/lib/services/ios/export-options-plist-service.js

@@ -54,13 +54,11 @@ class ExportOptionsPlistService {
         plistTemplate += `
 </dict>
 </plist>`;
-        // Save the options...
         const exportOptionsPlistFilePath = await this.$tempService.path({
             prefix: "export-",
             suffix: ".plist",
         });
         this.$fs.writeFile(exportOptionsPlistFilePath, plistTemplate);
-        // The xcodebuild exportPath expects directory and writes the <project-name>.ipa at that directory.
         const exportFileDir = path.resolve(path.dirname(archivePath));
         const exportFilePath = path.join(exportFileDir, projectData.projectName + ".ipa");
         return { exportFileDir, exportFilePath, exportOptionsPlistFilePath };
@@ -98,7 +96,6 @@ class ExportOptionsPlistService {
     <false/>
 </dict>
 </plist>`;
-        // Save the options...
         const exportOptionsPlistFilePath = await this.$tempService.path({
             prefix: "export-",
             suffix: ".plist",
@@ -121,4 +118,3 @@ class ExportOptionsPlistService {
 }
 exports.ExportOptionsPlistService = ExportOptionsPlistService;
 yok_1.injector.register("exportOptionsPlistService", ExportOptionsPlistService);
-//# sourceMappingURL=export-options-plist-service.js.map

package/lib/services/ios/ios-signing-service.d.ts

@@ -0,0 +1,33 @@
+import * as mobileProvisionFinder from "ios-mobileprovision-finder";
+import { IOSProvisionService } from "../ios-provision-service";
+import { IOSBuildData } from "../../data/build-data";
+import { IOptions, IXcconfigService, IXcprojService } from "../../declarations";
+import { IProjectData } from "../../definitions/project";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare class IOSSigningService implements IiOSSigningService {
+    private $errors;
+    private $fs;
+    private $iOSProvisionService;
+    private $logger;
+    private $options;
+    private $pbxprojDomXcode;
+    private $prompter;
+    private $xcconfigService;
+    private $xcprojService;
+    constructor($errors: IErrors, $fs: IFileSystem, $iOSProvisionService: IOSProvisionService, $logger: ILogger, $options: IOptions, $pbxprojDomXcode: IPbxprojDomXcode, $prompter: IPrompter, $xcconfigService: IXcconfigService, $xcprojService: IXcprojService);
+    setupSigningForDevice(projectRoot: string, projectData: IProjectData, iOSBuildData: IOSBuildData): Promise<void>;
+    setupSigningFromTeam(projectRoot: string, projectData: IProjectData, teamId: string): Promise<void>;
+    setupSigningFromProvision(projectRoot: string, projectData: IProjectData, provision?: string, mobileProvisionData?: mobileProvisionFinder.provision.MobileProvision): Promise<void>;
+    private getExtensionNames;
+    private getExtensionsManualSigningConfiguration;
+    private getManualSigningConfiguration;
+    private getBuildXCConfigFilePath;
+    private getPbxProjPath;
+    private readTeamIdFromFile;
+    private getDevelopmentTeam;
+    private readXCConfigDevelopmentTeam;
+    private readXCConfigProvisioningProfile;
+    private readXCConfigProvisioningProfileForIPhoneOs;
+    private readXCConfigProvisioningProfileSpecifier;
+    private readXCConfigProvisioningProfileSpecifierForIPhoneOs;
+}

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

@@ -46,7 +46,6 @@ class IOSSigningService {
         let shouldUpdateXcode = false;
         if (signing && signing.style === "Automatic") {
             if (signing.team !== teamId) {
-                // Maybe the provided team is name such as "Telerik AD" and we need to convert it to CH******37
                 const teamIdsForName = await this.$iOSProvisionService.getTeamIdsWithName(teamId);
                 if (!teamIdsForName.some((id) => id === signing.team)) {
                     shouldUpdateXcode = true;
@@ -80,7 +79,6 @@ class IOSSigningService {
     }
     async setupSigningFromProvision(projectRoot, projectData, provision, mobileProvisionData) {
         if (!provision) {
-            // read uuid from Xcode an cache...
             return;
         }
         const xcode = this.$pbxprojDomXcode.Xcode.open(this.getPbxProjPath(projectData, projectRoot));
@@ -113,7 +111,6 @@ class IOSSigningService {
                 this.$logger.trace(`Set Manual signing style and provisioning profile: ${configuration.name} (${configuration.uuid})`);
             });
             xcode.save();
-            // this.cache(uuid);
         }
         else {
             this.$logger.trace(`The specified provisioning profile is already set in the Xcode: ${provision}`);
@@ -276,4 +273,3 @@ class IOSSigningService {
 }
 exports.IOSSigningService = IOSSigningService;
 yok_1.injector.register("iOSSigningService", IOSSigningService);
-//# sourceMappingURL=ios-signing-service.js.map

package/lib/services/ios/spm-pbxproj-service.d.ts

@@ -0,0 +1,16 @@
+import { IFileSystem } from "../../common/declarations";
+export declare class SPMPbxprojService implements ISPMPbxprojService {
+    private $fs;
+    private $logger;
+    private $xcode;
+    constructor($fs: IFileSystem, $logger: ILogger, $xcode: IXcode);
+    addPackages(projectRoot: string, assignments: IosSPMPackageAssignment[]): boolean;
+    private findPbxProjPath;
+    private findTargetId;
+    private addPackageToTarget;
+    private findFrameworksBuildPhase;
+    private addOrUpdateArrayEntry;
+    private addOrUpdateEntry;
+    private findUuidByComment;
+}
+export declare function classifyVersion(version: string): Record<string, string>;