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

package/lib/common/deprecation.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportDeprecation = reportDeprecation;
+exports.clearReportedDeprecations = clearReportedDeprecations;
+const DEFAULT_STAGE = "trace";
+const reported = new Set();
+function reportDeprecation(report) {
+    const stage = getDeprecationStage();
+    const message = formatMessage(report);
+    if (stage === "error") {
+        throw new Error(message);
+    }
+    const key = report.detail ? `${report.api}::${report.detail}` : report.api;
+    if (reported.has(key)) {
+        return;
+    }
+    const logger = report.logger || tryResolveGlobalLogger();
+    if (!logger) {
+        return;
+    }
+    reported.add(key);
+    if (stage === "warn") {
+        logger.warn(message);
+    }
+    else {
+        logger.trace(message);
+    }
+}
+function clearReportedDeprecations() {
+    reported.clear();
+}
+function formatMessage(report) {
+    const detail = report.detail ? ` (${report.detail})` : "";
+    return (`Legacy CLI API used: ${report.api}${detail}. ` +
+        `This API is planned for deprecation in a future release; ` +
+        `set NS_DEPRECATIONS=warn or NS_DEPRECATIONS=error to preview stricter handling.`);
+}
+function getDeprecationStage() {
+    const value = (process.env.NS_DEPRECATIONS || "").toLowerCase();
+    if (value === "warn" || value === "error" || value === "trace") {
+        return value;
+    }
+    return DEFAULT_STAGE;
+}
+function tryResolveGlobalLogger() {
+    try {
+        const injector = require("./yok").getInjector();
+        if (!injector) {
+            return null;
+        }
+        return injector.resolve("logger");
+    }
+    catch (err) {
+        return null;
+    }
+}

package/lib/common/di/contract.d.ts

@@ -0,0 +1,7 @@
+export declare const CONTRACT_NAME: unique symbol;
+export interface IContractOptions {
+    name: string;
+}
+export declare function Contract(options: IContractOptions): (target: Function) => void;
+export declare function getContractName(token: any): string | undefined;
+export declare function clearMintedContractNames(): void;

package/lib/common/di/contract.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_NAME = void 0;
+exports.Contract = Contract;
+exports.getContractName = getContractName;
+exports.clearMintedContractNames = clearMintedContractNames;
+exports.CONTRACT_NAME = Symbol.for("nativescript:di:contractName");
+const mintedNames = new Map();
+function Contract(options) {
+    const { name } = options;
+    return (target) => {
+        const existing = mintedNames.get(name);
+        if (existing && existing !== target) {
+            throw new Error(`@Contract name '${name}' is already used by '${existing.name || "another contract"}'. Token names must be unique — a duplicate silently aliases two contracts.`);
+        }
+        mintedNames.set(name, target);
+        Object.defineProperty(target, exports.CONTRACT_NAME, {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    };
+}
+function getContractName(token) {
+    if (typeof token === "function" &&
+        Object.prototype.hasOwnProperty.call(token, exports.CONTRACT_NAME)) {
+        return token[exports.CONTRACT_NAME];
+    }
+    return undefined;
+}
+function clearMintedContractNames() {
+    mintedNames.clear();
+}

package/lib/common/di/forward-ref.d.ts

@@ -0,0 +1,2 @@
+export declare function forwardRef<T>(fn: () => T): T;
+export declare function resolveForwardRef<T>(token: T): T;

package/lib/common/di/forward-ref.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardRef = forwardRef;
+exports.resolveForwardRef = resolveForwardRef;
+const FORWARD_REF = Symbol.for("nativescript:di:forwardRef");
+function forwardRef(fn) {
+    fn[FORWARD_REF] = true;
+    return fn;
+}
+function resolveForwardRef(token) {
+    if (typeof token === "function" && token[FORWARD_REF] === true) {
+        return token();
+    }
+    return token;
+}

package/lib/common/di/index.d.ts

@@ -0,0 +1,8 @@
+export { Injector } from "./injector";
+export type { InjectOptions } from "./injector";
+export { inject, runInInjectionContext } from "./inject";
+export { forwardRef, resolveForwardRef } from "./forward-ref";
+export { Contract, getContractName, CONTRACT_NAME, clearMintedContractNames, } from "./contract";
+export type { IContractOptions } from "./contract";
+export { provide, provideLazy } from "./providers";
+export type { Provider, InternalProvider, ProviderToken, Type, AbstractType, IClassProvider, IValueProvider, IFactoryProvider, ILazyClassProvider, ILegacyClassProvider, ILazyRequireProvider, } from "./providers";

package/lib/common/di/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideLazy = exports.provide = exports.clearMintedContractNames = exports.CONTRACT_NAME = exports.getContractName = exports.Contract = exports.resolveForwardRef = exports.forwardRef = exports.runInInjectionContext = exports.inject = exports.Injector = void 0;
+var injector_1 = require("./injector");
+Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return injector_1.Injector; } });
+var inject_1 = require("./inject");
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return inject_1.inject; } });
+Object.defineProperty(exports, "runInInjectionContext", { enumerable: true, get: function () { return inject_1.runInInjectionContext; } });
+var forward_ref_1 = require("./forward-ref");
+Object.defineProperty(exports, "forwardRef", { enumerable: true, get: function () { return forward_ref_1.forwardRef; } });
+Object.defineProperty(exports, "resolveForwardRef", { enumerable: true, get: function () { return forward_ref_1.resolveForwardRef; } });
+var contract_1 = require("./contract");
+Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return contract_1.Contract; } });
+Object.defineProperty(exports, "getContractName", { enumerable: true, get: function () { return contract_1.getContractName; } });
+Object.defineProperty(exports, "CONTRACT_NAME", { enumerable: true, get: function () { return contract_1.CONTRACT_NAME; } });
+Object.defineProperty(exports, "clearMintedContractNames", { enumerable: true, get: function () { return contract_1.clearMintedContractNames; } });
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "provide", { enumerable: true, get: function () { return providers_1.provide; } });
+Object.defineProperty(exports, "provideLazy", { enumerable: true, get: function () { return providers_1.provideLazy; } });

package/lib/common/di/inject.d.ts

@@ -0,0 +1,8 @@
+import type { Injector, InjectOptions } from "./injector";
+import type { ProviderToken } from "./providers";
+export declare function inject<T = any>(token: ProviderToken<T>): T;
+export declare function inject<T = any>(token: ProviderToken<T>, options: InjectOptions & {
+    optional: true;
+}): T | null;
+export declare function inject<T = any>(token: ProviderToken<T>, options: InjectOptions): T;
+export declare function runInInjectionContext<T>(injector: Injector, fn: () => T): T;

package/lib/common/di/inject.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = inject;
+exports.runInInjectionContext = runInInjectionContext;
+const CONTEXT_SLOT = Symbol.for("nativescript:di:injectionContext");
+const COPY_ID = {};
+let reportedCrossCopyUse = false;
+function currentFrame() {
+    return globalThis[CONTEXT_SLOT] || null;
+}
+function inject(token, options) {
+    const frame = currentFrame();
+    if (!frame) {
+        throw new Error("inject() can only be called from an injection context — a field " +
+            "initializer, a constructor, or a provider factory running under " +
+            "runInInjectionContext(). It is not valid after an await; inject " +
+            "the Injector itself and use injector.get() for late lookups.");
+    }
+    if (frame.owner !== COPY_ID && !reportedCrossCopyUse) {
+        reportedCrossCopyUse = true;
+        const logger = frame.injector.get("logger", { optional: true });
+        if (logger) {
+            logger.warn(`A second copy of the NativeScript CLI (${__dirname}) is serving ` +
+                `inject() in this process. This works, but loads the CLI twice; ` +
+                `extensions and projects should declare nativescript as a ` +
+                `peerDependency so the running copy is shared.`);
+        }
+    }
+    return frame.injector.get(token, options);
+}
+function runInInjectionContext(injector, fn) {
+    const g = globalThis;
+    const previous = g[CONTEXT_SLOT];
+    g[CONTEXT_SLOT] = { injector, owner: COPY_ID };
+    try {
+        return fn();
+    }
+    finally {
+        g[CONTEXT_SLOT] = previous;
+    }
+}

package/lib/common/di/injector.d.ts

@@ -0,0 +1,38 @@
+import type { InternalProvider, Provider, ProviderToken, Type } from "./providers";
+export interface InjectOptions {
+    optional?: boolean;
+    self?: boolean;
+    skipSelf?: boolean;
+}
+export declare class Injector {
+    private parent?;
+    private providers;
+    private instantiationOrder;
+    constructor(providers?: Provider[], parent?: Injector);
+    get<T = any>(token: ProviderToken<T>): T;
+    get<T = any>(token: ProviderToken<T>, options: InjectOptions & {
+        optional: true;
+    }): T | null;
+    get<T = any>(token: ProviderToken<T>, options: InjectOptions): T;
+    protected getWithLegacyArguments(token: ProviderToken, ctorArguments?: {
+        [key: string]: any;
+    }): any;
+    createChild(providers?: Provider[]): Injector;
+    createInstance<T = any>(cls: Type<T> | Function, providers?: Provider[], ctorArguments?: {
+        [key: string]: any;
+    }): T;
+    register(providers: InternalProvider | InternalProvider[]): void;
+    getRegisteredNames(prefix?: string): string[];
+    has(token: ProviderToken): boolean;
+    protected hasResolver(token: ProviderToken): boolean;
+    peek(token: ProviderToken): any;
+    remove(token: ProviderToken): void;
+    dispose(exclude?: any[]): void;
+    private keysFor;
+    private applyProvider;
+    private findRecordLocal;
+    private findRecord;
+    private instantiate;
+    private construct;
+    private constructLegacy;
+}

package/lib/common/di/injector.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
+const helpers_1 = require("../helpers");
+const contract_1 = require("./contract");
+const forward_ref_1 = require("./forward-ref");
+const inject_1 = require("./inject");
+const resolutionStack = [];
+class Injector {
+    constructor(providers = [], parent) {
+        this.parent = parent;
+        this.providers = new Map();
+        this.instantiationOrder = [];
+        this.register({ provide: Injector, useValue: this });
+        this.register(providers);
+    }
+    get(token, options) {
+        if (options && options.self && options.skipSelf) {
+            throw new Error("inject options cannot combine self and skipSelf");
+        }
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        const found = this.findRecord(token, options);
+        if (!found) {
+            if (options && options.optional) {
+                return null;
+            }
+            throw new Error("unable to resolve " + displayNameOf(token));
+        }
+        return found.owner.instantiate(found.record);
+    }
+    getWithLegacyArguments(token, ctorArguments) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        const found = this.findRecord(token);
+        if (!found) {
+            throw new Error("unable to resolve " + displayNameOf(token));
+        }
+        return found.owner.instantiate(found.record, ctorArguments);
+    }
+    createChild(providers = []) {
+        return new Injector(providers, this);
+    }
+    createInstance(cls, providers = [], ctorArguments) {
+        const scope = providers.length ? this.createChild(providers) : this;
+        return scope.constructLegacy(cls, ctorArguments);
+    }
+    register(providers) {
+        const list = Array.isArray(providers) ? providers : [providers];
+        for (const provider of list) {
+            const keys = this.keysFor(provider.provide);
+            let record;
+            for (const key of keys) {
+                record = this.providers.get(key);
+                if (record) {
+                    break;
+                }
+            }
+            if (!record) {
+                record = {
+                    displayName: displayNameOf(provider.provide),
+                    shared: true,
+                    instances: [],
+                    constructing: false,
+                };
+            }
+            this.applyProvider(record, provider);
+            for (const key of keys) {
+                this.providers.set(key, record);
+            }
+        }
+    }
+    getRegisteredNames(prefix = "") {
+        const names = [];
+        for (const key of this.providers.keys()) {
+            if (typeof key === "string" && key.startsWith(prefix)) {
+                names.push(key);
+            }
+        }
+        return names;
+    }
+    has(token) {
+        return !!this.findRecord(token);
+    }
+    hasResolver(token) {
+        const found = this.findRecord(token);
+        return !!found && found.record.kind !== undefined;
+    }
+    peek(token) {
+        const found = this.findRecord(token);
+        return found ? found.record.instances[0] : undefined;
+    }
+    remove(token) {
+        const record = this.findRecordLocal(token);
+        if (!record) {
+            return;
+        }
+        const keys = [];
+        for (const [key, value] of this.providers) {
+            if (value === record) {
+                keys.push(key);
+            }
+        }
+        for (const key of keys) {
+            this.providers.delete(key);
+        }
+    }
+    dispose(exclude = []) {
+        const seen = new Set(exclude);
+        const disposeOne = (instance) => {
+            if (!instance || seen.has(instance) || instance === this) {
+                return;
+            }
+            seen.add(instance);
+            if (typeof instance.dispose === "function") {
+                instance.dispose();
+            }
+        };
+        for (let i = this.instantiationOrder.length - 1; i >= 0; i--) {
+            disposeOne(this.instantiationOrder[i]);
+        }
+        for (const record of new Set(this.providers.values())) {
+            for (const instance of record.instances) {
+                disposeOne(instance);
+            }
+        }
+    }
+    keysFor(token) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        if (typeof token === "string") {
+            return [normalizeName(token)];
+        }
+        const name = (0, contract_1.getContractName)(token);
+        return name !== undefined ? [token, name] : [token];
+    }
+    applyProvider(record, provider) {
+        record.shared = provider.shared === undefined ? true : provider.shared;
+        if ("useLazyRequire" in provider) {
+            record.pendingLoader = provider.useLazyRequire;
+            return;
+        }
+        record.useValue = undefined;
+        record.useClass = undefined;
+        record.useFactory = undefined;
+        record.useLazyClass = undefined;
+        record.useLegacyClass = undefined;
+        if ("useValue" in provider) {
+            record.kind = "value";
+            record.useValue = provider.useValue;
+            if (record.shared) {
+                record.instances[0] = provider.useValue;
+            }
+            else {
+                record.instances.push(provider.useValue);
+            }
+        }
+        else if ("useClass" in provider) {
+            record.kind = "class";
+            record.useClass = provider.useClass;
+        }
+        else if ("useFactory" in provider) {
+            record.kind = "factory";
+            record.useFactory = provider.useFactory;
+        }
+        else if ("useLazyClass" in provider) {
+            record.kind = "lazyClass";
+            record.useLazyClass = provider.useLazyClass;
+        }
+        else if ("useLegacyClass" in provider) {
+            record.kind = "legacyClass";
+            record.useLegacyClass = provider.useLegacyClass;
+        }
+    }
+    findRecordLocal(token) {
+        token = (0, forward_ref_1.resolveForwardRef)(token);
+        if (typeof token === "string") {
+            return this.providers.get(normalizeName(token));
+        }
+        const direct = this.providers.get(token);
+        if (direct) {
+            return direct;
+        }
+        const name = (0, contract_1.getContractName)(token);
+        return name !== undefined ? this.providers.get(name) : undefined;
+    }
+    findRecord(token, options) {
+        if (!options || !options.skipSelf) {
+            const local = this.findRecordLocal(token);
+            if (local) {
+                return { record: local, owner: this };
+            }
+            if (options && options.self) {
+                return undefined;
+            }
+        }
+        return this.parent ? this.parent.findRecord(token) : undefined;
+    }
+    instantiate(record, ctorArguments) {
+        if (record.pendingLoader) {
+            const loader = record.pendingLoader;
+            loader();
+            record.pendingLoader = undefined;
+        }
+        if (record.shared && record.instances.length) {
+            return record.instances[0];
+        }
+        if (record.kind === undefined ||
+            (record.kind === "value" && !record.shared)) {
+            throw new Error("no resolver registered for " + record.displayName);
+        }
+        if (record.kind === "value") {
+            return record.instances[0];
+        }
+        if (record.constructing) {
+            const cyclePath = resolutionStack.concat(record.displayName).join(" -> ");
+            throw new Error(`Cyclic dependency detected on dependency '${record.displayName}'. Resolution path: ${cyclePath}`);
+        }
+        record.constructing = true;
+        resolutionStack.push(record.displayName);
+        let instance;
+        try {
+            instance = this.construct(record, ctorArguments);
+        }
+        finally {
+            resolutionStack.pop();
+            record.constructing = false;
+        }
+        record.instances.push(instance);
+        this.instantiationOrder.push(instance);
+        return instance;
+    }
+    construct(record, ctorArguments) {
+        switch (record.kind) {
+            case "class":
+                return (0, inject_1.runInInjectionContext)(this, () => new record.useClass());
+            case "factory":
+                return (0, inject_1.runInInjectionContext)(this, () => record.useFactory());
+            case "lazyClass": {
+                if (!record.useClass) {
+                    record.useClass = record.useLazyClass();
+                }
+                const cls = record.useClass;
+                return (0, inject_1.runInInjectionContext)(this, () => new cls());
+            }
+            case "legacyClass":
+                return this.constructLegacy(record.useLegacyClass, ctorArguments);
+        }
+    }
+    constructLegacy(ctor, ctorArguments) {
+        (0, helpers_1.annotate)(ctor);
+        const resolvedArgs = ctor.$inject.args.map((paramName) => ctorArguments &&
+            Object.prototype.hasOwnProperty.call(ctorArguments, paramName)
+            ? ctorArguments[paramName]
+            : this.get(paramName));
+        const name = ctor.$inject.name;
+        return (0, inject_1.runInInjectionContext)(this, () => name && name[0] === name[0].toUpperCase()
+            ? new ctor(...resolvedArgs)
+            : ctor.apply(null, resolvedArgs));
+    }
+}
+exports.Injector = Injector;
+function normalizeName(name) {
+    return name[0] === "$" ? name.slice(1) : name;
+}
+function displayNameOf(token) {
+    if (typeof token === "string") {
+        return normalizeName(token);
+    }
+    return (0, contract_1.getContractName)(token) || token.name || "<anonymous class>";
+}

package/lib/common/di/providers.d.ts

@@ -0,0 +1,30 @@
+export type Type<T> = new (...args: any[]) => T;
+export type AbstractType<T> = abstract new (...args: any[]) => T;
+export type ProviderToken<T = any> = string | Type<T> | AbstractType<T>;
+interface IBaseProvider<T> {
+    provide: ProviderToken<T>;
+    shared?: boolean;
+}
+export interface IClassProvider<T> extends IBaseProvider<T> {
+    useClass: Type<T>;
+}
+export interface IValueProvider<T> extends IBaseProvider<T> {
+    useValue: T;
+}
+export interface IFactoryProvider<T> extends IBaseProvider<T> {
+    useFactory: () => T;
+}
+export interface ILazyClassProvider<T> extends IBaseProvider<T> {
+    useLazyClass: () => Type<T>;
+}
+export interface ILegacyClassProvider extends IBaseProvider<any> {
+    useLegacyClass: Function;
+}
+export interface ILazyRequireProvider extends IBaseProvider<any> {
+    useLazyRequire: () => void;
+}
+export type Provider<T = any> = IClassProvider<T> | IValueProvider<T> | IFactoryProvider<T> | ILazyClassProvider<T> | ILegacyClassProvider;
+export type InternalProvider<T = any> = Provider<T> | ILazyRequireProvider;
+export declare const provide: <T>(token: AbstractType<T> | string, impl: Type<T>) => Provider<T>;
+export declare const provideLazy: <T>(token: AbstractType<T> | string, load: () => Type<T>) => Provider<T>;
+export {};

package/lib/common/di/providers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideLazy = exports.provide = void 0;
+const provide = (token, impl) => ({ provide: token, useClass: impl });
+exports.provide = provide;
+const provideLazy = (token, load) => ({ provide: token, useLazyClass: load });
+exports.provideLazy = provideLazy;

package/lib/common/dispatchers.d.ts

@@ -0,0 +1,21 @@
+import { ICommandDispatcher, ICancellationService, ISysInfo } from "./declarations";
+import { IOptions, IPackageManager, IVersionsService } from "../declarations";
+import { IInjector } from "./definitions/yok";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class CommandDispatcher implements ICommandDispatcher {
+    private $logger;
+    protected $injector: IInjector;
+    private $cancellation;
+    private $commandsService;
+    private $staticConfig;
+    private $sysInfo;
+    private $options;
+    private $versionsService;
+    private $packageManager;
+    private $terminalSpinnerService;
+    constructor($logger: ILogger, $injector: IInjector, $cancellation: ICancellationService, $commandsService: ICommandsService, $staticConfig: Config.IStaticConfig, $sysInfo: ISysInfo, $options: IOptions, $versionsService: IVersionsService, $packageManager: IPackageManager, $terminalSpinnerService: ITerminalSpinnerService);
+    dispatchCommand(): Promise<void>;
+    private resolveCommand;
+    private getCommandName;
+    private printVersion;
+}

package/lib/common/enums.d.ts

@@ -0,0 +1,34 @@
+export declare enum GoogleAnalyticsDataType {
+    Page = "pageview",
+    Event = "event"
+}
+export declare enum TrackingTypes {
+    Initialization = "initialization",
+    Exception = "exception",
+    AcceptTrackFeatureUsage = "acceptTrackFeatureUsage",
+    GoogleAnalyticsData = "googleAnalyticsData",
+    FinishTracking = "FinishTracking"
+}
+export declare enum AnalyticsStatus {
+    enabled = "enabled",
+    disabled = "disabled",
+    notConfirmed = "not confirmed"
+}
+export declare enum OptionType {
+    String = "string",
+    Boolean = "boolean",
+    Number = "number",
+    Array = "array",
+    Object = "object"
+}
+export declare enum ErrorCodes {
+    UNCAUGHT = 120,
+    UNKNOWN = 127,
+    INVALID_ARGUMENT = 128,
+    RESOURCE_PROBLEM = 129,
+    KARMA_FAIL = 130,
+    UNHANDLED_REJECTION_FAILURE = 131,
+    DELETED_KILL_FILE = 132,
+    TESTS_INIT_REQUIRED = 133,
+    ALL_DEVICES_DISCONNECTED = 134
+}

package/lib/common/errors.d.ts

@@ -0,0 +1,15 @@
+import { IErrors, IFailOptions } from "./declarations";
+import { IInjector } from "./definitions/yok";
+export declare function installUncaughtExceptionListener(actionOnException?: () => void): void;
+export declare class Errors implements IErrors {
+    private $injector;
+    constructor($injector: IInjector);
+    printCallStack: boolean;
+    fail(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    failWithoutHelp(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    failWithHelp(optsOrFormatStr: string | IFailOptions, ...args: any[]): never;
+    private getFailOptions;
+    private failWithOptions;
+    beginCommand(action: () => Promise<boolean>, printCommandHelpSuggestion: () => Promise<void>): Promise<boolean>;
+    verifyHeap(message: string): void;
+}