nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/common/yok.js

@@ -2,20 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Yok = exports.injector = void 0;
 exports.register = register;
+exports.getInjector = getInjector;
 exports.setGlobalInjector = setGlobalInjector;
 const path = require("path");
 const _ = require("lodash");
 const helpers_1 = require("./helpers");
+const deprecation_1 = require("./deprecation");
 const constants_1 = require("./constants");
 const constants_2 = require("./constants");
-let indent = "";
-function trace(formatStr, ...args) {
-}
-function pushIndent() {
-    indent += "  ";
-}
-function popIndent() {
-    indent = indent.slice(0, -2);
+const injector_1 = require("./di/injector");
+const contracts_1 = require("./contracts");
+function rejected(rejection) {
+    return { registered: false, rejection };
 }
 function forEachName(names, action) {
     if (_.isString(names)) {
@@ -30,25 +28,34 @@ function register(...rest) {
         exports.injector.register(rest[0], target);
     };
 }
-class Yok {
+class Yok extends injector_1.Injector {
     constructor() {
+        super();
         this.overrideAlreadyRequiredModule = false;
         this.COMMANDS_NAMESPACE = "commands";
+        this.synthesizedParents = new Set();
+        this.placeholderParents = new Set();
         this.KEY_COMMANDS_NAMESPACE = "keyCommands";
-        this.modules = {};
-        this.resolutionProgress = {};
-        this.hierarchicalCommands = {};
+        this.hierarchicalCommands = Object.create(null);
+        this.deferredCommandOwners = Object.create(null);
         this.publicApi = {
             __modules__: {},
         };
         this.register("injector", this);
+        this.register([
+            { provide: contracts_1.CommandRegistry, useValue: this },
+            { provide: contracts_1.KeyCommandRegistry, useValue: this },
+            { provide: contracts_1.ModuleRegistry, useValue: this },
+            { provide: contracts_1.PublicApiBuilder, useValue: this },
+        ]);
     }
     requireCommand(names, file) {
         forEachName(names, (commandName) => {
             const commands = commandName.split(constants_2.CommandsDelimiters.HierarchicalCommand);
             if (commands.length > 1) {
                 if (_.startsWith(commands[1], "*") &&
-                    this.modules[this.createCommandName(commands[0])]) {
+                    this.has(this.createCommandName(commands[0])) &&
+                    !this.synthesizedParents.has(commands[0])) {
                     throw new Error("Default commands should be required before child commands");
                 }
                 const parentCommandName = commands[0];
@@ -58,17 +65,79 @@ class Yok {
                 this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand));
             }
             if (commands.length > 1 &&
-                !this.modules[this.createCommandName(commands[0])]) {
+                !this.has(this.createCommandName(commands[0]))) {
+                this.placeholderParents.add(commands[0]);
                 this.require(this.createCommandName(commands[0]), file);
                 if (commands[1] && !commandName.match(/\|\*/)) {
                     this.require(this.createCommandName(commandName), file);
                 }
             }
-            else {
+            else if (!commandName.match(/\|\*/)) {
                 this.require(this.createCommandName(commandName), file);
             }
         });
     }
+    registerDeferredCommand(name, options) {
+        if (name !== name.toLowerCase()) {
+            return rejected({
+                reason: "invalid-name",
+                detail: `command names are matched in lower case, so '${name}' can never ` +
+                    `be dispatched; declare it as '${name.toLowerCase()}'`,
+            });
+        }
+        const claimedBy = this.deferredCommandOwners[name];
+        if (claimedBy) {
+            return claimedBy === options.owner
+                ? { registered: true }
+                : rejected({ reason: "claimed", owner: claimedBy });
+        }
+        const commandRecordName = this.createCommandName(name);
+        if (this.has(commandRecordName)) {
+            return rejected(this.synthesizedParents.has(name)
+                ? { reason: "subcommand-parent" }
+                : { reason: "built-in" });
+        }
+        const commands = name.split(constants_2.CommandsDelimiters.HierarchicalCommand);
+        const parentCommandName = commands.length > 1 ? commands[0] : null;
+        if (parentCommandName &&
+            this.has(this.createCommandName(parentCommandName)) &&
+            !this.synthesizedParents.has(parentCommandName) &&
+            !this.placeholderParents.has(parentCommandName)) {
+            return rejected({
+                reason: "parent-is-command",
+                parent: parentCommandName,
+            });
+        }
+        super.register({
+            provide: commandRecordName,
+            useLazyRequire: () => {
+                try {
+                    options.load();
+                }
+                catch (err) {
+                    throw new Error(`Unable to load command '${name}' of ${options.owner} from ` +
+                        `${options.source}: ${err.message}`);
+                }
+                if (!this.hasResolver(commandRecordName)) {
+                    throw new Error(`Command '${name}' of ${options.owner} was not registered when ` +
+                        `${options.source} loaded. The module must export a ` +
+                        `defineCommand() definition or register the command itself.`);
+                }
+            },
+        });
+        this.deferredCommandOwners[name] = options.owner;
+        if (parentCommandName) {
+            const subCommandName = _.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand);
+            if (!this.hierarchicalCommands[parentCommandName]) {
+                this.hierarchicalCommands[parentCommandName] = [];
+            }
+            if (!_.includes(this.hierarchicalCommands[parentCommandName], subCommandName)) {
+                this.hierarchicalCommands[parentCommandName].push(subCommandName);
+            }
+            this.createHierarchicalCommand(parentCommandName, name);
+        }
+        return { registered: true };
+    }
     require(names, file) {
         forEachName(names, (name) => this.requireOne(name, file));
     }
@@ -103,7 +172,7 @@ class Yok {
         });
     }
     resolveInstance(name) {
-        let classInstance = _.first(this.modules[name].instances);
+        let classInstance = this.peek(name);
         if (!classInstance) {
             classInstance = this.resolve(name);
         }
@@ -111,14 +180,15 @@ class Yok {
     }
     requireOne(name, file) {
         const relativePath = path.join("../", file);
-        const dependency = {
-            require: require("fs").existsSync(path.join(__dirname, relativePath + ".js"))
-                ? relativePath
-                : file,
-            shared: true,
-        };
-        if (!this.modules[name] || this.overrideAlreadyRequiredModule) {
-            this.modules[name] = dependency;
+        const dependencyPath = require("fs").existsSync(path.join(__dirname, relativePath + ".js"))
+            ? relativePath
+            : file;
+        if (!this.has(name) || this.overrideAlreadyRequiredModule) {
+            this.remove(name);
+            super.register({
+                provide: name,
+                useLazyRequire: () => require(dependencyPath),
+            });
         }
         else {
             throw new Error(`module '${name}' require'd twice.`);
@@ -129,7 +199,15 @@ class Yok {
             const commands = name.split(constants_2.CommandsDelimiters.HierarchicalCommand);
             this.register(this.createCommandName(name), resolver);
             if (commands.length > 1) {
-                this.createHierarchicalCommand(commands[0]);
+                const parentCommandName = commands[0];
+                const subCommandName = _.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand);
+                if (!this.hierarchicalCommands[parentCommandName]) {
+                    this.hierarchicalCommands[parentCommandName] = [];
+                }
+                if (!_.includes(this.hierarchicalCommands[parentCommandName], subCommandName)) {
+                    this.hierarchicalCommands[parentCommandName].push(subCommandName);
+                }
+                this.createHierarchicalCommand(parentCommandName, name);
             }
         });
     }
@@ -165,7 +243,7 @@ class Yok {
             finalRemainingArguments = _.difference(commandLineArguments, finalSubCommandName
                 .split(constants_2.CommandsDelimiters.HierarchicalCommand)
                 .map((command) => _.startsWith(command, constants_2.CommandsDelimiters.DefaultCommandSymbol)
-                ? command.substr(1)
+                ? command.slice(1)
                 : command));
         }
         if (finalSubCommandName) {
@@ -175,13 +253,24 @@ class Yok {
             };
         }
     }
-    createHierarchicalCommand(name) {
+    createHierarchicalCommand(name, triggeredBy) {
+        if (this.has(this.createCommandName(name)) &&
+            !this.synthesizedParents.has(name) &&
+            !this.placeholderParents.has(name)) {
+            const logger = this.get("logger", { optional: true });
+            if (logger) {
+                logger.warn(`'${name}' is already registered as a command of its own, so no ` +
+                    `subcommand dispatcher was created for it${triggeredBy ? ` and '${triggeredBy}' cannot be reached` : ""}. Rename one of the two.`);
+            }
+            return;
+        }
+        this.synthesizedParents.add(name);
         const factory = () => {
             return {
                 disableAnalytics: true,
                 isHierarchicalCommand: true,
                 execute: async (args) => {
-                    const commandsService = exports.injector.resolve("commandsService");
+                    const commandsService = this.resolve("commandsService");
                     let commandName = null;
                     const defaultCommand = this.getDefaultCommand(name, args);
                     let commandArguments = [];
@@ -217,7 +306,7 @@ class Yok {
                 },
             };
         };
-        exports.injector.registerCommand(name, factory);
+        this.registerCommand(name, factory);
     }
     getHierarchicalCommandName(parentCommandName, subCommandName) {
         return [parentCommandName, subCommandName].join(constants_2.CommandsDelimiters.HierarchicalCommand);
@@ -228,7 +317,7 @@ class Yok {
             if (subCommands) {
                 const fullCommandName = this.buildHierarchicalCommand(commandName, commandArguments);
                 if (!fullCommandName) {
-                    const errors = exports.injector.resolve("errors");
+                    const errors = this.resolve("errors");
                     errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, commandName);
                 }
                 return true;
@@ -240,29 +329,35 @@ class Yok {
         return (commandName.indexOf(constants_2.CommandsDelimiters.DefaultCommandSymbol) > 0 &&
             commandName.indexOf(constants_2.CommandsDelimiters.HierarchicalCommand) > 0);
     }
-    register(name, resolver, shared) {
+    register(nameOrProviders, resolver, shared) {
+        if (typeof nameOrProviders !== "string") {
+            super.register(nameOrProviders);
+            return;
+        }
         shared = shared === undefined ? true : shared;
-        trace("registered '%s'", name);
-        const dependency = this.modules[name] || {};
-        dependency.shared = shared;
         if (_.isFunction(resolver)) {
-            dependency.resolver = resolver;
+            if (resolver.length === 0 && !resolver.prototype) {
+                super.register({
+                    provide: nameOrProviders,
+                    useFactory: resolver,
+                    shared,
+                });
+                return;
+            }
+            super.register({
+                provide: nameOrProviders,
+                useLegacyClass: resolver,
+                shared,
+            });
         }
         else {
-            dependency.instances = dependency.instances || [];
-            if (shared) {
-                dependency.instances[0] = resolver;
-            }
-            else {
-                dependency.instances.push(resolver);
-            }
+            super.register({ provide: nameOrProviders, useValue: resolver, shared });
         }
-        this.modules[name] = dependency;
     }
     resolveCommand(name) {
         let command;
         const commandModuleName = this.createCommandName(name);
-        if (!this.modules[commandModuleName]) {
+        if (!this.has(commandModuleName)) {
             return null;
         }
         command = this.resolve(commandModuleName);
@@ -271,7 +366,7 @@ class Yok {
     resolveKeyCommand(name) {
         let command;
         const commandModuleName = this.createKeyCommandName(name);
-        if (!this.modules[commandModuleName]) {
+        if (!this.has(commandModuleName)) {
             return null;
         }
         command = this.resolve(commandModuleName);
@@ -279,16 +374,15 @@ class Yok {
     }
     resolve(param, ctorArguments) {
         if (_.isFunction(param)) {
-            return this.resolveConstructor(param, ctorArguments);
-        }
-        else {
-            return this.resolveByName(param, ctorArguments);
+            return this.createInstance(param, [], ctorArguments);
         }
+        return this.getWithLegacyArguments(param, ctorArguments);
     }
     get dynamicCallRegex() {
         return /#{([^.]+)\.([^}]+?)(\((.+)\))*}/;
     }
     getDynamicCallData(call, args) {
+        (0, deprecation_1.reportDeprecation)({ api: "injector.dynamicCall", detail: call });
         const parsed = call.match(this.dynamicCallRegex);
         const module = this.resolve(parsed[1]);
         if (!args && parsed[3]) {
@@ -303,84 +397,17 @@ class Yok {
         }
         return data;
     }
-    resolveConstructor(ctor, ctorArguments) {
-        (0, helpers_1.annotate)(ctor);
-        const resolvedArgs = ctor.$inject.args.map((paramName) => {
-            if (ctorArguments && ctorArguments.hasOwnProperty(paramName)) {
-                return ctorArguments[paramName];
-            }
-            else {
-                return this.resolve(paramName);
-            }
-        });
-        const name = ctor.$inject.name;
-        if (name && name[0] === name[0].toUpperCase()) {
-            return new ctor(...resolvedArgs);
-        }
-        else {
-            return ctor.apply(null, resolvedArgs);
-        }
-    }
-    resolveByName(name, ctorArguments) {
-        if (name[0] === "$") {
-            name = name.substr(1);
-        }
-        if (this.resolutionProgress[name]) {
-            throw new Error(`Cyclic dependency detected on dependency '${name}'`);
-        }
-        this.resolutionProgress[name] = true;
-        trace("resolving '%s'", name);
-        pushIndent();
-        let dependency;
-        let instance;
-        try {
-            dependency = this.resolveDependency(name);
-            if (!dependency) {
-                throw new Error("unable to resolve " + name);
-            }
-            if (!dependency.instances ||
-                !dependency.instances.length ||
-                !dependency.shared) {
-                if (!dependency.resolver) {
-                    throw new Error("no resolver registered for " + name);
-                }
-                dependency.instances = dependency.instances || [];
-                instance = this.resolveConstructor(dependency.resolver, ctorArguments);
-                dependency.instances.push(instance);
-            }
-            else {
-                instance = _.first(dependency.instances);
-            }
-        }
-        finally {
-            popIndent();
-            delete this.resolutionProgress[name];
-        }
-        return instance;
-    }
-    resolveDependency(name) {
-        const module = this.modules[name];
-        if (!module) {
-            throw new Error("unable to resolve " + name);
-        }
-        if (module.require) {
-            require(module.require);
-        }
-        return module;
-    }
     getRegisteredCommandsNames(includeDev) {
-        const modulesNames = _.keys(this.modules);
-        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.COMMANDS_NAMESPACE}.`));
-        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.COMMANDS_NAMESPACE.length + 1));
+        const commandsNames = this.getRegisteredNames(`${this.COMMANDS_NAMESPACE}.`);
+        let commands = _.map(commandsNames, (commandName) => commandName.slice(this.COMMANDS_NAMESPACE.length + 1));
         if (!includeDev) {
             commands = _.reject(commands, (command) => _.startsWith(command, "dev-"));
         }
         return commands;
     }
     getRegisteredKeyCommandsNames() {
-        const modulesNames = _.keys(this.modules);
-        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.KEY_COMMANDS_NAMESPACE}.`));
-        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.KEY_COMMANDS_NAMESPACE.length + 1));
+        const commandsNames = this.getRegisteredNames(`${this.KEY_COMMANDS_NAMESPACE}.`);
+        const commands = _.map(commandsNames, (commandName) => commandName.slice(this.KEY_COMMANDS_NAMESPACE.length + 1));
         return commands;
     }
     getChildrenCommandsNames(commandName) {
@@ -392,23 +419,24 @@ class Yok {
     createKeyCommandName(name) {
         return `${this.KEY_COMMANDS_NAMESPACE}.${name}`;
     }
-    dispose() {
-        Object.keys(this.modules).forEach((moduleName) => {
-            const instances = this.modules[moduleName].instances;
-            _.forEach(instances, (instance) => {
-                if (instance && instance.dispose && instance !== this) {
-                    instance.dispose();
-                }
-            });
-        });
+    dispose(exclude = []) {
+        super.dispose([this, ...exclude]);
     }
 }
 exports.Yok = Yok;
-if (!global.$injector) {
-    global.$injector = new Yok();
-    exports.injector = global.$injector;
+exports.injector = global.$injector || new Yok();
+Object.defineProperty(global, "$injector", {
+    get: () => exports.injector,
+    set: (value) => {
+        exports.injector = value;
+    },
+    configurable: true,
+});
+function getInjector() {
+    return exports.injector;
 }
 function setGlobalInjector(inj) {
-    global.$injector = exports.injector = inj;
+    exports.injector = inj;
+    global.$injector = inj;
     return inj;
 }

package/lib/config.d.ts

@@ -0,0 +1,45 @@
+import { IConfiguration, IStaticConfig } from "./declarations";
+import { IFileSystem } from "./common/declarations";
+import { IInjector } from "./common/definitions/yok";
+export declare class Configuration implements IConfiguration {
+    private $fs;
+    DEBUG: boolean;
+    ANDROID_DEBUG_UI: string;
+    USE_POD_SANDBOX: boolean;
+    GA_MEASUREMENT_ID: string;
+    GA_API_SECRET: string;
+    DISABLE_HOOKS: boolean;
+    constructor($fs: IFileSystem);
+    private loadConfig;
+    private getConfigPath;
+}
+export declare class StaticConfig implements IStaticConfig {
+    private $injector;
+    QR_SIZE: number;
+    PROJECT_FILE_NAME: string;
+    CLIENT_NAME_KEY_IN_PROJECT_FILE: string;
+    CLIENT_NAME: string;
+    CLIENT_NAME_ALIAS: string;
+    TRACK_FEATURE_USAGE_SETTING_NAME: string;
+    ERROR_REPORT_SETTING_NAME: string;
+    ANALYTICS_INSTALLATION_ID_SETTING_NAME: string;
+    get PROFILE_DIR_NAME(): string;
+    RESOURCE_DIR_PATH: string;
+    constructor($injector: IInjector);
+    get disableCommandHooks(): boolean;
+    version: any;
+    cliBinPath: string;
+    get HTML_CLI_HELPERS_DIR(): string;
+    get pathToPackageJson(): string;
+    get PATH_TO_BOOTSTRAP(): string;
+    private _adbFilePath;
+    getAdbFilePath(): Promise<string>;
+    private _userAgent;
+    get USER_AGENT_NAME(): string;
+    set USER_AGENT_NAME(userAgentName: string);
+    get MAN_PAGES_DIR(): string;
+    get HTML_PAGES_DIR(): string;
+    get HTML_COMMON_HELPERS_DIR(): string;
+    private getAdbFilePathCore;
+    private spawnPrivateAdb;
+}

package/lib/config.js

@@ -12,7 +12,8 @@ class Configuration {
         this.DEBUG = false;
         this.ANDROID_DEBUG_UI = null;
         this.USE_POD_SANDBOX = false;
-        this.GA_TRACKING_ID = null;
+        this.GA_MEASUREMENT_ID = null;
+        this.GA_API_SECRET = null;
         this.DISABLE_HOOKS = false;
         _.extend(this, this.loadConfig("config"));
     }

package/lib/constants-provider.d.ts

@@ -0,0 +1,4 @@
+import { IDictionary } from "./common/declarations";
+export declare class Constants implements IDictionary<any> {
+    constructor();
+}