@akylas/nativescript-cli 8.7.2

package/lib/services/ios-debugger-port-service.js

@@ -0,0 +1,140 @@
+"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.IOSDebuggerPortService = void 0;
+const constants_1 = require("../common/constants");
+const decorators_1 = require("../common/decorators");
+const constants_2 = require("../constants");
+const yok_1 = require("../common/yok");
+class IOSDebuggerPortService {
+    constructor($logParserService, $iOSNotification, $devicePlatformsConstants, $logger) {
+        this.$logParserService = $logParserService;
+        this.$iOSNotification = $iOSNotification;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$logger = $logger;
+        this.mapDebuggerPortData = {};
+    }
+    getPort(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const key = `${data.deviceId}${data.appId}`;
+                const retryInterval = 500;
+                let retryCount = Math.max((constants_2.APPLICATION_RESPONSE_TIMEOUT_SECONDS * 1000) / retryInterval, 10);
+                const interval = setInterval(() => {
+                    const port = this.getPortByKey(key);
+                    if (port || retryCount === 0) {
+                        clearInterval(interval);
+                        resolve(port);
+                    }
+                    else {
+                        if (this.mapDebuggerPortData[key] &&
+                            this.mapDebuggerPortData[key].error) {
+                            clearInterval(interval);
+                            reject(this.mapDebuggerPortData[key].error);
+                        }
+                        else {
+                            retryCount--;
+                        }
+                    }
+                }, retryInterval);
+            });
+        });
+    }
+    attachToDebuggerPortFoundEvent(appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentAppId = appId;
+            this.attachToDebuggerPortFoundEventCore();
+            this.attachToAttachRequestEvent();
+        });
+    }
+    attachToDebuggerPortFoundEventCore() {
+        this.$logParserService.addParseRule({
+            regex: IOSDebuggerPortService.DEBUG_PORT_LOG_REGEX,
+            handler: this.handlePortFound.bind(this),
+            name: "debugPort",
+            platform: this.$devicePlatformsConstants.iOS.toLowerCase(),
+        });
+        this.$logParserService.addParseRule({
+            regex: constants_1.IOS_APP_CRASH_LOG_REG_EXP,
+            handler: this.handleAppCrash.bind(this),
+            name: "appCrash",
+            platform: this.$devicePlatformsConstants.iOS.toLowerCase(),
+        });
+    }
+    handleAppCrash(matches, deviceId) {
+        const data = {
+            port: 0,
+            appId: this.currentAppId,
+            deviceId,
+            error: new Error("The application has been terminated."),
+        };
+        this.clearTimeout(data);
+        this.setData(data, { port: data.port, error: data.error });
+    }
+    handlePortFound(matches, deviceId) {
+        const data = {
+            port: parseInt(matches[1]),
+            appId: matches[2],
+            deviceId,
+        };
+        this.$logger.trace(constants_1.DEBUGGER_PORT_FOUND_EVENT_NAME, data);
+        this.clearTimeout(data);
+        this.setData(data, { port: data.port });
+    }
+    attachToAttachRequestEvent() {
+        this.$iOSNotification.on(constants_1.ATTACH_REQUEST_EVENT_NAME, (data) => {
+            this.$logger.trace(constants_1.ATTACH_REQUEST_EVENT_NAME, data);
+            const timer = setTimeout(() => {
+                this.clearTimeout(data);
+                if (!this.getPortByKey(`${data.deviceId}${data.appId}`)) {
+                    this.$logger.warn(`NativeScript debugger was not able to get inspector socket port on device ${data.deviceId} for application ${data.appId}.`);
+                }
+            }, constants_2.APPLICATION_RESPONSE_TIMEOUT_SECONDS * 1000);
+            this.setData(data, { port: null, timer });
+        });
+    }
+    getPortByKey(key) {
+        if (this.mapDebuggerPortData[key] && this.mapDebuggerPortData[key].port) {
+            return this.mapDebuggerPortData[key].port;
+        }
+        return null;
+    }
+    setData(data, storedData) {
+        const key = `${data.deviceId}${data.appId}`;
+        if (!this.mapDebuggerPortData[key]) {
+            this.mapDebuggerPortData[key] = {};
+        }
+        this.mapDebuggerPortData[key].port = storedData.port;
+        this.mapDebuggerPortData[key].timer = storedData.timer;
+        this.mapDebuggerPortData[key].error = storedData.error;
+    }
+    clearTimeout(data) {
+        const storedData = this.mapDebuggerPortData[`${data.deviceId}${data.appId}`];
+        if (storedData && storedData.timer) {
+            clearTimeout(storedData.timer);
+        }
+    }
+}
+IOSDebuggerPortService.DEBUG_PORT_LOG_REGEX = /NativeScript debugger has opened inspector socket on port (\d+?) for (.*)[.]/;
+__decorate([
+    (0, decorators_1.cache)()
+], IOSDebuggerPortService.prototype, "attachToDebuggerPortFoundEventCore", null);
+__decorate([
+    (0, decorators_1.cache)()
+], IOSDebuggerPortService.prototype, "attachToAttachRequestEvent", null);
+exports.IOSDebuggerPortService = IOSDebuggerPortService;
+yok_1.injector.register("iOSDebuggerPortService", IOSDebuggerPortService);

package/lib/services/ios-device-debug-service.js

@@ -0,0 +1,167 @@
+"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.IOSDeviceDebugService = void 0;
+const path = require("path");
+const debug_service_base_1 = require("./debug-service-base");
+const constants_1 = require("../constants");
+const inspectorAppName = "NativeScript Inspector.app";
+const inspectorNpmPackageName = "tns-ios-inspector";
+const inspectorUiDir = "WebInspectorUI/";
+const decorators_1 = require("../common/decorators");
+const os_1 = require("os");
+const yok_1 = require("../common/yok");
+class IOSDeviceDebugService extends debug_service_base_1.DebugServiceBase {
+    constructor(device, $devicesService, $childProcess, $hostInfo, $logger, $errors, $packageInstallationManager, $appDebugSocketProxyFactory, $projectDataService) {
+        super(device, $devicesService);
+        this.device = device;
+        this.$devicesService = $devicesService;
+        this.$childProcess = $childProcess;
+        this.$hostInfo = $hostInfo;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$appDebugSocketProxyFactory = $appDebugSocketProxyFactory;
+        this.$projectDataService = $projectDataService;
+        this.$appDebugSocketProxyFactory.on(constants_1.CONNECTION_ERROR_EVENT_NAME, (e) => this.emit(constants_1.CONNECTION_ERROR_EVENT_NAME, e));
+        this.deviceIdentifier = this.device.deviceInfo.identifier;
+    }
+    get platform() {
+        return "ios";
+    }
+    debug(debugData, debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateOptions(debugOptions);
+            const result = { debugUrl: null };
+            result.debugUrl = yield this.wireDebuggerClient(debugData, debugOptions);
+            return result;
+        });
+    }
+    debugStop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$appDebugSocketProxyFactory.removeAllProxies();
+        });
+    }
+    validateOptions(debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$hostInfo.isWindows && !this.$hostInfo.isDarwin) {
+                this.$errors.fail(`Debugging on iOS devices is not supported for ${(0, os_1.platform)()} yet.`);
+            }
+            if (debugOptions.debugBrk && debugOptions.start) {
+                this.$errors.fail("Expected exactly one of the --debug-brk or --start options.");
+            }
+            yield this.validateUSBConnectedDevice();
+        });
+    }
+    validateUSBConnectedDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.$devicesService.getDevice(this.deviceIdentifier);
+            if (device.deviceInfo.connectionTypes.indexOf(constants_1.DeviceConnectionType.USB) ===
+                -1 &&
+                device.deviceInfo.connectionTypes.indexOf(constants_1.DeviceConnectionType.Local) ===
+                    -1) {
+                const deviceConnectionTypes = device.deviceInfo.connectionTypes
+                    .map((type) => constants_1.DeviceConnectionType[type])
+                    .join(", ");
+                this.$errors.fail(`Debugging application requires a USB or LOCAL connection while the target device "${this.deviceIdentifier}" has connection type "${deviceConnectionTypes}".`);
+            }
+        });
+    }
+    getProjectName(debugData) {
+        let projectName = debugData.projectName;
+        if (!projectName && debugData.projectDir) {
+            const projectData = this.$projectDataService.getProjectData(debugData.projectDir);
+            projectName = projectData.projectName;
+        }
+        return projectName;
+    }
+    killProcess(childProcess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (childProcess) {
+                return new Promise((resolve, reject) => {
+                    childProcess.on("close", resolve);
+                    childProcess.kill();
+                });
+            }
+        });
+    }
+    wireDebuggerClient(debugData, debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((debugOptions.inspector || !debugOptions.client) &&
+                this.$hostInfo.isDarwin) {
+                return yield this.setupTcpAppDebugProxy(debugData, debugOptions);
+            }
+            else {
+                return yield this.setupWebAppDebugProxy(debugOptions, debugData);
+            }
+        });
+    }
+    setupWebAppDebugProxy(debugOptions, debugData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (debugOptions.chrome) {
+                this.$logger.info("'--chrome' is the default behavior. Use --inspector to debug iOS applications using the Safari Web Inspector.");
+            }
+            const projectName = this.getProjectName(debugData);
+            const webSocketProxy = yield this.$appDebugSocketProxyFactory.ensureWebSocketProxy(this.device, debugData.applicationIdentifier, projectName, debugData.projectDir);
+            return this.getChromeDebugUrl(debugOptions, webSocketProxy.options.port);
+        });
+    }
+    setupTcpAppDebugProxy(debugData, debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectName = this.getProjectName(debugData);
+            const existingTcpProxy = this.$appDebugSocketProxyFactory.getTCPSocketProxy(this.deviceIdentifier, debugData.applicationIdentifier);
+            const tcpSocketProxy = existingTcpProxy ||
+                (yield this.$appDebugSocketProxyFactory.addTCPSocketProxy(this.device, debugData.applicationIdentifier, projectName, debugData.projectDir));
+            if (!existingTcpProxy) {
+                const inspectorProcess = yield this.openAppInspector(tcpSocketProxy.address(), debugData, debugOptions);
+                if (inspectorProcess) {
+                    tcpSocketProxy.on("close", () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.killProcess(inspectorProcess);
+                    }));
+                }
+            }
+            return null;
+        });
+    }
+    openAppInspector(fileDescriptor, debugData, debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (debugOptions.client) {
+                const inspectorPath = yield this.$packageInstallationManager.getInspectorFromCache(inspectorNpmPackageName, debugData.projectDir);
+                const inspectorSourceLocation = path.join(inspectorPath, inspectorUiDir, "Main.html");
+                const inspectorApplicationPath = path.join(inspectorPath, inspectorAppName, "Contents", "MacOS", inspectorAppName, "Contents", "MacOS", "NativeScript Inspector");
+                const inspectorProcess = this.$childProcess.spawn(inspectorApplicationPath, [inspectorSourceLocation, debugData.projectName, fileDescriptor]);
+                inspectorProcess.on("error", (e) => this.$logger.trace(e));
+                return inspectorProcess;
+            }
+            else {
+                this.$logger.info("Suppressing debugging client.");
+                return null;
+            }
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSDeviceDebugService.prototype, "debug", null);
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSDeviceDebugService.prototype, "wireDebuggerClient", null);
+__decorate([
+    (0, decorators_1.performanceLog)()
+], IOSDeviceDebugService.prototype, "openAppInspector", null);
+exports.IOSDeviceDebugService = IOSDeviceDebugService;
+yok_1.injector.register("iOSDeviceDebugService", IOSDeviceDebugService, false);

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

@@ -0,0 +1,78 @@
+"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.IOSEntitlementsService = void 0;
+const path = require("path");
+const plist_merge_patch_1 = require("plist-merge-patch");
+const yok_1 = require("../common/yok");
+class IOSEntitlementsService {
+    constructor($options, $fs, $logger, $devicePlatformsConstants, $mobileHelper, $pluginsService) {
+        this.$options = $options;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$mobileHelper = $mobileHelper;
+        this.$pluginsService = $pluginsService;
+    }
+    getDefaultAppEntitlementsPath(projectData) {
+        var _a;
+        const entitlementsName = IOSEntitlementsService.DefaultEntitlementsName;
+        const entitlementsPath = path.join(projectData.appResourcesDirectoryPath, this.$mobileHelper.normalizePlatformName((_a = this.$options.platformOverride) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS), entitlementsName);
+        return entitlementsPath;
+    }
+    getPlatformsEntitlementsPath(projectData) {
+        var _a;
+        return path.join(projectData.platformsDir, (_a = this.$options.platformOverride) !== null && _a !== void 0 ? _a : this.$devicePlatformsConstants.iOS.toLowerCase(), projectData.projectName, projectData.projectName + ".entitlements");
+    }
+    getPlatformsEntitlementsRelativePath(projectData) {
+        return path.join(projectData.projectName, projectData.projectName + ".entitlements");
+    }
+    merge(projectData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = new plist_merge_patch_1.PlistSession({
+                log: (txt) => this.$logger.trace("App.entitlements: " + txt),
+            });
+            const projectDir = projectData.projectDir;
+            const makePatch = (plistPath) => {
+                if (!this.$fs.exists(plistPath)) {
+                    this.$logger.trace("No plist found at: " + plistPath);
+                    return;
+                }
+                this.$logger.trace("Schedule merge plist at: " + plistPath);
+                session.patch({
+                    name: path.relative(projectDir, plistPath),
+                    read: () => this.$fs.readText(plistPath),
+                });
+            };
+            const allPlugins = yield this.getAllInstalledPlugins(projectData);
+            for (const plugin of allPlugins) {
+                const pluginInfoPlistPath = path.join(plugin.pluginPlatformsFolderPath(this.$devicePlatformsConstants.iOS), IOSEntitlementsService.DefaultEntitlementsName);
+                makePatch(pluginInfoPlistPath);
+            }
+            const appEntitlementsPath = this.getDefaultAppEntitlementsPath(projectData);
+            if (this.$fs.exists(appEntitlementsPath)) {
+                makePatch(appEntitlementsPath);
+            }
+            if (session.patches && session.patches.length > 0) {
+                const plistContent = session.build();
+                this.$logger.trace("App.entitlements: Write to: " +
+                    this.getPlatformsEntitlementsPath(projectData));
+                this.$fs.writeFile(this.getPlatformsEntitlementsPath(projectData), plistContent);
+            }
+        });
+    }
+    getAllInstalledPlugins(projectData) {
+        return this.$pluginsService.getAllInstalledPlugins(projectData);
+    }
+}
+IOSEntitlementsService.DefaultEntitlementsName = "app.entitlements";
+exports.IOSEntitlementsService = IOSEntitlementsService;
+yok_1.injector.register("iOSEntitlementsService", IOSEntitlementsService);

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

@@ -0,0 +1,63 @@
+"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.IOSExtensionsService = void 0;
+const path = require("path");
+const constants_1 = require("../constants");
+const yok_1 = require("../common/yok");
+class IOSExtensionsService {
+    constructor($fs, $pbxprojDomXcode, $xcode, $iOSNativeTargetService) {
+        this.$fs = $fs;
+        this.$pbxprojDomXcode = $pbxprojDomXcode;
+        this.$xcode = $xcode;
+        this.$iOSNativeTargetService = $iOSNativeTargetService;
+    }
+    addExtensionsFromPath({ extensionsFolderPath, projectData, platformData, pbxProjPath, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetUuids = [];
+            let addedExtensions = false;
+            if (!this.$fs.exists(extensionsFolderPath)) {
+                return false;
+            }
+            const project = new this.$xcode.project(pbxProjPath);
+            project.parseSync();
+            this.$iOSNativeTargetService
+                .getTargetDirectories(extensionsFolderPath)
+                .forEach((extensionFolder) => {
+                const target = this.$iOSNativeTargetService.addTargetToProject(extensionsFolderPath, extensionFolder, constants_1.IOSNativeTargetTypes.appExtension, project, platformData);
+                this.configureTarget(extensionFolder, path.join(extensionsFolderPath, extensionFolder), target, project, projectData);
+                targetUuids.push(target.uuid);
+                addedExtensions = true;
+            });
+            this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+            this.$iOSNativeTargetService.prepareSigning(targetUuids, projectData, pbxProjPath);
+            return addedExtensions;
+        });
+    }
+    configureTarget(extensionName, extensionPath, target, project, projectData) {
+        const extJsonPath = path.join(extensionPath, "extension.json");
+        this.$iOSNativeTargetService.setXcodeTargetBuildConfigurationProperties([
+            {
+                name: "PRODUCT_BUNDLE_IDENTIFIER",
+                value: `${projectData.projectIdentifiers.ios}.${extensionName}`,
+            },
+        ], extensionName, project);
+        this.$iOSNativeTargetService.setConfigurationsFromJsonFile(extJsonPath, target.uuid, extensionName, project);
+    }
+    removeExtensions({ pbxProjPath }) {
+        const project = new this.$xcode.project(pbxProjPath);
+        project.parseSync();
+        project.removeTargetsByProductType(constants_1.IOSNativeTargetProductTypes.appExtension);
+        this.$fs.writeFile(pbxProjPath, project.writeSync({ omitEmptyValues: true }));
+    }
+}
+exports.IOSExtensionsService = IOSExtensionsService;
+yok_1.injector.register("iOSExtensionsService", IOSExtensionsService);

package/lib/services/ios-log-filter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSLogFilter = void 0;
+const yok_1 = require("../common/yok");
+class IOSLogFilter {
+    constructor($loggingLevels) {
+        this.$loggingLevels = $loggingLevels;
+        this.appOutputRegex = /([^\s\(\)]+)(?:\(([^\s]+)\))?\[[0-9]+\]/;
+        this.infoFilterRegex = new RegExp(`^.*(?:<Notice>:[ \t]?|<Error>:[ \t]?|<Warning>:[ \t]?|\\(NativeScript\\)[ \t]?|${this.appOutputRegex.source}:[ \t]?){1}`);
+        this.postFilterRegex = /^\((.+)\) \[com\.apple.+\]/;
+        this.filterActive = true;
+        this.partialLine = null;
+    }
+    filterData(data, loggingOptions = {}) {
+        const specifiedLogLevel = (loggingOptions.logLevel || "").toUpperCase();
+        if (specifiedLogLevel !== this.$loggingLevels.info || !data) {
+            return data;
+        }
+        const chunkLines = data.split("\n");
+        const skipLastLine = chunkLines.length > 0 ? data[data.length - 1] !== "\n" : false;
+        let output = "";
+        for (let i = 0; i < chunkLines.length; i++) {
+            let currentLine = chunkLines[i];
+            if (this.partialLine) {
+                currentLine = this.partialLine + currentLine;
+                this.partialLine = undefined;
+            }
+            if (i === chunkLines.length - 1 && skipLastLine) {
+                this.partialLine = currentLine;
+                break;
+            }
+            if (this.preFilter(data, currentLine)) {
+                continue;
+            }
+            const matchResult = this.appOutputRegex.exec(currentLine);
+            if (matchResult && matchResult.length > 1) {
+                const projectName = loggingOptions && loggingOptions.projectName;
+                this.filterActive = matchResult[1] !== projectName;
+                if (matchResult === null || matchResult === void 0 ? void 0 : matchResult[2]) {
+                    this.filterActive || (this.filterActive = matchResult[2] !== "NativeScript");
+                }
+            }
+            if (this.filterActive) {
+                continue;
+            }
+            const filteredLineInfo = currentLine.match(this.infoFilterRegex);
+            if (filteredLineInfo && filteredLineInfo.length > 0) {
+                currentLine = currentLine.replace(filteredLineInfo[0], "");
+            }
+            currentLine = currentLine
+                .replace(/^\s*CONSOLE/, "CONSOLE")
+                .trimEnd();
+            const postFilterMatch = this.postFilterRegex.exec(currentLine);
+            if (postFilterMatch && (postFilterMatch === null || postFilterMatch === void 0 ? void 0 : postFilterMatch[1]) !== "NativeScript") {
+                continue;
+            }
+            output += currentLine + "\n";
+        }
+        return output.length === 0 ? null : output;
+    }
+    preFilter(data, currentLine) {
+        return (currentLine.length < 1 ||
+            currentLine.indexOf("SecTaskCopyDebugDescription") !== -1 ||
+            currentLine.indexOf("NativeScript loaded bundle") !== -1 ||
+            (currentLine.indexOf("assertion failed:") !== -1 &&
+                data.indexOf("libxpc.dylib") !== -1));
+    }
+}
+exports.IOSLogFilter = IOSLogFilter;
+yok_1.injector.register("iOSLogFilter", IOSLogFilter);

package/lib/services/ios-native-target-service.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOSNativeTargetService = void 0;
+const path = require("path");
+const _ = require("lodash");
+const yok_1 = require("../common/yok");
+class IOSNativeTargetService {
+    constructor($fs, $pbxprojDomXcode, $logger) {
+        this.$fs = $fs;
+        this.$pbxprojDomXcode = $pbxprojDomXcode;
+        this.$logger = $logger;
+    }
+    addTargetToProject(targetRootPath, targetFolder, targetType, project, platformData, parentTarget) {
+        const targetPath = path.join(targetRootPath, targetFolder);
+        const targetRelativePath = path.relative(platformData.projectRoot, targetPath);
+        const files = this.$fs
+            .readDirectory(targetPath)
+            .filter((filePath) => !filePath.startsWith("."))
+            .map((filePath) => path.join(targetPath, filePath));
+        const target = project.addTarget(targetFolder, targetType, targetRelativePath, parentTarget);
+        project.addBuildPhase([], "PBXSourcesBuildPhase", "Sources", target.uuid);
+        project.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", target.uuid);
+        project.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", target.uuid);
+        project.addPbxGroup(files, targetFolder, targetPath, null, {
+            isMain: true,
+            target: target.uuid,
+            filesRelativeToProject: true,
+        });
+        project.addToHeaderSearchPaths(targetPath, target.pbxNativeTarget.productName);
+        return target;
+    }
+    prepareSigning(targetUuids, projectData, projectPath) {
+        const xcode = this.$pbxprojDomXcode.Xcode.open(projectPath);
+        const signing = xcode.getSigning(projectData.projectName);
+        if (signing !== undefined) {
+            _.forEach(targetUuids, (targetUuid) => {
+                if (signing.style === "Automatic") {
+                    xcode.setAutomaticSigningStyleByTargetKey(targetUuid, signing.team);
+                }
+                else {
+                    for (const config in signing.configurations) {
+                        const signingConfiguration = signing.configurations[config];
+                        xcode.setManualSigningStyleByTargetKey(targetUuid, signingConfiguration);
+                        break;
+                    }
+                }
+            });
+        }
+        xcode.save();
+    }
+    getTargetDirectories(folderPath) {
+        return this.$fs.readDirectory(folderPath).filter((fileName) => {
+            const filePath = path.join(folderPath, fileName);
+            const stats = this.$fs.getFsStats(filePath);
+            return stats.isDirectory() && !fileName.startsWith(".");
+        });
+    }
+    setXcodeTargetBuildConfigurationProperties(properties, targetName, project) {
+        properties.forEach((property) => {
+            const buildNames = property.buildNames || [
+                "Debug",
+                "Release",
+            ];
+            buildNames.forEach((buildName) => {
+                project.addBuildProperty(property.name, property.value, buildName, targetName);
+            });
+        });
+    }
+    setConfigurationsFromJsonFile(jsonPath, targetUuid, targetName, project) {
+        if (this.$fs.exists(jsonPath)) {
+            const configurationJson = this.$fs.readJson(jsonPath) || {};
+            _.forEach(configurationJson.frameworks, (framework) => {
+                project.addFramework(framework, { target: targetUuid });
+            });
+            if (configurationJson.assetcatalogCompilerAppiconName) {
+                project.addToBuildSettings("ASSETCATALOG_COMPILER_APPICON_NAME", configurationJson.assetcatalogCompilerAppiconName, targetUuid);
+            }
+            const properties = [];
+            if (configurationJson.targetBuildConfigurationProperties) {
+                _.forEach(configurationJson.targetBuildConfigurationProperties, (value, name) => properties.push({ value, name }));
+            }
+            if (configurationJson.targetNamedBuildConfigurationProperties) {
+                _.forEach(configurationJson.targetNamedBuildConfigurationProperties, (value, name) => {
+                    var buildName = null;
+                    switch (name) {
+                        case "debug": {
+                            buildName = "Debug";
+                            break;
+                        }
+                        case "release": {
+                            buildName = "Release";
+                            break;
+                        }
+                        default: {
+                            this.$logger.warn("Ignoring targetNamedBuildConfigurationProperties: %s. Only 'release', 'debug' are allowed.", name);
+                        }
+                    }
+                    if (buildName) {
+                        _.forEach(value, (value, name) => properties.push({ value, name, buildNames: [buildName] }));
+                    }
+                });
+            }
+            this.setXcodeTargetBuildConfigurationProperties(properties, targetName, project);
+        }
+    }
+}
+exports.IOSNativeTargetService = IOSNativeTargetService;
+yok_1.injector.register("iOSNativeTargetService", IOSNativeTargetService);