Generate CMakeLists.txt with frameworks enabled

Author: kraenhansen

packages/gyp-to-cmake/package.json

@@ -23,6 +23,8 @@
   },
   "dependencies": {
     "@react-native-node-api/cli-utils": "0.1.0",
-    "gyp-parser": "^1.0.4"
+    "gyp-parser": "^1.0.4",
+    "pkg-dir": "^8.0.0",
+    "read-pkg": "^9.0.1"
   }
 }

packages/gyp-to-cmake/src/cli.ts

@@ -1,7 +1,12 @@
+import assert from "node:assert/strict";
 import fs from "node:fs";
 import path from "node:path";
+import { packageDirectorySync } from "pkg-dir";
+import { readPackageSync } from "read-pkg";
+
 import {
   Command,
+  Option,
   prettyPath,
   wrapAction,
 } from "@react-native-node-api/cli-utils";
@@ -12,23 +17,22 @@ import {
   type GypToCmakeListsOptions,
 } from "./transformer.js";
 
-export type TransformOptions = Omit<
-  GypToCmakeListsOptions,
-  "gyp" | "projectName"
-> & {
+export type TransformOptions = Omit<GypToCmakeListsOptions, "gyp"> & {
   disallowUnknownProperties: boolean;
-  projectName?: string;
 };
 
 export function generateProjectName(gypPath: string) {
-  return path.dirname(gypPath).replaceAll(path.sep, "-");
+  const packagePath = packageDirectorySync({ cwd: path.dirname(gypPath) });
+  assert(packagePath, "Expected the binding.gyp file to be inside a package");
+  const packageJson = readPackageSync({ cwd: packagePath });
+  return packageJson.name;
 }
 
 export function transformBindingGypFile(
   gypPath: string,
   {
     disallowUnknownProperties,
-    projectName = generateProjectName(gypPath),
+    projectName,
     ...restOfOptions
   }: TransformOptions,
 ) {
@@ -49,19 +53,27 @@ export function transformBindingGypFile(
 
 export function transformBindingGypsRecursively(
   directoryPath: string,
-  options: TransformOptions,
+  options: Omit<TransformOptions, "projectName">,
 ) {
   const entries = fs.readdirSync(directoryPath, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path.join(directoryPath, entry.name);
     if (entry.isDirectory()) {
       transformBindingGypsRecursively(fullPath, options);
     } else if (entry.isFile() && entry.name === "binding.gyp") {
-      transformBindingGypFile(fullPath, options);
+      transformBindingGypFile(fullPath, {
+        ...options,
+        projectName: generateProjectName(fullPath),
+      });
     }
   }
 }
 
+const projectNameOption = new Option(
+  "--project-name <name>",
+  "Project name to use in CMakeLists.txt",
+).default(undefined, "Uses name from the surrounding package.json");
+
 export const program = new Command("gyp-to-cmake")
   .description("Transform binding.gyp to CMakeLists.txt")
   .option(
@@ -70,7 +82,12 @@ export const program = new Command("gyp-to-cmake")
   )
   .option("--weak-node-api", "Link against the weak-node-api library", false)
   .option("--define-napi-version", "Define NAPI_VERSION for all targets", false)
+  .option(
+    "--no-apple-framework",
+    "Disable emitting target properties to produce Apple frameworks",
+  )
   .option("--cpp <version>", "C++ standard version", "17")
+  .addOption(projectNameOption)
   .argument(
     "[path]",
     "Path to the binding.gyp file or directory to traverse recursively",
@@ -80,19 +97,30 @@ export const program = new Command("gyp-to-cmake")
     wrapAction(
       (
         targetPath: string,
-        { pathTransforms, cpp, defineNapiVersion, weakNodeApi },
+        {
+          pathTransforms,
+          cpp,
+          defineNapiVersion,
+          weakNodeApi,
+          appleFramework,
+          projectName,
+        },
       ) => {
-        const options: TransformOptions = {
+        const options: Omit<TransformOptions, "projectName"> = {
           unsupportedBehaviour: "throw",
           disallowUnknownProperties: false,
           transformWinPathsToPosix: pathTransforms,
           compileFeatures: cpp ? [`cxx_std_${cpp}`] : [],
           defineNapiVersion,
           weakNodeApi,
+          appleFramework,
         };
         const stat = fs.statSync(targetPath);
         if (stat.isFile()) {
-          transformBindingGypFile(targetPath, options);
+          transformBindingGypFile(targetPath, {
+            ...options,
+            projectName: projectName ?? generateProjectName(targetPath),
+          });
         } else if (stat.isDirectory()) {
           transformBindingGypsRecursively(targetPath, options);
         } else {

packages/gyp-to-cmake/src/transformer.ts

@@ -15,6 +15,7 @@ export type GypToCmakeListsOptions = {
   compileFeatures?: string[];
   defineNapiVersion?: boolean;
   weakNodeApi?: boolean;
+  appleFramework?: boolean;
 };
 
 function isCmdExpansion(value: string) {
@@ -26,6 +27,10 @@ function escapeSpaces(source: string) {
   return source.replace(/ /g, "\\ ");
 }
 
+function escapeBundleIdentifier(identifier: string) {
+  return identifier.replace(/[^A-Za-z0-9.-]/g, "-");
+}
+
 /**
  * @see {@link https://github.com/cmake-js/cmake-js?tab=readme-ov-file#usage} for details on the template used
  * @returns The contents of a CMakeLists.txt file
@@ -39,6 +44,7 @@ export function bindingGypToCmakeLists({
   transformWinPathsToPosix = true,
   defineNapiVersion = true,
   weakNodeApi = false,
+  appleFramework = true,
   compileFeatures = [],
 }: GypToCmakeListsOptions): string {
   function mapExpansion(value: string): string[] {
@@ -113,10 +119,58 @@ export function bindingGypToCmakeLists({
       escapedIncludes.push("${CMAKE_JS_INC}");
     }
 
-    lines.push(
-      `add_library(${targetName} SHARED ${escapedSources.join(" ")})`,
-      `set_target_properties(${targetName} PROPERTIES PREFIX "" SUFFIX ".node")`,
-    );
+    function setTargetPropertiesLines(
+      properties: Record<string, string>,
+      indent = "",
+    ): string[] {
+      return [
+        `${indent}set_target_properties(${targetName} PROPERTIES`,
+        ...Object.entries(properties).map(
+          ([key, value]) => `${indent}  ${key} ${value}`,
+        ),
+        `${indent} )`,
+      ];
+    }
+
+    lines.push(`add_library(${targetName} SHARED ${escapedSources.join(" ")})`);
+
+    if (appleFramework) {
+      lines.push(
+        "",
+        'option(BUILD_APPLE_FRAMEWORK "Wrap addon in an Apple framework" ON)',
+        "",
+        "if(APPLE AND BUILD_APPLE_FRAMEWORK)",
+        ...setTargetPropertiesLines(
+          {
+            FRAMEWORK: "TRUE",
+            MACOSX_FRAMEWORK_IDENTIFIER: escapeBundleIdentifier(
+              `${projectName}.${targetName}`,
+            ),
+            MACOSX_FRAMEWORK_SHORT_VERSION_STRING: "1.0",
+            MACOSX_FRAMEWORK_BUNDLE_VERSION: "1.0",
+            XCODE_ATTRIBUTE_SKIP_INSTALL: "NO",
+          },
+          "  ",
+        ),
+        "elseif(APPLE)",
+        ...setTargetPropertiesLines(
+          {
+            PREFIX: '""',
+            SUFFIX: ".node",
+          },
+          "  ",
+        ),
+        "endif()",
+        "",
+      );
+    } else {
+      lines.push(
+        ...setTargetPropertiesLines({
+          PREFIX: "",
+          SUFFIX: ".node",
+        }),
+      );
+    }
 
     if (libraries.length > 0) {
       lines.push(

packages/node-addon-examples/package.json

@@ -11,7 +11,7 @@
   },
   "scripts": {
     "copy-examples": "tsx scripts/copy-examples.mts",
-    "gyp-to-cmake": "gyp-to-cmake --weak-node-api --apple-framework .",
+    "gyp-to-cmake": "gyp-to-cmake --weak-node-api .",
     "build": "tsx scripts/build-examples.mts",
     "copy-and-build": "node --run copy-examples && node --run gyp-to-cmake && node --run build",
     "verify": "tsx scripts/verify-prebuilds.mts",