nitrogen 0.35.9 → 0.36.0

package/README.md

@@ -1,4 +1,4 @@
-<a href="https://margelo.com">
+<a href="https://nitro.margelo.com/docs/concepts/nitrogen">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="../../docs/static/img/banner-nitrogen-dark.png" />
     <source media="(prefers-color-scheme: light)" srcset="../../docs/static/img/banner-nitrogen-light.png" />

package/lib/createPlatformSpec.js

@@ -80,13 +80,13 @@ function getHybridObjectSpec(type, language) {
         if (Node.isPropertySignature(declaration)) {
             const t = declaration.getType();
             const isOptional = prop.isOptional() || t.getUnionTypes().some((u) => u.isUndefined());
-            const propType = createType(language, t, isOptional);
+            const propType = createType(language, t, isOptional, declaration.getTypeNode());
             properties.push(new Property(prop.getName(), propType, declaration.isReadonly()));
         }
         else if (Node.isMethodSignature(declaration)) {
             const returnType = declaration.getReturnType();
             const isOptional = returnType.getUnionTypes().some((t) => t.isUndefined());
-            const methodReturnType = createType(language, returnType, isOptional);
+            const methodReturnType = createType(language, returnType, isOptional, declaration.getReturnTypeNode());
             const methodParameters = declaration
                 .getParameters()
                 .map((p) => new Parameter(p, language));

package/lib/syntax/Parameter.js

@@ -18,7 +18,7 @@ export class Parameter {
             const name = param.getSymbolOrThrow().getEscapedName();
             const type = param.getType();
             const isOptional = param.hasQuestionToken() || param.isOptional() || type.isNullable();
-            this.type = createNamedType(language, name, type, isOptional);
+            this.type = createNamedType(language, name, type, isOptional, param.getTypeNode());
         }
         else {
             // constructor(...)???

package/lib/syntax/createType.d.ts

@@ -1,8 +1,9 @@
-import { Type as TSMorphType } from 'ts-morph';
+import { Node, ts, Type as TSMorphType } from 'ts-morph';
 import type { Type } from './types/Type.js';
 import { NamedWrappingType } from './types/NamedWrappingType.js';
 import { type Language } from '../getPlatformSpecs.js';
-export declare function createNamedType(language: Language, name: string, type: TSMorphType, isOptional: boolean): NamedWrappingType<Type>;
+type TypeNode = Node<ts.TypeNode>;
+export declare function createNamedType(language: Language, name: string, type: TSMorphType, isOptional: boolean, typeNode?: TypeNode): NamedWrappingType<Type>;
 export declare function createVoidType(): Type;
 /**
  * Get a list of all currently known complex types.
@@ -12,4 +13,5 @@ export declare function addKnownType(key: string, type: Type, language: Language
 /**
  * Create a new type (or return it from cache if it is already known)
  */
-export declare function createType(language: Language, type: TSMorphType, isOptional: boolean): Type;
+export declare function createType(language: Language, type: TSMorphType, isOptional: boolean, typeNode?: TypeNode): Type;
+export {};

package/lib/syntax/createType.js

@@ -1,4 +1,4 @@
-import { ts, Type as TSMorphType } from 'ts-morph';
+import { Node, ts, Type as TSMorphType } from 'ts-morph';
 import { BooleanType } from './types/BooleanType.js';
 import { NumberType } from './types/NumberType.js';
 import { StringType } from './types/StringType.js';
@@ -51,6 +51,34 @@ function removeDuplicates(types) {
         return firstIndexOfType === index;
     });
 }
+function getAliasTypeNode(type) {
+    const symbol = type.getNonNullableType().getAliasSymbol();
+    const declaration = symbol?.getDeclarations()[0];
+    if (declaration != null && Node.isTypeAliasDeclaration(declaration)) {
+        return declaration.getTypeNode();
+    }
+    return undefined;
+}
+function getUnionTypeNodes(type, typeNode) {
+    if (typeNode != null && Node.isUnionTypeNode(typeNode)) {
+        return typeNode.getTypeNodes();
+    }
+    const aliasTypeNode = getAliasTypeNode(type);
+    if (aliasTypeNode != null && Node.isUnionTypeNode(aliasTypeNode)) {
+        return aliasTypeNode.getTypeNodes();
+    }
+    return undefined;
+}
+function getUnionConstituents(type, typeNode) {
+    const typeNodes = getUnionTypeNodes(type, typeNode);
+    if (typeNodes != null) {
+        return typeNodes.map((node) => ({
+            type: node.getType(),
+            typeNode: node,
+        }));
+    }
+    return type.getUnionTypes().map((unionType) => ({ type: unionType }));
+}
 function getArguments(type, typename, count) {
     const typeArguments = type.getTypeArguments();
     if (typeArguments.length === count) {
@@ -62,11 +90,11 @@ function getArguments(type, typename, count) {
     }
     throw new Error(`Type ${type.getText()} looks like a ${typename}, but has ${typeArguments.length} or ${aliasTypeArguments.length} type arguments instead of ${count}!`);
 }
-export function createNamedType(language, name, type, isOptional) {
+export function createNamedType(language, name, type, isOptional, typeNode) {
     if (name.startsWith('__')) {
         throw new Error(`Name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${type.getText()})`);
     }
-    return new NamedWrappingType(name, createType(language, type, isOptional));
+    return new NamedWrappingType(name, createType(language, type, isOptional, typeNode));
 }
 export function createVoidType() {
     return new VoidType();
@@ -110,7 +138,7 @@ export function addKnownType(key, type, language) {
 /**
  * Create a new type (or return it from cache if it is already known)
  */
-export function createType(language, type, isOptional) {
+export function createType(language, type, isOptional, typeNode) {
     const key = getTypeId(type, isOptional);
     if (key != null && knownTypes[language].has(key)) {
         const known = knownTypes[language].get(key);
@@ -120,7 +148,7 @@ export function createType(language, type, isOptional) {
     }
     const get = () => {
         if (isOptional) {
-            const wrapping = createType(language, type, false);
+            const wrapping = createType(language, type, false, typeNode);
             return new OptionalType(wrapping);
         }
         if (type.isNull()) {
@@ -232,8 +260,10 @@ export function createType(language, type, isOptional) {
             // - of string literals (then it's an enum)
             // - of type `T | undefined` (then it's just optional `T`)
             // - of different types (then it's a variant `A | B | C`)
-            const types = type.getUnionTypes();
-            const nonNullTypes = types.filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid());
+            const unionConstituents = getUnionConstituents(type, typeNode);
+            const nonNullTypes = unionConstituents
+                .map((c) => c.type)
+                .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid());
             const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral());
             if (isEnumUnion) {
                 // It consists only of string literaly - that means it's describing an enum!
@@ -248,11 +278,10 @@ export function createType(language, type, isOptional) {
             }
             else {
                 // It consists of different types - that means it's a variant!
-                let variants = type
-                    .getUnionTypes()
+                let variants = unionConstituents
                     // Filter out any undefineds/voids, as those are already treated as `isOptional`.
-                    .filter((t) => !t.isUndefined() && !t.isVoid())
-                    .map((t) => createType(language, t, false))
+                    .filter(({ type: t }) => !t.isUndefined() && !t.isVoid())
+                    .map(({ type: t, typeNode: node }) => createType(language, t, false, node))
                     .toSorted(compareLooselyness);
                 variants = removeDuplicates(variants);
                 if (variants.length === 1) {

package/lib/syntax/getInterfaceProperties.d.ts

@@ -1,4 +1,4 @@
-import type { ts, Type } from 'ts-morph';
+import { type ts, type Type } from 'ts-morph';
 import type { NamedType } from './types/Type.js';
 import type { Language } from '../getPlatformSpecs.js';
 export declare function getInterfaceProperties(language: Language, interfaceType: Type<ts.ObjectType>): NamedType[];

package/lib/syntax/getInterfaceProperties.js

@@ -1,9 +1,13 @@
+import { Node } from 'ts-morph';
 import { createNamedType } from './createType.js';
 export function getInterfaceProperties(language, interfaceType) {
     const symbol = interfaceType.getAliasSymbol() ?? interfaceType.getSymbol();
     if (symbol == null)
         throw new Error(`Interface "${interfaceType.getText()}" does not have a Symbol!`);
     return interfaceType.getProperties().map((prop) => {
+        const propDeclaration = prop
+            .getDeclarations()
+            .find((declaration) => Node.isPropertySignature(declaration));
         let propType = prop.getDeclaredType();
         if (propType.isAny() || propType.isUnknown()) {
             // the interface is aliased/merged - we need to look into the actual declaration
@@ -15,7 +19,7 @@ export function getInterfaceProperties(language, interfaceType) {
                 }
             }
         }
-        const refType = createNamedType(language, prop.getName(), propType, prop.isOptional() || propType.isNullable());
+        const refType = createNamedType(language, prop.getName(), propType, prop.isOptional() || propType.isNullable(), propDeclaration?.getTypeNode());
         return refType;
     });
 }

package/lib/syntax/kotlin/KotlinEnum.js

@@ -40,7 +40,7 @@ namespace ${cxxNamespace} {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "${enumType.enumName}" and the the Kotlin enum "${enumType.enumName}".
+   * The C++ JNI bridge between the C++ enum "${enumType.enumName}" and the Kotlin enum "${enumType.enumName}".
    */
   struct J${enumType.enumName} final: public jni::JavaClass<J${enumType.enumName}> {
   public:

package/lib/syntax/kotlin/KotlinStruct.js

@@ -109,7 +109,7 @@ namespace ${cxxNamespace} {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "${structType.structName}" and the the Kotlin data class "${structType.structName}".
+   * The C++ JNI bridge between the C++ struct "${structType.structName}" and the Kotlin data class "${structType.structName}".
    */
   struct J${structType.structName} final: public jni::JavaClass<J${structType.structName}> {
   public:

package/lib/views/CppHybridViewComponent.js

@@ -210,7 +210,7 @@ namespace ${namespace} {
 
   ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
     : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+                                  react::RawPropsParser()) {}
 
   std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
                                       ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitrogen",
-  "version": "0.35.9",
-  "description": "The code-generator for react-native-nitro-modules.",
+  "version": "0.36.0",
+  "description": "Code generator for React Native Nitro Modules that turns TypeScript specs into C++, Swift, and Kotlin bindings.",
   "main": "lib/index",
   "types": "lib/index.d.ts",
   "source": "src/index",
@@ -21,7 +21,7 @@
   "bugs": {
     "url": "https://github.com/mrousavy/nitro/issues"
   },
-  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "homepage": "https://nitro.margelo.com/docs/concepts/nitrogen",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -30,18 +30,18 @@
     "start": "tsc && node lib/index.js",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
-    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions --max-warnings 0",
     "release": "release-it"
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "react-native-nitro-modules": "^0.35.9",
+    "react-native-nitro-modules": "^0.36.0",
     "ts-morph": "^28.0.0",
     "yargs": "^18.0.0",
-    "zod": "^4.0.5"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^25.7.0"
+    "@types/node": "^26.0.0"
   },
   "release-it": {
     "npm": {

package/src/createPlatformSpec.ts

@@ -113,14 +113,24 @@ function getHybridObjectSpec(type: Type, language: Language): HybridObjectSpec {
       const t = declaration.getType()
       const isOptional =
         prop.isOptional() || t.getUnionTypes().some((u) => u.isUndefined())
-      const propType = createType(language, t, isOptional)
+      const propType = createType(
+        language,
+        t,
+        isOptional,
+        declaration.getTypeNode()
+      )
       properties.push(
         new Property(prop.getName(), propType, declaration.isReadonly())
       )
     } else if (Node.isMethodSignature(declaration)) {
       const returnType = declaration.getReturnType()
       const isOptional = returnType.getUnionTypes().some((t) => t.isUndefined())
-      const methodReturnType = createType(language, returnType, isOptional)
+      const methodReturnType = createType(
+        language,
+        returnType,
+        isOptional,
+        declaration.getReturnTypeNode()
+      )
       const methodParameters = declaration
         .getParameters()
         .map((p) => new Parameter(p, language))

package/src/syntax/Parameter.ts

@@ -26,7 +26,13 @@ export class Parameter implements CodeNode {
       const type = param.getType()
       const isOptional =
         param.hasQuestionToken() || param.isOptional() || type.isNullable()
-      this.type = createNamedType(language, name, type, isOptional)
+      this.type = createNamedType(
+        language,
+        name,
+        type,
+        isOptional,
+        param.getTypeNode()
+      )
     } else {
       // constructor(...)???
       throw new Error(`Invalid constructor! Arguments: ${args}`)

package/src/syntax/createType.ts

@@ -1,4 +1,4 @@
-import { ts, Type as TSMorphType, type Signature } from 'ts-morph'
+import { Node, ts, Type as TSMorphType, type Signature } from 'ts-morph'
 import type { Type } from './types/Type.js'
 import { BooleanType } from './types/BooleanType.js'
 import { NumberType } from './types/NumberType.js'
@@ -83,6 +83,54 @@ type Tuple<
   N extends number,
   R extends unknown[] = [],
 > = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>
+
+type TypeNode = Node<ts.TypeNode>
+
+interface UnionConstituent {
+  type: TSMorphType
+  typeNode?: TypeNode
+}
+
+function getAliasTypeNode(type: TSMorphType): TypeNode | undefined {
+  const symbol = type.getNonNullableType().getAliasSymbol()
+  const declaration = symbol?.getDeclarations()[0]
+  if (declaration != null && Node.isTypeAliasDeclaration(declaration)) {
+    return declaration.getTypeNode()
+  }
+  return undefined
+}
+
+function getUnionTypeNodes(
+  type: TSMorphType,
+  typeNode?: TypeNode
+): TypeNode[] | undefined {
+  if (typeNode != null && Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes()
+  }
+
+  const aliasTypeNode = getAliasTypeNode(type)
+  if (aliasTypeNode != null && Node.isUnionTypeNode(aliasTypeNode)) {
+    return aliasTypeNode.getTypeNodes()
+  }
+
+  return undefined
+}
+
+function getUnionConstituents(
+  type: TSMorphType,
+  typeNode?: TypeNode
+): UnionConstituent[] {
+  const typeNodes = getUnionTypeNodes(type, typeNode)
+  if (typeNodes != null) {
+    return typeNodes.map((node) => ({
+      type: node.getType(),
+      typeNode: node,
+    }))
+  }
+
+  return type.getUnionTypes().map((unionType) => ({ type: unionType }))
+}
+
 function getArguments<N extends number>(
   type: TSMorphType,
   typename: string,
@@ -107,14 +155,18 @@ export function createNamedType(
   language: Language,
   name: string,
   type: TSMorphType,
-  isOptional: boolean
+  isOptional: boolean,
+  typeNode?: TypeNode
 ) {
   if (name.startsWith('__')) {
     throw new Error(
       `Name cannot start with two underscores (__) as this is reserved syntax for Nitrogen! (In ${type.getText()})`
     )
   }
-  return new NamedWrappingType(name, createType(language, type, isOptional))
+  return new NamedWrappingType(
+    name,
+    createType(language, type, isOptional, typeNode)
+  )
 }
 
 export function createVoidType(): Type {
@@ -171,7 +223,8 @@ export function addKnownType(
 export function createType(
   language: Language,
   type: TSMorphType,
-  isOptional: boolean
+  isOptional: boolean,
+  typeNode?: TypeNode
 ): Type {
   const key = getTypeId(type, isOptional)
   if (key != null && knownTypes[language].has(key)) {
@@ -183,7 +236,7 @@ export function createType(
 
   const get = () => {
     if (isOptional) {
-      const wrapping = createType(language, type, false)
+      const wrapping = createType(language, type, false, typeNode)
       return new OptionalType(wrapping)
     }
 
@@ -286,10 +339,10 @@ export function createType(
       // - of string literals (then it's an enum)
       // - of type `T | undefined` (then it's just optional `T`)
       // - of different types (then it's a variant `A | B | C`)
-      const types = type.getUnionTypes()
-      const nonNullTypes = types.filter(
-        (t) => !t.isNull() && !t.isUndefined() && !t.isVoid()
-      )
+      const unionConstituents = getUnionConstituents(type, typeNode)
+      const nonNullTypes = unionConstituents
+        .map((c) => c.type)
+        .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
       const isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral())
       if (isEnumUnion) {
         // It consists only of string literaly - that means it's describing an enum!
@@ -305,11 +358,12 @@ export function createType(
         return new EnumType(typename, type)
       } else {
         // It consists of different types - that means it's a variant!
-        let variants = type
-          .getUnionTypes()
+        let variants = unionConstituents
           // Filter out any undefineds/voids, as those are already treated as `isOptional`.
-          .filter((t) => !t.isUndefined() && !t.isVoid())
-          .map((t) => createType(language, t, false))
+          .filter(({ type: t }) => !t.isUndefined() && !t.isVoid())
+          .map(({ type: t, typeNode: node }) =>
+            createType(language, t, false, node)
+          )
           .toSorted(compareLooselyness)
         variants = removeDuplicates(variants)
 

package/src/syntax/getInterfaceProperties.ts

@@ -1,4 +1,4 @@
-import type { ts, Type } from 'ts-morph'
+import { Node, type ts, type Type } from 'ts-morph'
 import type { NamedType } from './types/Type.js'
 import { createNamedType } from './createType.js'
 import type { Language } from '../getPlatformSpecs.js'
@@ -13,6 +13,9 @@ export function getInterfaceProperties(
       `Interface "${interfaceType.getText()}" does not have a Symbol!`
     )
   return interfaceType.getProperties().map((prop) => {
+    const propDeclaration = prop
+      .getDeclarations()
+      .find((declaration) => Node.isPropertySignature(declaration))
     let propType = prop.getDeclaredType()
     if (propType.isAny() || propType.isUnknown()) {
       // the interface is aliased/merged - we need to look into the actual declaration
@@ -29,7 +32,8 @@ export function getInterfaceProperties(
       language,
       prop.getName(),
       propType,
-      prop.isOptional() || propType.isNullable()
+      prop.isOptional() || propType.isNullable(),
+      propDeclaration?.getTypeNode()
     )
     return refType
   })

package/src/syntax/kotlin/KotlinEnum.ts

@@ -49,7 +49,7 @@ namespace ${cxxNamespace} {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ enum "${enumType.enumName}" and the the Kotlin enum "${enumType.enumName}".
+   * The C++ JNI bridge between the C++ enum "${enumType.enumName}" and the Kotlin enum "${enumType.enumName}".
    */
   struct J${enumType.enumName} final: public jni::JavaClass<J${enumType.enumName}> {
   public:

package/src/syntax/kotlin/KotlinStruct.ts

@@ -133,7 +133,7 @@ namespace ${cxxNamespace} {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "${structType.structName}" and the the Kotlin data class "${structType.structName}".
+   * The C++ JNI bridge between the C++ struct "${structType.structName}" and the Kotlin data class "${structType.structName}".
    */
   struct J${structType.structName} final: public jni::JavaClass<J${structType.structName}> {
   public:

package/src/views/CppHybridViewComponent.ts

@@ -257,7 +257,7 @@ namespace ${namespace} {
 
   ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
     : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+                                  react::RawPropsParser()) {}
 
   std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
                                       ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,