feat: macOS support

lib/bootstrap.ts

@@ -182,6 +182,7 @@ injector.requireCommand("run|ios", "./commands/run");
 injector.requireCommand("run|android", "./commands/run");
 injector.requireCommand("run|vision", "./commands/run");
 injector.requireCommand("run|visionos", "./commands/run");
+injector.requireCommand("run|macos", "./commands/run");
 injector.requireCommand("typings", "./commands/typings");
 
 injector.requireCommand("preview", "./commands/preview");
@@ -197,6 +198,7 @@ injector.requireCommand("build|ios", "./commands/build");
 injector.requireCommand("build|android", "./commands/build");
 injector.requireCommand("build|vision", "./commands/build");
 injector.requireCommand("build|visionos", "./commands/build");
+injector.requireCommand("build|macos", "./commands/build");
 injector.requireCommand("deploy", "./commands/deploy");
 
 injector.requireCommand("embed", "./commands/embedding/embed");

lib/commands/build.ts

@@ -277,3 +277,58 @@ export class BuildVisionOsCommand extends BuildIosCommand implements ICommand {
 
 injector.registerCommand("build|vision", BuildVisionOsCommand);
 injector.registerCommand("build|visionos", BuildVisionOsCommand);
+
+export class BuildMacOSCommand extends BuildIosCommand implements ICommand {
+	constructor(
+		protected $options: IOptions,
+		$errors: IErrors,
+		$projectData: IProjectData,
+		$platformsDataService: IPlatformsDataService,
+		$devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		$buildController: IBuildController,
+		$platformValidationService: IPlatformValidationService,
+		$logger: ILogger,
+		$buildDataService: IBuildDataService,
+		protected $migrateController: IMigrateController,
+	) {
+		super(
+			$options,
+			$errors,
+			$projectData,
+			$platformsDataService,
+			$devicePlatformsConstants,
+			$buildController,
+			$platformValidationService,
+			$logger,
+			$buildDataService,
+			$migrateController,
+		);
+	}
+
+	public async execute(args: string[]): Promise<void> {
+		await this.executeCore([
+			this.$devicePlatformsConstants.macOS.toLowerCase(),
+		]);
+	}
+
+	public async canExecute(args: string[]): Promise<boolean> {
+		const platform = this.$devicePlatformsConstants.macOS;
+		if (!this.$options.force) {
+			await this.$migrateController.validate({
+				projectDir: this.$projectData.projectDir,
+				platforms: [platform],
+			});
+		}
+
+		super.validatePlatform(platform);
+
+		let canExecute = await super.canExecuteCommandBase(platform);
+		if (canExecute) {
+			canExecute = await super.validateArgs(args, platform);
+		}
+
+		return canExecute;
+	}
+}
+
+injector.registerCommand("build|macos", BuildMacOSCommand);

lib/commands/run.ts

@@ -13,9 +13,14 @@ import {
 	ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE,
 	ANDROID_RELEASE_BUILD_ERROR_MESSAGE,
 } from "../constants";
-import { IOptions, IPlatformValidationService } from "../declarations";
+import {
+	IOpener,
+	IOptions,
+	IPlatformValidationService,
+} from "../declarations";
 import { IMigrateController } from "../definitions/migrate";
 import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IBuildController, IBuildDataService } from "../definitions/build";
 
 export class RunCommandBase implements ICommand {
 	private liveSyncCommandHelperAdditionalOptions: ILiveSyncCommandHelperAdditionalOptions =
@@ -223,3 +228,65 @@ export class RunVisionOSCommand extends RunIosCommand {
 
 injector.registerCommand("run|vision", RunVisionOSCommand);
 injector.registerCommand("run|visionos", RunVisionOSCommand);
+
+export class RunMacOSCommand implements ICommand {
+	public allowedParameters: ICommandParameter[] = [];
+
+	public get platform(): string {
+		return this.$devicePlatformsConstants.macOS || "macOS";
+	}
+
+	constructor(
+		private $buildController: IBuildController,
+		private $buildDataService: IBuildDataService,
+		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		private $errors: IErrors,
+		private $migrateController: IMigrateController,
+		private $opener: IOpener,
+		private $options: IOptions,
+		private $platformValidationService: IPlatformValidationService,
+		private $projectDataService: IProjectDataService,
+	) {}
+
+	public async execute(args: string[]): Promise<void> {
+		const projectData = this.$projectDataService.getProjectData();
+		const buildData = this.$buildDataService.getBuildData(
+			projectData.projectDir,
+			this.platform.toLowerCase(),
+			this.$options,
+		);
+		const outputPath = await this.$buildController.prepareAndBuild(buildData);
+		await this.$opener.open(outputPath, projectData.projectName);
+	}
+
+	public async canExecute(args: string[]): Promise<boolean> {
+		const projectData = this.$projectDataService.getProjectData();
+
+		if (
+			!this.$platformValidationService.isPlatformSupportedForOS(
+				this.platform,
+				projectData,
+			)
+		) {
+			this.$errors.fail(
+				`Applications for platform ${this.platform} can not be built on this OS`,
+			);
+		}
+
+		if (!this.$options.force) {
+			await this.$migrateController.validate({
+				projectDir: projectData.projectDir,
+				platforms: [this.platform],
+			});
+		}
+
+		return this.$platformValidationService.validateOptions(
+			this.$options.provision,
+			this.$options.teamId,
+			projectData,
+			this.platform.toLowerCase(),
+		);
+	}
+}
+
+injector.registerCommand("run|macos", RunMacOSCommand);

lib/common/definitions/mobile.d.ts

@@ -1197,6 +1197,7 @@ declare global {
 			isAndroidPlatform(platform: string): boolean;
 			isiOSPlatform(platform: string): boolean;
 			isvisionOSPlatform(platform: string): boolean;
+			ismacOSPlatform?(platform: string): boolean;
 			isApplePlatform(platform: string): boolean;
 			normalizePlatformName(platform: string): string;
 			validatePlatformName(platform: string): string;
@@ -1241,10 +1242,12 @@ declare global {
 			iOS: string;
 			Android: string;
 			visionOS: string;
+			macOS?: string;
 
 			isiOS(value: string): boolean;
 			isAndroid(value: string): boolean;
 			isvisionOS(value: string): boolean;
+			ismacOS?(value: string): boolean;
 		}
 
 		interface IDeviceApplication {

lib/common/mobile/device-platforms-constants.ts

@@ -6,6 +6,7 @@ export class DevicePlatformsConstants
 	public iOS = "iOS";
 	public Android = "Android";
 	public visionOS = "visionOS";
+	public macOS = "macOS";
 
 	public isiOS(value: string) {
 		return value.toLowerCase() === this.iOS.toLowerCase();
@@ -18,5 +19,9 @@ export class DevicePlatformsConstants
 	public isvisionOS(value: string) {
 		return value.toLowerCase() === this.visionOS.toLowerCase();
 	}
+
+	public ismacOS(value: string) {
+		return value.toLowerCase() === this.macOS.toLowerCase();
+	}
 }
 injector.register("devicePlatformsConstants", DevicePlatformsConstants);

lib/common/mobile/mobile-helper.ts

@@ -21,6 +21,7 @@ export class MobileHelper implements Mobile.IMobileHelper {
 			this.$devicePlatformsConstants.iOS,
 			this.$devicePlatformsConstants.Android,
 			this.$devicePlatformsConstants.visionOS,
+			this.$devicePlatformsConstants.macOS || "macOS",
 		];
 	}
 
@@ -48,8 +49,20 @@ export class MobileHelper implements Mobile.IMobileHelper {
 		);
 	}
 
+	public ismacOSPlatform(platform: string): boolean {
+		const macOSPlatformName = this.$devicePlatformsConstants.macOS || "macOS";
+		return !!(
+			platform &&
+			macOSPlatformName.toLowerCase() === platform.toLowerCase()
+		);
+	}
+
 	public isApplePlatform(platform: string): boolean {
-		return this.isiOSPlatform(platform) || this.isvisionOSPlatform(platform);
+		return (
+			this.isiOSPlatform(platform) ||
+			this.isvisionOSPlatform(platform) ||
+			this.ismacOSPlatform(platform)
+		);
 	}
 
 	public normalizePlatformName(platform: string): string {
@@ -59,6 +72,8 @@ export class MobileHelper implements Mobile.IMobileHelper {
 			return "iOS";
 		} else if (this.isvisionOSPlatform(platform)) {
 			return "visionOS";
+		} else if (this.ismacOSPlatform(platform)) {
+			return "macOS";
 		}
 
 		return undefined;

lib/constants.ts

@@ -24,6 +24,7 @@ export const TNS_IOS_RUNTIME_NAME = "tns-ios";
 export const SCOPED_ANDROID_RUNTIME_NAME = "@nativescript/android";
 export const SCOPED_IOS_RUNTIME_NAME = "@nativescript/ios";
 export const SCOPED_VISIONOS_RUNTIME_NAME = "@nativescript/visionos";
+export const SCOPED_MACOS_RUNTIME_NAME = "@nativescript/macos";
 export const PACKAGE_JSON_FILE_NAME = "package.json";
 export const PACKAGE_LOCK_JSON_FILE_NAME = "package-lock.json";
 export const ANDROID_DEVICE_APP_ROOT_TEMPLATE = `/data/data/%s/files`;
@@ -348,12 +349,14 @@ export const enum PlatformTypes {
 	ios = "ios",
 	android = "android",
 	visionos = "visionos",
+	macos = "macos",
 }
 
 export type SupportedPlatform =
 	| PlatformTypes.ios
 	| PlatformTypes.android
-	| PlatformTypes.visionos;
+	| PlatformTypes.visionos
+	| PlatformTypes.macos;
 
 export const PODFILE_NAME = "Podfile";
 

lib/controllers/prepare-controller.ts

@@ -194,6 +194,8 @@ export class PrepareController extends EventEmitter {
 			};
 		}
 
+		this.syncMacOSBundleArtifacts(projectData, platformData);
+
 		await this.writeRuntimePackageJson(projectData, platformData, prepareData);
 
 		await this.$projectChangesService.savePrepareInfo(
@@ -518,6 +520,55 @@ export class PrepareController extends EventEmitter {
 		this.$fs.writeJson(packagePath, packageData);
 	}
 
+	private syncMacOSBundleArtifacts(
+		projectData: IProjectData,
+		platformData: IPlatformData,
+	): void {
+		if (platformData.platformNameLowerCase !== "macos") {
+			return;
+		}
+		if (process.env.NS_MACOS_IOS_BUNDLE_FALLBACK !== "1") {
+			return;
+		}
+
+		const macosAppPath = path.join(
+			platformData.projectRoot,
+			projectData.projectName,
+			"app",
+		);
+		const hasMacBundle =
+			this.$fs.exists(path.join(macosAppPath, "bundle.js")) ||
+			this.$fs.exists(path.join(macosAppPath, "bundle.mjs"));
+
+		if (hasMacBundle) {
+			return;
+		}
+
+		const iosAppPath = path.join(
+			projectData.platformsDir,
+			"ios",
+			projectData.projectName,
+			"app",
+		);
+		if (!this.$fs.exists(iosAppPath)) {
+			return;
+		}
+
+		this.$logger.trace(
+			`Copying bundle artifacts from ${iosAppPath} to ${macosAppPath} for macOS prepare.`,
+		);
+
+		this.$fs.ensureDirectoryExists(macosAppPath);
+		const emittedFiles = this.$fs.enumerateFilesInDirectorySync(iosAppPath);
+
+		emittedFiles.forEach((sourcePath) => {
+			const relativePath = path.relative(iosAppPath, sourcePath);
+			const destinationPath = path.join(macosAppPath, relativePath);
+			this.$fs.ensureDirectoryExists(path.dirname(destinationPath));
+			this.$fs.copyFile(sourcePath, destinationPath);
+		});
+	}
+
 	private emitPrepareEvent(filesChangeEventData: IFilesChangeEventData) {
 		if (this.isInitialPrepareReady) {
 			this.emit(PREPARE_READY_EVENT_NAME, filesChangeEventData);

lib/definitions/project.d.ts

@@ -133,6 +133,7 @@ interface INsConfigIOS extends INsConfigPlaform {
 }
 
 interface INSConfigVisionOS extends INsConfigIOS {}
+interface INSConfigMacOS extends INsConfigIOS {}
 
 interface INsConfigAndroid extends INsConfigPlaform {
 	v8Flags?: string;
@@ -188,6 +189,7 @@ interface INsConfig {
 	ios?: INsConfigIOS;
 	android?: INsConfigAndroid;
 	visionos?: INSConfigVisionOS;
+	macos?: INSConfigMacOS;
 	ignoredNativeDependencies?: string[];
 	hooks?: INsConfigHooks[];
 	projectName?: string;

lib/key-commands/bootstrap.ts

@@ -21,3 +21,4 @@ injector.requireCommand("open|ios", path);
 injector.requireCommand("open|android", path);
 injector.requireCommand("open|visionos", path);
 injector.requireCommand("open|vision", path);
+injector.requireCommand("open|macos", path);