@akylas/nativescript-cli 8.7.2

package/lib/services/log-parser-service.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogParserService = void 0;
+const constants_1 = require("../common/constants");
+const decorators_1 = require("../common/decorators");
+const events_1 = require("events");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class LogParserService extends events_1.EventEmitter {
+    constructor($deviceLogProvider, $errors) {
+        super();
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$errors = $errors;
+        this.parseRules = {};
+    }
+    addParseRule(rule) {
+        if (this.parseRules[rule.name]) {
+            this.$errors.fail("Log parse rule already exists.");
+        }
+        this.parseRules[rule.name] = rule;
+        this.startParsingLogCore();
+    }
+    startParsingLogCore() {
+        this.$deviceLogProvider.on(constants_1.DEVICE_LOG_EVENT_NAME, this.processDeviceLogResponse.bind(this));
+    }
+    processDeviceLogResponse(message, deviceIdentifier, devicePlatform) {
+        const lines = message.split("\n");
+        _.forEach(lines, (line) => {
+            _.forEach(this.parseRules, (parseRule) => {
+                if (!devicePlatform ||
+                    !parseRule.platform ||
+                    parseRule.platform.toLowerCase() === devicePlatform.toLowerCase()) {
+                    const matches = parseRule.regex.exec(line);
+                    if (matches) {
+                        parseRule.handler(matches, deviceIdentifier);
+                    }
+                }
+            });
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], LogParserService.prototype, "startParsingLogCore", null);
+exports.LogParserService = LogParserService;
+yok_1.injector.register("logParserService", LogParserService);

package/lib/services/log-source-map-service.js

@@ -0,0 +1,235 @@
+"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.LogSourceMapService = void 0;
+const path = require("path");
+const util = require("util");
+const _ = require("lodash");
+const sourcemap = require("source-map");
+const sourceMapConverter = require("convert-source-map");
+const semver = require("semver");
+const helpers_1 = require("../common/helpers");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class LogSourceMapService {
+    get $platformsDataService() {
+        return this.$injector.resolve("platformsDataService");
+    }
+    constructor($fs, $projectDataService, $injector, $devicePlatformsConstants, $logger) {
+        this.$fs = $fs;
+        this.$projectDataService = $projectDataService;
+        this.$injector = $injector;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$logger = $logger;
+        this.cache = {};
+        this.originalFilesLocationCache = {};
+        this.getProjectData = _.memoize(this.$projectDataService.getProjectData.bind(this.$projectDataService));
+        this.getRuntimeVersion = _.memoize(this.getRuntimeVersionCore, (...args) => args.join(LogSourceMapService.MEMOIZE_FUNCTION_RANDOM_KEY_FOR_JOIN));
+    }
+    setSourceMapConsumerForFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.$fs.getFsStats(filePath).isDirectory()) {
+                    const mapFile = filePath + ".map";
+                    let sourceMapRaw;
+                    if (this.$fs.getFileSize(filePath) > 50 * 1000 * 1000) {
+                        this.$logger.trace(`Skipping source map for file ${filePath} because it is too big (> 50MB).`);
+                        return;
+                    }
+                    const source = this.$fs.readText(filePath);
+                    if (this.$fs.exists(mapFile)) {
+                        sourceMapRaw = sourceMapConverter.fromMapFileSource(source, (filename) => {
+                            return this.$fs.readText(path.join(path.dirname(filePath), filename));
+                        });
+                    }
+                    else {
+                        sourceMapRaw = sourceMapConverter.fromSource(source);
+                    }
+                    let smc = null;
+                    if (sourceMapRaw && sourceMapRaw.sourcemap) {
+                        const sourceMap = sourceMapRaw.sourcemap;
+                        smc = yield sourcemap.SourceMapConsumer.with(sourceMap, null, (c) => {
+                            return c;
+                        });
+                    }
+                    this.cache[filePath] = smc;
+                }
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to set sourceMapConsumer for file ${filePath}. Error is: ${err}`);
+            }
+        });
+    }
+    replaceWithOriginalFileLocations(platform, messageData, loggingOptions) {
+        if (!messageData || !loggingOptions || !loggingOptions.projectDir) {
+            return messageData;
+        }
+        const projectData = this.getProjectData(loggingOptions.projectDir);
+        const lines = messageData.split("\n");
+        const isAndroid = platform.toLowerCase() ===
+            this.$devicePlatformsConstants.Android.toLowerCase();
+        const parserFunction = isAndroid
+            ? this.parseAndroidLog.bind(this, projectData)
+            : this.parseIosLog.bind(this);
+        let outputData = "";
+        lines.forEach((rawLine) => {
+            const parsedLine = parserFunction(rawLine);
+            const originalLocation = this.getOriginalFileLocation(platform, parsedLine, projectData);
+            if (originalLocation && originalLocation.sourceFile) {
+                const runtimeVersion = this.getRuntimeVersion(loggingOptions.projectDir, platform);
+                const { sourceFile, line, column } = originalLocation;
+                if (semver.valid(runtimeVersion) &&
+                    semver.gte(semver.coerce(runtimeVersion), "6.1.0")) {
+                    const lastIndexOfFile = rawLine.lastIndexOf(LogSourceMapService.FILE_PREFIX);
+                    const firstPart = rawLine.substr(0, lastIndexOfFile);
+                    outputData +=
+                        firstPart +
+                            rawLine
+                                .substring(lastIndexOfFile)
+                                .replace(/file:\/\/\/.+?:\d+:\d+/, `${LogSourceMapService.FILE_PREFIX_REPLACEMENT}${sourceFile}:${line}:${column}`) +
+                            "\n";
+                }
+                else {
+                    outputData = `${outputData}${parsedLine.messagePrefix}${LogSourceMapService.FILE_PREFIX_REPLACEMENT}${sourceFile}:${line}:${column}${parsedLine.messageSuffix}\n`;
+                }
+            }
+            else if (rawLine !== "") {
+                outputData = `${outputData}${rawLine}\n`;
+            }
+        });
+        return outputData;
+    }
+    getRuntimeVersionCore(projectDir, platform) {
+        let runtimeVersion = null;
+        try {
+            const projectData = this.getProjectData(projectDir);
+            const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+            const runtimeVersionData = this.$projectDataService.getRuntimePackage(projectData.projectDir, platformData.platformNameLowerCase);
+            runtimeVersion = runtimeVersionData && runtimeVersionData.version;
+        }
+        catch (err) {
+            this.$logger.trace(`Unable to get runtime version for project directory: ${projectDir} and platform ${platform}. Error is: `, err);
+        }
+        return runtimeVersion;
+    }
+    getOriginalFileLocation(platform, parsedLine, projectData) {
+        const fileLocation = path.join(this.getFilesLocation(platform, projectData), constants_1.APP_FOLDER_NAME);
+        if (parsedLine && parsedLine.filePath) {
+            const sourceMapFile = path.join(fileLocation, parsedLine.filePath);
+            const smc = this.cache[sourceMapFile];
+            if (smc) {
+                const originalPosition = smc.originalPositionFor({
+                    line: parsedLine.line,
+                    column: parsedLine.column,
+                });
+                let sourceFile = originalPosition.source &&
+                    originalPosition.source.replace("webpack:///", "");
+                if (sourceFile) {
+                    const appPath = projectData.getAppDirectoryRelativePath();
+                    if (!_.startsWith(sourceFile, constants_1.NODE_MODULES_FOLDER_NAME) &&
+                        !_.startsWith(sourceFile, appPath + "/")) {
+                        sourceFile = path.join(appPath, sourceFile);
+                    }
+                    sourceFile = (0, helpers_1.stringReplaceAll)(sourceFile, "/", path.sep);
+                    if (!this.originalFilesLocationCache[sourceFile]) {
+                        const { dir, ext, name } = path.parse(sourceFile);
+                        const platformSpecificName = `${name}.${platform.toLowerCase()}`;
+                        const platformSpecificFile = path.format({
+                            dir,
+                            ext,
+                            name: platformSpecificName,
+                        });
+                        if (this.$fs.exists(path.join(projectData.projectDir, platformSpecificFile))) {
+                            this.originalFilesLocationCache[sourceFile] =
+                                platformSpecificFile;
+                        }
+                        else {
+                            this.originalFilesLocationCache[sourceFile] = sourceFile;
+                        }
+                    }
+                    return {
+                        sourceFile: this.originalFilesLocationCache[sourceFile],
+                        line: originalPosition.line,
+                        column: originalPosition.column,
+                    };
+                }
+            }
+        }
+    }
+    parseAndroidLog(projectData, rawMessage) {
+        const fileIndex = rawMessage.lastIndexOf(LogSourceMapService.FILE_PREFIX);
+        const deviceProjectPath = util.format(constants_1.ANDROID_DEVICE_APP_ROOT_TEMPLATE, projectData.projectIdentifiers.android);
+        let separator = ",";
+        let messageSuffix = "";
+        let parts, filePath, line, column, messagePrefix;
+        if (fileIndex >= 0) {
+            const fileSubstring = rawMessage.substring(fileIndex + LogSourceMapService.FILE_PREFIX.length);
+            parts = fileSubstring.split(separator);
+            if (parts.length >= 3) {
+                parts[0] = parts[0].replace("'", "");
+                parts[1] = parts[1].replace(" line: ", "");
+                parts[2] = parts[2].replace(" column: ", "");
+            }
+            else {
+                separator = ":";
+                parts = fileSubstring.split(separator);
+            }
+            if (parts.length >= 3) {
+                const devicePath = `${deviceProjectPath}/${constants_1.APP_FOLDER_NAME}/`;
+                filePath = path.relative(devicePath, `${"/"}${parts[0]}`);
+                line = parseInt(parts[1]);
+                column = parseInt(parts[2]);
+                messagePrefix = rawMessage.substring(0, fileIndex);
+                for (let i = 3; i < parts.length; i++) {
+                    messageSuffix += `${parts[i]}${i === parts.length - 1 ? "" : separator}`;
+                }
+                messagePrefix = _.trimEnd(messagePrefix, "(");
+            }
+        }
+        return { filePath, line, column, messagePrefix, messageSuffix };
+    }
+    parseIosLog(rawMessage) {
+        const fileIndex = rawMessage.lastIndexOf(LogSourceMapService.FILE_PREFIX);
+        let messageSuffix = "";
+        let parts, filePath, line, column, messagePrefix;
+        if (fileIndex >= 0) {
+            const fileSubstring = rawMessage.substring(fileIndex + LogSourceMapService.FILE_PREFIX.length);
+            parts = fileSubstring.split(":");
+            if (parts && parts.length >= 3) {
+                filePath = parts[0];
+                if (_.startsWith(filePath, constants_1.APP_FOLDER_NAME)) {
+                    filePath = path.relative(constants_1.APP_FOLDER_NAME, parts[0]);
+                }
+                line = parseInt(parts[1]);
+                column = parseInt(parts[2]);
+                messagePrefix = rawMessage.substring(0, fileIndex);
+                for (let i = 3; i < parts.length; i++) {
+                    messageSuffix += `${parts[i]}${i === parts.length - 1 ? "" : ":"}`;
+                }
+            }
+        }
+        return { filePath, line, column, messagePrefix, messageSuffix };
+    }
+    getFilesLocation(platform, projectData) {
+        try {
+            const platformsData = this.$platformsDataService.getPlatformData(platform.toLowerCase(), projectData);
+            return platformsData.appDestinationDirectoryPath;
+        }
+        catch (err) {
+            return "";
+        }
+    }
+}
+LogSourceMapService.FILE_PREFIX = "file:///";
+LogSourceMapService.FILE_PREFIX_REPLACEMENT = "file: ";
+LogSourceMapService.MEMOIZE_FUNCTION_RANDOM_KEY_FOR_JOIN = "__some_random_value__";
+exports.LogSourceMapService = LogSourceMapService;
+yok_1.injector.register("logSourceMapService", LogSourceMapService);

package/lib/services/marking-mode-service.js

@@ -0,0 +1,56 @@
+"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.MarkingModeService = void 0;
+const os_1 = require("os");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+const semver = require("semver/preload");
+const MARKING_MODE_PROP = "markingMode";
+const MARKING_MODE_FULL_DEPRECATION_MSG = `In the current version of NativeScript "${MARKING_MODE_PROP}:${"full"}" is no longer supported.`;
+class MarkingModeService {
+    constructor($logger, $projectConfigService, $projectHelper, $projectDataService) {
+        this.$logger = $logger;
+        this.$projectConfigService = $projectConfigService;
+        this.$projectHelper = $projectHelper;
+        this.$projectDataService = $projectDataService;
+    }
+    handleMarkingModeFullDeprecation(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const markingModeValue = this.$projectConfigService.getValue("android.markingMode");
+            const { skipWarnings, forceSwitch } = options;
+            if (forceSwitch) {
+                yield this.setMarkingMode("none");
+                return;
+            }
+            if (!skipWarnings && (markingModeValue === null || markingModeValue === void 0 ? void 0 : markingModeValue.toLowerCase()) !== "none") {
+                const { version } = this.$projectDataService.getRuntimePackage(this.$projectHelper.projectDir, "android");
+                const isMarkingModeFullDefault = version && semver.lt(semver.coerce(version), "7.0.0-rc.5");
+                if (isMarkingModeFullDefault) {
+                    this.showMarkingModeFullWarning();
+                }
+            }
+        });
+    }
+    setMarkingMode(newMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$projectConfigService.setValue("android.markingMode", newMode);
+        });
+    }
+    showMarkingModeFullWarning() {
+        const markingModeFullWarning = `You are using the deprecated "${MARKING_MODE_PROP}:${"full"}".${os_1.EOL}${os_1.EOL}${MARKING_MODE_FULL_DEPRECATION_MSG}${os_1.EOL}${os_1.EOL}You should update your marking mode by executing 'ns update --markingMode'.`;
+        this.$logger.warn(markingModeFullWarning, {
+            [constants_1.LoggerConfigData.wrapMessageWithBorders]: true,
+        });
+    }
+}
+exports.MarkingModeService = MarkingModeService;
+yok_1.injector.register("markingModeService", MarkingModeService);

package/lib/services/metadata-filtering-service.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataFilteringService = void 0;
+const path = require("path");
+const os = require("os");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class MetadataFilteringService {
+    constructor($fs, $pluginsService, $mobileHelper, $platformsDataService, $logger) {
+        this.$fs = $fs;
+        this.$pluginsService = $pluginsService;
+        this.$mobileHelper = $mobileHelper;
+        this.$platformsDataService = $platformsDataService;
+        this.$logger = $logger;
+    }
+    generateMetadataFilters(projectData, platform) {
+        this.generateWhitelist(projectData, platform);
+        this.generateBlacklist(projectData, platform);
+    }
+    generateWhitelist(projectData, platform) {
+        const platformsDirPath = this.getPlatformsDirPath(projectData, platform);
+        const pathToWhitelistFile = path.join(platformsDirPath, constants_1.MetadataFilteringConstants.WHITELIST_FILE_NAME);
+        this.$fs.deleteFile(pathToWhitelistFile);
+        const nativeApiConfiguration = this.getNativeApiConfigurationForPlatform(projectData, platform);
+        if (nativeApiConfiguration) {
+            const whitelistedItems = [];
+            if (nativeApiConfiguration["whitelist-plugins-usages"]) {
+                const plugins = this.$pluginsService.getAllProductionPlugins(projectData, platform);
+                for (const pluginData of plugins) {
+                    const pathToPlatformsDir = pluginData.pluginPlatformsFolderPath(platform);
+                    const pathToPluginsMetadataConfig = path.join(pathToPlatformsDir, constants_1.MetadataFilteringConstants.NATIVE_API_USAGE_FILE_NAME);
+                    if (this.$fs.exists(pathToPluginsMetadataConfig)) {
+                        const pluginConfig = this.$fs.readJson(pathToPluginsMetadataConfig) || {};
+                        this.$logger.trace(`Adding content of ${pathToPluginsMetadataConfig} to whitelisted items of metadata filtering: ${JSON.stringify(pluginConfig, null, 2)}`);
+                        const itemsToAdd = pluginConfig.uses || [];
+                        if (itemsToAdd.length) {
+                            whitelistedItems.push(`// Added from: ${pathToPluginsMetadataConfig}`);
+                            whitelistedItems.push(...itemsToAdd);
+                            whitelistedItems.push(`// Finished part from ${pathToPluginsMetadataConfig}${os.EOL}`);
+                        }
+                    }
+                }
+            }
+            const applicationWhitelistedItems = nativeApiConfiguration.whitelist || [];
+            if (applicationWhitelistedItems.length) {
+                this.$logger.trace(`Adding content from application to whitelisted items of metadata filtering: ${JSON.stringify(applicationWhitelistedItems, null, 2)}`);
+                whitelistedItems.push(`// Added from application`);
+                whitelistedItems.push(...applicationWhitelistedItems);
+                whitelistedItems.push(`// Finished part from application${os.EOL}`);
+            }
+            if (whitelistedItems.length) {
+                this.$fs.writeFile(pathToWhitelistFile, whitelistedItems.join(os.EOL));
+            }
+        }
+    }
+    generateBlacklist(projectData, platform) {
+        const platformsDirPath = this.getPlatformsDirPath(projectData, platform);
+        const pathToBlacklistFile = path.join(platformsDirPath, constants_1.MetadataFilteringConstants.BLACKLIST_FILE_NAME);
+        this.$fs.deleteFile(pathToBlacklistFile);
+        const nativeApiConfiguration = this.getNativeApiConfigurationForPlatform(projectData, platform);
+        if (nativeApiConfiguration) {
+            const blacklistedItems = nativeApiConfiguration.blacklist || [];
+            if (nativeApiConfiguration["whitelist-plugins-usages"]) {
+                const plugins = this.$pluginsService.getAllProductionPlugins(projectData, platform);
+                for (const pluginData of plugins) {
+                    const pathToPlatformsDir = pluginData.pluginPlatformsFolderPath(platform);
+                    const pathToPluginsMetadataConfig = path.join(pathToPlatformsDir, constants_1.MetadataFilteringConstants.NATIVE_API_USAGE_FILE_NAME);
+                    if (this.$fs.exists(pathToPluginsMetadataConfig)) {
+                        const pluginConfig = this.$fs.readJson(pathToPluginsMetadataConfig) || {};
+                        this.$logger.trace(`Adding content of ${pathToPluginsMetadataConfig} to whitelisted items of metadata filtering: ${JSON.stringify(pluginConfig, null, 2)}`);
+                        const itemsToAdd = pluginConfig.blacklist || [];
+                        if (itemsToAdd.length) {
+                            blacklistedItems.push(`// Added from: ${pathToPluginsMetadataConfig}`);
+                            blacklistedItems.push(...itemsToAdd);
+                            blacklistedItems.push(`// Finished part from ${pathToPluginsMetadataConfig}${os.EOL}`);
+                        }
+                    }
+                }
+            }
+            if (blacklistedItems.length) {
+                this.$fs.writeFile(pathToBlacklistFile, blacklistedItems.join(os.EOL));
+            }
+        }
+        else {
+            this.$logger.trace(`There's no application configuration for metadata filtering for platform ${platform}. Full metadata will be generated.`);
+        }
+    }
+    getNativeApiConfigurationForPlatform(projectData, platform) {
+        let config = null;
+        const pathToApplicationConfigurationFile = this.getPathToApplicationConfigurationForPlatform(projectData, platform);
+        if (this.$fs.exists(pathToApplicationConfigurationFile)) {
+            config = this.$fs.readJson(pathToApplicationConfigurationFile);
+        }
+        return config;
+    }
+    getPlatformsDirPath(projectData, platform) {
+        const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
+        return platformData.projectRoot;
+    }
+    getPathToApplicationConfigurationForPlatform(projectData, platform) {
+        return path.join(projectData.appResourcesDirectoryPath, this.$mobileHelper.normalizePlatformName(platform), constants_1.MetadataFilteringConstants.NATIVE_API_USAGE_FILE_NAME);
+    }
+}
+exports.MetadataFilteringService = MetadataFilteringService;
+yok_1.injector.register("metadataFilteringService", MetadataFilteringService);

package/lib/services/npm-config-service.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmConfigService = void 0;
+const yok_1 = require("../common/yok");
+const child_process_1 = require("child_process");
+const decorators_1 = require("../common/decorators");
+class NpmConfigService {
+    constructor() {
+        this.config = {};
+    }
+    getConfig() {
+        this.readConfig();
+        return this.config;
+    }
+    readConfig() {
+        try {
+            const res = (0, child_process_1.execSync)("npm config list --json --global");
+            const data = JSON.parse(res.toString());
+            Object.entries(data).forEach(([key, value]) => {
+                this.config[key] =
+                    typeof value !== "string"
+                        ? value
+                        : value.replace(/\${([^}]+)}/, (_, envVar) => process.env[envVar]);
+            });
+        }
+        catch (e) { }
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], NpmConfigService.prototype, "readConfig", null);
+exports.NpmConfigService = NpmConfigService;
+yok_1.injector.register("npmConfigService", NpmConfigService);

package/lib/services/pacote-service.js

@@ -0,0 +1,109 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.PacoteService = void 0;
+const pacote = require("pacote");
+const tar = require("tar");
+const path = require("path");
+const stream_1 = require("stream");
+const _ = require("lodash");
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+const arborist_1 = require("@npmcli/arborist");
+class PacoteService {
+    constructor($fs, $injector, $logger, $npmConfigService, $proxyService) {
+        this.$fs = $fs;
+        this.$injector = $injector;
+        this.$logger = $logger;
+        this.$npmConfigService = $npmConfigService;
+        this.$proxyService = $proxyService;
+    }
+    get $packageManager() {
+        return this.$injector.resolve("packageManager");
+    }
+    manifest(packageName, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Calling pacoteService.manifest for packageName: '${packageName}' and options: `, options);
+            const manifestOptions = yield this.getPacoteBaseOptions();
+            if (options) {
+                _.extend(manifestOptions, options);
+            }
+            packageName = this.getRealPackageName(packageName);
+            this.$logger.trace(`Calling pacote.manifest for packageName: ${packageName} and manifestOptions:`, manifestOptions);
+            const result = yield pacote.manifest(packageName, manifestOptions);
+            this.$logger.trace("pacote.manifest result:", result);
+            return result;
+        });
+    }
+    extractPackage(packageName, destinationDirectory, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
+            const extractOptions = { strip: 1, C: destinationDirectory };
+            if (options) {
+                _.extend(extractOptions, options);
+            }
+            packageName = this.getRealPackageName(packageName);
+            const pacoteOptions = yield this.getPacoteBaseOptions();
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.$logger.trace(`Calling pacoteService.extractPackage for packageName: '${packageName}', destinationDir: '${destinationDirectory}' and options: ${options}`);
+                const source = yield pacote
+                    .tarball(packageName, pacoteOptions)
+                    .catch((err) => {
+                    this.$logger.trace(`Error in source while trying to extract stream from ${packageName}. Error is ${err}`);
+                    reject(err);
+                });
+                this.$logger.trace(`Creating extract tar stream with options: ${JSON.stringify(extractOptions, null, 2)}`);
+                const destination = tar.x(extractOptions);
+                const sourceStream = new stream_1.PassThrough();
+                sourceStream.end(source);
+                sourceStream.pipe(destination);
+                destination.on("error", (err) => {
+                    this.$logger.trace(`Error in destination while trying to extract stream from ${packageName}. Error is ${err}`);
+                    reject(err);
+                });
+                destination.on("finish", () => {
+                    this.$logger.trace(`Successfully extracted '${packageName}' to ${destinationDirectory}`);
+                    resolve();
+                });
+            }));
+        });
+    }
+    getPacoteBaseOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cachePath = yield this.$packageManager.getCachePath();
+            const npmConfig = this.$npmConfigService.getConfig();
+            const pacoteOptions = _.extend(npmConfig, { cache: cachePath, Arborist: arborist_1.Arborist });
+            const proxySettings = yield this.$proxyService.getCache();
+            if (proxySettings) {
+                _.extend(pacoteOptions, proxySettings);
+            }
+            return pacoteOptions;
+        });
+    }
+    getRealPackageName(packageName) {
+        if (this.$fs.exists(packageName)) {
+            this.$logger.trace(`Will resolve the full path to package ${packageName}.`);
+            packageName = path.resolve(packageName);
+        }
+        return packageName;
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], PacoteService.prototype, "$packageManager", null);
+exports.PacoteService = PacoteService;
+yok_1.injector.register("pacoteService", PacoteService);