@akylas/nativescript-cli 8.7.2

package/lib/common/decorators.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecated = exports.performanceLog = exports.exported = exports.invokeInit = exports.invokeBefore = exports.memoize = exports.cache = void 0;
+const constants_1 = require("../constants");
+const yok_1 = require("./yok");
+function cache() {
+    return (target, propertyKey, descriptor) => {
+        let result;
+        const propName = descriptor.value ? "value" : "get";
+        const originalValue = descriptor[propName];
+        descriptor[propName] = function (...args) {
+            const propertyName = `__isCalled_${propertyKey}__`;
+            if (this && !this[propertyName]) {
+                this[propertyName] = true;
+                result = originalValue.apply(this, args);
+            }
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.cache = cache;
+let memoizeIDCounter = 0;
+function memoize(options) {
+    return (target, propertyKey, descriptor) => {
+        const DEBUG = false;
+        const memoizeID = memoizeIDCounter++;
+        const valueOrGet = descriptor.value ? "value" : "get";
+        const originalMethod = descriptor[valueOrGet];
+        descriptor[valueOrGet] = function (...args) {
+            const cacheMapName = `__memoize_cache_map_${memoizeID}`;
+            DEBUG && console.log(options);
+            let hashKey;
+            if (options.hashFn) {
+                DEBUG && console.log({ args });
+                hashKey = options.hashFn.apply(this, args);
+            }
+            else {
+                hashKey = `__memoize_cache_value_${memoizeID}`;
+            }
+            DEBUG &&
+                console.log({
+                    cacheMapName,
+                    hashKey,
+                });
+            if (!this.hasOwnProperty(cacheMapName)) {
+                DEBUG && console.log("NO CACHE MAP YET, CREATING ONE NOW");
+                Object.defineProperty(this, cacheMapName, {
+                    configurable: false,
+                    enumerable: false,
+                    writable: false,
+                    value: new Map(),
+                });
+            }
+            const cacheMap = this[cacheMapName];
+            DEBUG &&
+                console.log({
+                    cacheMap,
+                });
+            if (cacheMap.has(hashKey)) {
+                DEBUG && console.log("CACHE HIT");
+                return cacheMap.get(hashKey);
+            }
+            DEBUG && console.log("CACHE MISS");
+            const result = originalMethod.apply(this, args);
+            let shouldCache = true;
+            if (options.shouldCache) {
+                shouldCache = options.shouldCache.call(this, result);
+            }
+            DEBUG && console.log("GOT BACK SHOULDCACHE", shouldCache);
+            if (shouldCache) {
+                DEBUG && console.log("CACHING NOW");
+                cacheMap.set(hashKey, result);
+            }
+            DEBUG && console.log("RETURNING", result);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.memoize = memoize;
+function invokeBefore(methodName, methodArgs) {
+    return (target, propertyKey, descriptor) => {
+        const originalValue = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield target[methodName].apply(this, methodArgs);
+                return originalValue.apply(this, args);
+            });
+        };
+        return descriptor;
+    };
+}
+exports.invokeBefore = invokeBefore;
+function invokeInit() {
+    return invokeBefore("init");
+}
+exports.invokeInit = invokeInit;
+function exported(moduleName) {
+    return (target, propertyKey, descriptor) => {
+        yok_1.injector.publicApi.__modules__[moduleName] =
+            yok_1.injector.publicApi.__modules__[moduleName] || {};
+        yok_1.injector.publicApi.__modules__[moduleName][propertyKey] = (...args) => {
+            const originalModule = yok_1.injector.resolve(moduleName), originalMethod = originalModule[propertyKey], result = originalMethod.apply(originalModule, args);
+            return result;
+        };
+        return descriptor;
+    };
+}
+exports.exported = exported;
+function performanceLog(localInjector) {
+    localInjector = localInjector || yok_1.injector;
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const trackName = `${className}${constants_1.AnalyticsEventLabelDelimiter}${propertyKey}`;
+        const performanceService = localInjector.resolve("performanceService");
+        const functionWrapper = {
+            [originalMethod.name]: function (...args) {
+                const start = performanceService.now();
+                const result = originalMethod.apply(this, args);
+                const resolvedPromise = Promise.resolve(result);
+                let end;
+                if (resolvedPromise !== result) {
+                    end = performanceService.now();
+                    performanceService.processExecutionData(trackName, start, end, args);
+                }
+                else {
+                    resolvedPromise
+                        .then(() => {
+                        end = performanceService.now();
+                        performanceService.processExecutionData(trackName, start, end, args);
+                    })
+                        .catch((err) => {
+                        end = performanceService.now();
+                        performanceService.processExecutionData(trackName, start, end, args);
+                    });
+                }
+                return result;
+            },
+        };
+        descriptor.value = functionWrapper[originalMethod.name];
+        descriptor.value.toString = () => {
+            return originalMethod.toString();
+        };
+        return descriptor;
+    };
+}
+exports.performanceLog = performanceLog;
+function deprecated(additionalInfo, localInjector) {
+    const isDeprecatedMessage = " is deprecated.";
+    return (target, key, descriptor) => {
+        localInjector = localInjector || yok_1.injector;
+        additionalInfo = additionalInfo || "";
+        const $logger = localInjector.resolve("logger");
+        if (descriptor) {
+            if (descriptor.value) {
+                const originalMethod = descriptor.value;
+                descriptor.value = function (...args) {
+                    $logger.warn(`${key.toString()}${isDeprecatedMessage} ${additionalInfo}`);
+                    return originalMethod.apply(this, args);
+                };
+                return descriptor;
+            }
+            else {
+                if (descriptor.set) {
+                    const originalSetter = descriptor.set;
+                    descriptor.set = function (...args) {
+                        $logger.warn(`${key.toString()}${isDeprecatedMessage} ${additionalInfo}`);
+                        originalSetter.apply(this, args);
+                    };
+                }
+                if (descriptor.get) {
+                    const originalGetter = descriptor.get;
+                    descriptor.get = function (...args) {
+                        $logger.warn(`${key.toString()}${isDeprecatedMessage} ${additionalInfo}`);
+                        return originalGetter.apply(this, args);
+                    };
+                }
+                return descriptor;
+            }
+        }
+        else {
+            $logger.warn(`${(target &&
+                (target.name ||
+                    (target.constructor && target.constructor.name))) ||
+                target}${isDeprecatedMessage} ${additionalInfo}`);
+            return target;
+        }
+    };
+}
+exports.deprecated = deprecated;

package/lib/common/definitions/cli-global.d.ts

@@ -0,0 +1,22 @@
+import { IInjector } from "./yok";
+
+declare var _: _.LoDashStatic;
+/**
+ * Defines additional properties added to global object from CLI.
+ */
+interface ICliGlobal extends NodeJS.Global {
+	/**
+	 * Lodash instance.
+	 */
+	_: _.LoDashStatic;
+
+	/**
+	 * Global instance of the module used for dependency injection.
+	 */
+	$injector: IInjector;
+
+	/**
+	 * Instance of xmlhttprequest.
+	 */
+	XMLHttpRequest: any;
+}

package/lib/common/definitions/commands-service.d.ts

@@ -0,0 +1,27 @@
+interface ICommandsService {
+	currentCommandData: ICommandData;
+	allCommands(opts: { includeDevCommands: boolean }): string[];
+	tryExecuteCommand(
+		commandName: string,
+		commandArguments: string[]
+	): Promise<void>;
+	executeCommandUnchecked(
+		commandName: string,
+		commandArguments: string[]
+	): Promise<boolean>;
+}
+
+/**
+ * Describes the command data.
+ */
+interface ICommandData {
+	/**
+	 * Name of the command, usually the one registered in bootstrap.
+	 */
+	commandName: string;
+
+	/**
+	 * Additional arguments passed to the command.
+	 */
+	commandArguments: string[];
+}

package/lib/common/definitions/commands.d.ts

@@ -0,0 +1,51 @@
+import { IDictionary, IDashedOption, ICommandOptions } from "../declarations";
+
+interface ICommand extends ICommandOptions {
+	execute(args: string[]): Promise<void>;
+	allowedParameters: ICommandParameter[];
+
+	isDisabled?: boolean;
+
+	// Implement this method in cases when you want to have your own logic for validation. In case you do not implement it,
+	// the command will be evaluated from CommandsService's canExecuteCommand method.
+	// One possible case where you can use this method is when you have two commandParameters, neither of them is mandatory,
+	// but at least one of them is required. Used in prop|add, prop|set, etc. commands as their logic is complicated and
+	// default validation in CommandsService is not applicable.
+	canExecute?(args: string[]): Promise<boolean>;
+	completionData?: string[];
+	dashedOptions?: IDictionary<IDashedOption>;
+	isHierarchicalCommand?: boolean;
+
+	/**
+	 * Describes the action that will be executed after the command succeeds.
+	 * @param {string[]} args Arguments passed to the command.
+	 * @returns {Promise<void>}
+	 */
+	postCommandAction?(args: string[]): Promise<void>;
+}
+
+interface ICanExecuteCommandOptions {
+	validateOptions?: boolean;
+	notConfiguredEnvOptions?: INotConfiguredEnvOptions;
+}
+
+interface INotConfiguredEnvOptions {
+	hideCloudBuildOption?: boolean;
+}
+
+interface ISimilarCommand {
+	name: string;
+	rating: number;
+}
+
+interface ICommandArgument {}
+
+interface ICommandParameter {
+	mandatory: boolean;
+	errorMessage?: string;
+	validate(value: string, errorMessage?: string): Promise<boolean>;
+}
+
+interface IStringParameterBuilder {
+	createMandatoryParameter(errorMsg: string): ICommandParameter;
+}

package/lib/common/definitions/config.d.ts

@@ -0,0 +1,33 @@
+declare module Config {
+	interface IStaticConfig {
+		PROJECT_FILE_NAME: string;
+		CLIENT_NAME_KEY_IN_PROJECT_FILE?: string;
+		CLIENT_NAME: string;
+		USER_AGENT_NAME: string;
+		CLIENT_NAME_ALIAS?: string;
+		FULL_CLIENT_NAME?: string;
+		ANALYTICS_INSTALLATION_ID_SETTING_NAME: string;
+		TRACK_FEATURE_USAGE_SETTING_NAME: string;
+		ERROR_REPORT_SETTING_NAME: string;
+		version: string;
+		cliBinPath: string;
+		getAdbFilePath(): Promise<string>;
+		disableAnalytics?: boolean;
+		disableCommandHooks?: boolean;
+		enableDeviceRunCommandOnWindows?: boolean;
+		MAN_PAGES_DIR: string;
+		HTML_PAGES_DIR: string;
+		HTML_COMMON_HELPERS_DIR: string;
+		HTML_CLI_HELPERS_DIR: string;
+		pathToPackageJson: string;
+		RESOURCE_DIR_PATH: string;
+		PATH_TO_BOOTSTRAP: string;
+		QR_SIZE: number;
+		PROFILE_DIR_NAME: string;
+	}
+
+	interface IConfig {
+		DEBUG?: boolean;
+		DISABLE_HOOKS: boolean;
+	}
+}

package/lib/common/definitions/extensibility.d.ts

@@ -0,0 +1,147 @@
+import { IStringDictionary } from "../declarations";
+
+/**
+ * Describes extension name data.
+ */
+interface IExtensionName {
+	/**
+	 * The name of the extension.
+	 */
+	extensionName: string;
+}
+
+/**
+ * Describes each extension.
+ */
+interface IExtensionData extends IExtensionName {
+	/**
+	 * Extension version.
+	 */
+	version: string;
+
+	/**
+	 * Describes the location of the .md files containing the help of the commands included in the extension.
+	 * The property will contain the full path to the extension docs, constructed by getting the value of the docs key in nativescript key of the extensions package.json
+	 * and joining it with the full extension path. As some extensions may not have docs, the property may not be set.
+	 */
+	docs?: string;
+
+	/**
+	 * Full path to the directory of the installed extension.
+	 */
+	pathToExtension: string;
+}
+
+/**
+ * Describes the object passed to getExtensionNameWhereCommandIsRegistered
+ */
+interface IGetExtensionCommandInfoParams {
+	/**
+	 * All input strings specified by user.
+	 */
+	inputStrings: string[];
+
+	/**
+	 * The separator that is used between each strings when command is registered.
+	 */
+	commandDelimiter: string;
+
+	/**
+	 * The default separator that is used between each strings when command is registered.
+	 */
+	defaultCommandDelimiter: string;
+}
+
+/**
+ * Describes information in which extension a command is registered.
+ */
+interface IExtensionCommandInfo extends IExtensionName {
+	/**
+	 * The name of the command registered in the extension.
+	 */
+	registeredCommandName: string;
+
+	/**
+	 * Information how to install the extension.
+	 */
+	installationMessage: string;
+}
+
+/**
+ * Defines methods for working with CLI's extensions.
+ */
+interface IExtensibilityService {
+	/**
+	 * Installs a specified extension.
+	 * @param {string} extensionName Name of the extension to be installed. It may contain version as well, i.e. myPackage, myPackage@1.0.0,
+	 * myPackage.tgz, https://github.com/myOrganization/myPackage/tarball/master, https://github.com/myOrganization/myPackage, etc.
+	 * @returns {Promise<IExtensionData>} Information about installed extensions.
+	 */
+	installExtension(extensionName: string): Promise<IExtensionData>;
+
+	/**
+	 * Uninstalls extension from the installation.
+	 * @param {string} extensionName Name of the extension to be uninstalled.
+	 * @returns {Promise<void>}
+	 */
+	uninstallExtension(extensionName: string): Promise<void>;
+
+	/**
+	 * Removes all installed extensions.
+	 * @returns {void}
+	 */
+	removeAllExtensions(): void;
+
+	/**
+	 * Loads all extensions, so their methods and commands can be used from CLI.
+	 * For each of the extensions, a new Promise is returned. It will be rejected in case the extension cannot be loaded. However other promises will not be reflected by this failure.
+	 * In case a promise is rejected, the error will have additional property (extensionName) that shows which is the extension that cannot be loaded in the process.
+	 * @returns {Promise<IExtensionData>[]} Array of promises, each is resolved with information about loaded extension.
+	 */
+	loadExtensions(): Promise<IExtensionData>[];
+
+	/**
+	 * Loads a single extension, so its methods and commands can be used from CLI.
+	 * @param {string} extensionName Name of the extension to be installed. It may contain version as well, i.e. myPackage, myPackage@1.0.0
+	 * A Promise is returned. It will be rejected in case the extension cannot be loaded.
+	 * @returns {Promise<IExtensionData>} Promise, resolved with IExtensionData.
+	 */
+	loadExtension(extensionName: string): Promise<IExtensionData>;
+
+	/**
+	 * Gets information about installed dependencies - names and versions.
+	 * @returns {IStringDictionary}
+	 */
+	getInstalledExtensions(): IStringDictionary;
+
+	/**
+	 * Gives full information for each extension.
+	 * @returns {IExtensionData[]} Data for each of the installed extensions, like name, version, path to extension, etc.
+	 */
+	getInstalledExtensionsData(): IExtensionData[];
+
+	/**
+	 * Gives the name of the extension that contains a required command.
+	 * The method finds all extensions from npm and checks the command property defined in the nativescript key of the package.json.
+	 * Based on specified input array, the method tries to find a suitable command that is defined in the extension.
+	 * @example In case the input is `tns execute this command now`, the array will be ["execute", "this", "command", "now"].
+	 * There may be an extension that defines execute|this as a command. The method will check each extension for the following commands:
+	 * execute|this|command|now, execute|this|command, execute|this, execute
+	 * In case it finds any of this commands, the method will return the extension name and the command name.
+	 * @param {string[]} inputStrings All strings written on the terminal.
+	 * @returns {IExtensionCommandInfo} Information about the extension and the registered command.
+	 */
+	getExtensionNameWhereCommandIsRegistered(
+		inputOpts: IGetExtensionCommandInfoParams
+	): Promise<IExtensionCommandInfo>;
+
+	/**
+	 * Defines the path where CLI will search for extensions.
+	 */
+	pathToExtensions: string;
+}
+
+/**
+ * Describes the error that will be raised when a problem with extension is detected.
+ */
+interface IExtensionLoadingError extends Error, IExtensionData {}

package/lib/common/definitions/google-analytics.d.ts

@@ -0,0 +1,109 @@
+import { GoogleAnalyticsDataType, IStringDictionary } from "../declarations";
+
+/**
+ * Describes data that will be tracked to Google Analytics
+ */
+interface IGoogleAnalyticsData {
+	/**
+	 * Describes the type of information that will be tracked (Page or Event).
+	 */
+	googleAnalyticsDataType: GoogleAnalyticsDataType;
+
+	/**
+	 * Describes all custom dimensions that will be send to analytics.
+	 */
+	customDimensions?: IStringDictionary;
+}
+
+/**
+ * Describes information about event that should be tracked.
+ */
+interface IEventActionData {
+	/**
+	 * The action name.
+	 */
+	action: string;
+
+	/**
+	 * Mobile platform for which the action will be tracked.
+	 * In case device is passed, this property is disregarded and device.deviceInfo.platform is used instead.
+	 */
+	platform?: string;
+
+	/**
+	 * Describes if the action is for device or for simulator/emulator.
+	 * In case device is passed, this property is disregarded and !device.isEmulator is used instead.
+	 */
+	isForDevice?: boolean;
+
+	/**
+	 * Device instance for which the action will be tracked.
+	 */
+	device?: Mobile.IDevice;
+
+	/**
+	 * Any additional data that should be tracked.
+	 */
+	additionalData?: string;
+
+	/**
+	 * Project directory, in case the action is executed inside project.
+	 */
+	projectDir?: string;
+
+	/**
+	 * Value that should be tracked
+	 */
+	value?: number;
+}
+
+/**
+ * Describes page's information that should be tracked in Google Analytics.
+ * In CLI one page is one command.
+ */
+interface IGoogleAnalyticsPageviewData extends IGoogleAnalyticsData {
+	/**
+	 * Document path. The path portion of the page URL.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dp
+	 * In our case this is the beautified command name, i.e. `build|android` will be tracked as `build android`, `build|*all` will be tracked as `build`.
+	 */
+	path: string;
+
+	/**
+	 * The title of the page / document.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#dt
+	 * In our case this is the beautified command name, i.e. `build|android` will be tracked as `build android`, `build|*all` will be tracked as `build`.
+	 */
+	title: string;
+}
+
+/**
+ * Describes event's information that should be tracked in Google Analytics.
+ * In CLI these are all custom metrics and data that we track, instead of command.
+ */
+interface IGoogleAnalyticsEventData extends IGoogleAnalyticsData {
+	/**
+	 * Event category. For the moment it is hardcoded to CLI.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#ec
+	 */
+	category?: string;
+
+	/**
+	 * Event action - the real action that has to be tracked, like Build, LiveSync, etc.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#ea
+	 */
+	action: string;
+
+	/**
+	 * Event label - all custom data, specific for this action, like platform for Build operation, device type, os version, etc. for LiveSync.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#el
+	 */
+	label: string;
+
+	/**
+	 * Event value. Specifies the event value. Values must be non-negative.
+	 * https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#ev
+	 * Currently not used.
+	 */
+	value?: number;
+}

package/lib/common/definitions/json-file-settings-service.d.ts

@@ -0,0 +1,24 @@
+import { IDictionary } from "../declarations";
+
+interface ICacheTimeoutOpts {
+	cacheTimeout: number;
+}
+
+interface IUseCacheOpts {
+	useCaching: boolean;
+}
+
+interface IJsonFileSettingsService {
+	getSettingValue<T>(
+		settingName: string,
+		cacheOpts?: ICacheTimeoutOpts
+	): Promise<T>;
+	saveSetting<T>(
+		key: string,
+		value: T,
+		cacheOpts?: IUseCacheOpts
+	): Promise<void>;
+	removeSetting(key: string): Promise<void>;
+	loadUserSettingsFile(): Promise<void>;
+	saveSettings(data: IDictionary<{}>, cacheOpts?: IUseCacheOpts): Promise<void>;
+}

package/lib/common/definitions/key-commands.d.ts

@@ -0,0 +1,62 @@
+export type IKeyCommandPlatform = "Android" | "iOS" | "visionOS" | "all";
+export type IKeysLowerCase =
+	| "a"
+	| "b"
+	| "c"
+	| "d"
+	| "e"
+	| "f"
+	| "g"
+	| "h"
+	| "i"
+	| "j"
+	| "k"
+	| "l"
+	| "m"
+	| "n"
+	| "o"
+	| "p"
+	| "q"
+	| "r"
+	| "s"
+	| "t"
+	| "u"
+	| "v"
+	| "w"
+	| "x"
+	| "y"
+	| "z";
+
+export type IKeysUpperCase = Uppercase<IKeysLowerCase>;
+
+export const enum SpecialKeys {
+	CtrlC = "\u0003",
+	QuestionMark = "?",
+}
+
+export type IKeysSpecial = `${SpecialKeys}`;
+
+export type IValidKeyName = IKeysLowerCase | IKeysUpperCase | IKeysSpecial;
+
+export interface IKeyCommandHelper {
+	attachKeyCommands: (
+		platform: IKeyCommandPlatform,
+		processType: SupportedProcessType
+	) => void;
+
+	addOverride(key: IValidKeyName, execute: () => Promise<boolean>);
+	removeOverride(key: IValidKeyName);
+	printCommands(platform: IKeyCommandPlatform): void;
+}
+
+export type SupportedProcessType = "start" | "run";
+
+export interface IKeyCommand {
+	key: IValidKeyName;
+	platform: IKeyCommandPlatform;
+	description: string;
+	group: string;
+	willBlockKeyCommandExecution?: boolean;
+	execute(platform: string): Promise<void>;
+	canExecute?: (processType: SupportedProcessType) => boolean;
+}