nitrogen 0.2.24 → 0.29.5

package/lib/syntax/c++/CppStruct.js

@@ -0,0 +1,108 @@
+import { indent } from '../../utils.js';
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
+import { includeHeader, includeNitroHeader } from './includeNitroHeader.js';
+import { NitroConfig } from '../../config/NitroConfig.js';
+export function createCppStruct(typename, properties) {
+    // Namespace typename
+    const fullyQualifiedTypename = NitroConfig.current.getCxxNamespace('c++', typename);
+    // Get C++ code for all struct members
+    const cppStructProps = properties
+        .map((p) => `${p.getCode('c++')} ${p.escapedName}     SWIFT_PRIVATE;`)
+        .join('\n');
+    const cppConstructorParams = properties
+        .map((p) => `${p.getCode('c++')} ${p.escapedName}`)
+        .join(', ');
+    const cppInitializerParams = properties
+        .map((p) => `${p.escapedName}(${p.escapedName})`)
+        .join(', ');
+    // Get C++ code for converting each member from a jsi::Value
+    const codeOptions = {
+        fullyQualified: true,
+        includeNameInfo: false,
+    };
+    const cppFromJsiParams = properties
+        .map((p) => `JSIConverter<${p.getCode('c++', codeOptions)}>::fromJSI(runtime, obj.getProperty(runtime, "${p.name}"))`)
+        .join(',\n');
+    // Get C++ code for converting each member to a jsi::Value
+    const cppToJsiCalls = properties
+        .map((p) => `obj.setProperty(runtime, "${p.name}", JSIConverter<${p.getCode('c++', codeOptions)}>::toJSI(runtime, arg.${p.escapedName}));`)
+        .join('\n');
+    // Get C++ code for verifying if jsi::Value can be converted to type
+    const cppCanConvertCalls = properties
+        .map((p) => `if (!JSIConverter<${p.getCode('c++', codeOptions)}>::canConvert(runtime, obj.getProperty(runtime, "${p.name}"))) return false;`)
+        .join('\n');
+    // Get C++ includes for each extra-file we need to include
+    const includedTypes = properties.flatMap((r) => r.getRequiredImports('c++'));
+    const cppForwardDeclarations = includedTypes
+        .map((i) => i.forwardDeclaration)
+        .filter((v) => v != null)
+        .filter(isNotDuplicate);
+    const cppExtraIncludes = includedTypes
+        .map((i) => includeHeader(i))
+        .filter(isNotDuplicate);
+    const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
+    const cppCode = `
+${createFileMetadataString(`${typename}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('JSIConverter.hpp')}
+${includeNitroHeader('NitroDefines.hpp')}
+
+${cppForwardDeclarations.join('\n')}
+
+${cppExtraIncludes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  /**
+   * A struct which can be represented as a JavaScript object (${typename}).
+   */
+  struct ${typename} {
+  public:
+    ${indent(cppStructProps, '    ')}
+
+  public:
+    ${typename}() = default;
+    explicit ${typename}(${cppConstructorParams}): ${cppInitializerParams} {}
+  };
+
+} // namespace ${cxxNamespace}
+
+namespace margelo::nitro {
+
+  // C++ ${typename} <> JS ${typename} (object)
+  template <>
+  struct JSIConverter<${fullyQualifiedTypename}> final {
+    static inline ${fullyQualifiedTypename} fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return ${fullyQualifiedTypename}(
+        ${indent(cppFromJsiParams, '        ')}
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const ${fullyQualifiedTypename}& arg) {
+      jsi::Object obj(runtime);
+      ${indent(cppToJsiCalls, '      ')}
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      ${indent(cppCanConvertCalls, '      ')}
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro
+  `;
+    return {
+        content: cppCode,
+        name: `${typename}.hpp`,
+        subdirectory: [],
+        language: 'c++',
+        referencedTypes: properties,
+        platform: 'shared',
+    };
+}

package/lib/syntax/c++/CppUnion.js

@@ -0,0 +1,88 @@
+import { createFileMetadataString } from './../helpers.js';
+import { indent, toLowerCamelCase } from '../../utils.js';
+import { includeNitroHeader } from './includeNitroHeader.js';
+import { NitroConfig } from '../../config/NitroConfig.js';
+/**
+ * Creates a C++ enum that converts to a TypeScript union (aka just strings).
+ */
+export function createCppUnion(typename, enumMembers) {
+    // Namespace typename
+    const fullyQualifiedTypename = NitroConfig.current.getCxxNamespace('c++', typename);
+    const cppEnumMembers = enumMembers
+        .map((m, i) => `${m.name}      SWIFT_NAME(${toLowerCamelCase(m.name)}) = ${i},`)
+        .join('\n');
+    const cppFromJsiHashCases = enumMembers
+        .map((v) => `case hashString("${v.stringValue}"): return ${fullyQualifiedTypename}::${v.name};`.trim())
+        .join('\n');
+    const cppToJsiCases = enumMembers
+        .map((v) => `case ${fullyQualifiedTypename}::${v.name}: return JSIConverter<std::string>::toJSI(runtime, "${v.stringValue}");`)
+        .join('\n');
+    const cppCanConvertCases = enumMembers
+        .map((m) => `case hashString("${m.stringValue}"):`)
+        .join('\n');
+    const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
+    const cppCode = `
+${createFileMetadataString(`${typename}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('NitroHash.hpp')}
+${includeNitroHeader('JSIConverter.hpp')}
+${includeNitroHeader('NitroDefines.hpp')}
+
+namespace ${cxxNamespace} {
+
+  /**
+   * An enum which can be represented as a JavaScript union (${typename}).
+   */
+  enum class ${typename} {
+    ${indent(cppEnumMembers, '    ')}
+  } CLOSED_ENUM;
+
+} // namespace ${cxxNamespace}
+
+namespace margelo::nitro {
+
+  // C++ ${typename} <> JS ${typename} (union)
+  template <>
+  struct JSIConverter<${fullyQualifiedTypename}> final {
+    static inline ${fullyQualifiedTypename} fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        ${indent(cppFromJsiHashCases, '        ')}
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \\"" + unionValue + "\\" to enum ${typename} - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, ${fullyQualifiedTypename} arg) {
+      switch (arg) {
+        ${indent(cppToJsiCases, '        ')}
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert ${typename} to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        ${indent(cppCanConvertCases, '        ')}
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro
+          `;
+    return {
+        content: cppCode,
+        name: `${typename}.hpp`,
+        subdirectory: [],
+        language: 'c++',
+        platform: 'shared',
+    };
+}

package/lib/syntax/c++/getForwardDeclaration.js

@@ -0,0 +1,14 @@
+export function getForwardDeclaration(kind, className, namespace) {
+    if (namespace != null) {
+        return `
+// Forward declaration of \`${className}\` to properly resolve imports.
+namespace ${namespace} { ${kind} ${className}; }
+  `.trim();
+    }
+    else {
+        return `
+// Forward declaration of \`${className}\` to properly resolve imports.
+${kind} ${className};
+    `.trim();
+    }
+}

package/lib/syntax/c++/includeNitroHeader.js

@@ -0,0 +1,34 @@
+/**
+ * Generates C++ code for including a `NitroModules` header.
+ * @example `Hash.hpp` -> `#include <NitroModules/Hash.hpp>`
+ */
+export function includeNitroHeader(headerName) {
+    return `
+#if __has_include(<NitroModules/${headerName}>)
+#include <NitroModules/${headerName}>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+  `.trim();
+}
+export function includeHeader(sourceImport, force = true) {
+    const header = getHeader(sourceImport.name, sourceImport.space);
+    if (force) {
+        return `#include ${header}`;
+    }
+    else {
+        return `
+#if __has_include(${header})
+ #include ${header}
+#endif
+    `.trim();
+    }
+}
+function getHeader(name, space) {
+    switch (space) {
+        case 'user':
+            return `"${name}"`;
+        case 'system':
+            return `<${name}>`;
+    }
+}

package/lib/syntax/createType.js

@@ -0,0 +1,303 @@
+import { ts, Type as TSMorphType } from 'ts-morph';
+import { NullType } from './types/NullType.js';
+import { BooleanType } from './types/BooleanType.js';
+import { NumberType } from './types/NumberType.js';
+import { StringType } from './types/StringType.js';
+import { BigIntType } from './types/BigIntType.js';
+import { VoidType } from './types/VoidType.js';
+import { ArrayType } from './types/ArrayType.js';
+import { FunctionType } from './types/FunctionType.js';
+import { PromiseType } from './types/PromiseType.js';
+import { RecordType } from './types/RecordType.js';
+import { ArrayBufferType } from './types/ArrayBufferType.js';
+import { EnumType } from './types/EnumType.js';
+import { HybridObjectType } from './types/HybridObjectType.js';
+import { StructType } from './types/StructType.js';
+import { OptionalType } from './types/OptionalType.js';
+import { NamedWrappingType } from './types/NamedWrappingType.js';
+import { getInterfaceProperties } from './getInterfaceProperties.js';
+import { VariantType } from './types/VariantType.js';
+import { MapType } from './types/MapType.js';
+import { TupleType } from './types/TupleType.js';
+import { isAnyHybridSubclass, isDirectlyHybridObject, isHybridView, } from '../getPlatformSpecs.js';
+import { HybridObjectBaseType } from './types/HybridObjectBaseType.js';
+import { ErrorType } from './types/ErrorType.js';
+import { getBaseTypes, getHybridObjectNitroModuleConfig } from '../utils.js';
+import { DateType } from './types/DateType.js';
+import { NitroConfig } from '../config/NitroConfig.js';
+import { CustomType } from './types/CustomType.js';
+import { isSyncFunction, isArrayBuffer, isCustomType, isDate, isError, isMap, isPromise, isRecord, } from './isCoreType.js';
+import { getCustomTypeConfig } from './getCustomTypeConfig.js';
+function getHybridObjectName(type) {
+    const symbol = isHybridView(type) ? type.getAliasSymbol() : type.getSymbol();
+    if (symbol == null) {
+        throw new Error(`Cannot get name of \`${type.getText()}\` - symbol not found!`);
+    }
+    return symbol.getEscapedName();
+}
+function getFunctionCallSignature(func) {
+    const callSignatures = func.getCallSignatures();
+    const callSignature = callSignatures[0];
+    if (callSignatures.length !== 1 || callSignature == null) {
+        throw new Error(`Function overloads are not supported in Nitrogen! (in ${func.getText()})`);
+    }
+    return callSignature;
+}
+function removeDuplicates(types) {
+    return types.filter((t1, index, array) => {
+        const firstIndexOfType = array.findIndex((t2) => t1.getCode('c++') === t2.getCode('c++'));
+        return firstIndexOfType === index;
+    });
+}
+function getArguments(type, typename, count) {
+    const typeArguments = type.getTypeArguments();
+    if (typeArguments.length === count) {
+        return typeArguments;
+    }
+    const aliasTypeArguments = type.getAliasTypeArguments();
+    if (aliasTypeArguments.length === count) {
+        return aliasTypeArguments;
+    }
+    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) {
+    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));
+}
+export function createVoidType() {
+    return new VoidType();
+}
+const knownTypes = {
+    'c++': new Map(),
+    'swift': new Map(),
+    'kotlin': new Map(),
+};
+/**
+ * Get a list of all currently known complex types.
+ */
+export function getAllKnownTypes(language) {
+    if (language != null) {
+        // Get types for the given language
+        return Array.from(knownTypes[language].values());
+    }
+    else {
+        // Get types for all languages alltogether
+        const allMaps = Object.values(knownTypes);
+        return allMaps.flatMap((m) => Array.from(m.values()));
+    }
+}
+function getTypeId(type, isOptional) {
+    const symbol = type.getSymbol();
+    let key = type.getText();
+    if (symbol != null) {
+        key += '_' + symbol.getFullyQualifiedName();
+    }
+    if (isOptional)
+        key += '?';
+    return key;
+}
+export function addKnownType(key, type, language) {
+    if (knownTypes[language].has(key)) {
+        // type is already known
+        return;
+    }
+    knownTypes[language].set(key, type);
+}
+/**
+ * Create a new type (or return it from cache if it is already known)
+ */
+export function createType(language, type, isOptional) {
+    const key = getTypeId(type, isOptional);
+    if (key != null && knownTypes[language].has(key)) {
+        const known = knownTypes[language].get(key);
+        if (isOptional === known instanceof OptionalType) {
+            return known;
+        }
+    }
+    const get = () => {
+        if (isOptional) {
+            const wrapping = createType(language, type, false);
+            return new OptionalType(wrapping);
+        }
+        if (type.isNull() || type.isUndefined()) {
+            return new NullType();
+        }
+        else if (type.isBoolean() || type.isBooleanLiteral()) {
+            return new BooleanType();
+        }
+        else if (type.isNumber() || type.isNumberLiteral()) {
+            if (type.isEnumLiteral()) {
+                // enum literals are technically just numbers - but we treat them differently in C++.
+                return createType(language, type.getBaseTypeOfLiteralType(), isOptional);
+            }
+            return new NumberType();
+        }
+        else if (type.isString()) {
+            return new StringType();
+        }
+        else if (type.isBigInt() || type.isBigIntLiteral()) {
+            return new BigIntType();
+        }
+        else if (type.isVoid()) {
+            return new VoidType();
+        }
+        else if (type.isArray()) {
+            const arrayElementType = type.getArrayElementTypeOrThrow();
+            const elementType = createType(language, arrayElementType, false);
+            return new ArrayType(elementType);
+        }
+        else if (type.isTuple()) {
+            const itemTypes = type
+                .getTupleElements()
+                .map((t) => createType(language, t, t.isNullable()));
+            return new TupleType(itemTypes);
+        }
+        else if (type.getCallSignatures().length > 0) {
+            // It's a function!
+            const callSignature = getFunctionCallSignature(type);
+            const funcReturnType = callSignature.getReturnType();
+            const returnType = createType(language, funcReturnType, funcReturnType.isNullable());
+            const parameters = callSignature.getParameters().map((p) => {
+                const declaration = p.getValueDeclarationOrThrow();
+                const parameterType = p.getTypeAtLocation(declaration);
+                const isNullable = parameterType.isNullable() || p.isOptional();
+                return createNamedType(language, p.getName(), parameterType, isNullable);
+            });
+            const isSync = isSyncFunction(type);
+            return new FunctionType(returnType, parameters, isSync);
+        }
+        else if (isPromise(type)) {
+            // It's a Promise!
+            const [promiseResolvingType] = getArguments(type, 'Promise', 1);
+            const resolvingType = createType(language, promiseResolvingType, promiseResolvingType.isNullable());
+            return new PromiseType(resolvingType);
+        }
+        else if (isRecord(type)) {
+            // Record<K, V> -> unordered_map<K, V>
+            const [keyTypeT, valueTypeT] = getArguments(type, 'Record', 2);
+            const keyType = createType(language, keyTypeT, false);
+            const valueType = createType(language, valueTypeT, false);
+            return new RecordType(keyType, valueType);
+        }
+        else if (isArrayBuffer(type)) {
+            // ArrayBuffer
+            return new ArrayBufferType();
+        }
+        else if (isMap(type)) {
+            // Map
+            return new MapType();
+        }
+        else if (isDate(type)) {
+            // Date
+            return new DateType();
+        }
+        else if (isError(type)) {
+            // Error
+            return new ErrorType();
+        }
+        else if (isCustomType(type)) {
+            // Custom C++ type (manually written)
+            const { name, config } = getCustomTypeConfig(type);
+            return new CustomType(name, config);
+        }
+        else if (type.isEnum()) {
+            // It is an enum. We need to generate a C++ declaration for the enum
+            const typename = type.getSymbolOrThrow().getEscapedName();
+            const declaration = type.getSymbolOrThrow().getValueDeclarationOrThrow();
+            const enumDeclaration = declaration.asKindOrThrow(ts.SyntaxKind.EnumDeclaration);
+            return new EnumType(typename, enumDeclaration);
+        }
+        else if (type.isUnion()) {
+            // It is some kind of union;
+            // - 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 isEnumUnion = nonNullTypes.every((t) => t.isStringLiteral());
+            if (isEnumUnion) {
+                // It consists only of string literaly - that means it's describing an enum!
+                const symbol = type.getNonNullableType().getAliasSymbol();
+                if (symbol == null) {
+                    // If there is no alias, it is an inline union instead of a separate type declaration!
+                    throw new Error(`Inline union types ("${type.getText()}") are not supported by Nitrogen!\n` +
+                        `Extract the union to a separate type, and re-run nitrogen!`);
+                }
+                const typename = symbol.getEscapedName();
+                return new EnumType(typename, type);
+            }
+            else {
+                // It consists of different types - that means it's a variant!
+                let variants = type
+                    .getUnionTypes()
+                    // Filter out any nulls or undefineds, as those are already treated as `isOptional`.
+                    .filter((t) => !t.isNull() && !t.isUndefined() && !t.isVoid())
+                    .map((t) => createType(language, t, false));
+                variants = removeDuplicates(variants);
+                if (variants.length === 1) {
+                    // It's just one type with undefined/null variant(s) - so we treat it like a simple optional.
+                    return variants[0];
+                }
+                const name = type.getAliasSymbol()?.getName();
+                return new VariantType(variants, name);
+            }
+        }
+        else if (isAnyHybridSubclass(type)) {
+            // It is another HybridObject being referenced!
+            const typename = getHybridObjectName(type);
+            const baseTypes = getBaseTypes(type)
+                .filter((t) => isAnyHybridSubclass(t))
+                .map((b) => createType(language, b, false));
+            const baseHybrids = baseTypes.filter((b) => b instanceof HybridObjectType);
+            const sourceConfig = getHybridObjectNitroModuleConfig(type) ?? NitroConfig.current;
+            return new HybridObjectType(typename, language, baseHybrids, sourceConfig);
+        }
+        else if (isDirectlyHybridObject(type)) {
+            // It is a HybridObject directly/literally. Base type
+            return new HybridObjectBaseType();
+        }
+        else if (type.isInterface()) {
+            // It is an `interface T { ... }`, which is a `struct`
+            const typename = type.getSymbolOrThrow().getName();
+            const properties = getInterfaceProperties(language, type);
+            return new StructType(typename, properties);
+        }
+        else if (type.isObject()) {
+            // It is an object. If it has a symbol/name, it is a `type T = ...` declaration, so a `struct`.
+            // Otherwise, it is an anonymous/inline object, which cannot be represented in native.
+            const symbol = type.getAliasSymbol();
+            if (symbol != null) {
+                // it has a `type T = ...` declaration
+                const typename = symbol.getName();
+                const properties = getInterfaceProperties(language, type);
+                return new StructType(typename, properties);
+            }
+            else {
+                // It's an anonymous object (`{ ... }`)
+                throw new Error(`Anonymous objects cannot be represented in C++! Extract "${type.getText()}" to a separate interface/type declaration.`);
+            }
+        }
+        else if (type.isStringLiteral()) {
+            throw new Error(`String literal ${type.getText()} cannot be represented in C++ because it is ambiguous between a string and a discriminating union enum.`);
+        }
+        else {
+            if (type.getSymbol() == null) {
+                // There is no declaration for it!
+                // Could be an invalid import, e.g. an alias
+                throw new Error(`The TypeScript type "${type.getText()}" cannot be resolved - is it imported properly? ` +
+                    `Make sure to import it properly using fully specified relative or absolute imports, no aliases.`);
+            }
+            else {
+                // A different error
+                throw new Error(`The TypeScript type "${type.getText()}" cannot be represented in C++!`);
+            }
+        }
+    };
+    const result = get();
+    if (key != null) {
+        knownTypes[language].set(key, result);
+    }
+    return result;
+}

package/lib/syntax/getAllTypes.js

@@ -0,0 +1,11 @@
+// TODO: Structs or other HybridObjects may reference other types recursively - we need to add a `referencedTypes` prop to each `Type` to be able to resolve that.
+export function getAllTypes(spec) {
+    const types = [];
+    // 1. Properties
+    types.push(...spec.properties.map((p) => p.type));
+    // 2. Method return types
+    types.push(...spec.methods.map((m) => m.returnType));
+    // 3. Method parameters
+    types.push(...spec.methods.flatMap((m) => m.parameters.map((p) => p.type)));
+    return types;
+}

package/lib/syntax/getCustomTypeConfig.js

@@ -0,0 +1,53 @@
+export function getCustomTypeConfig(type) {
+    const parts = type.getIntersectionTypes();
+    for (const part of parts) {
+        const typeNameProperty = part.getProperty('__customTypeName');
+        if (typeNameProperty == null)
+            continue;
+        const typeConfigProperty = part.getProperty('__customTypeConfig');
+        if (typeConfigProperty == null)
+            continue;
+        const declaration = type.getAliasSymbolOrThrow().getDeclarations()[0];
+        if (declaration == null)
+            throw new Error(`Type has no declaration! ${type.getText()}`);
+        const typeNameTypeOrUndefined = typeNameProperty.getTypeAtLocation(declaration);
+        const typeConfigTypeOrUndefined = typeConfigProperty.getTypeAtLocation(declaration);
+        const typeNameType = typeNameTypeOrUndefined
+            .getUnionTypes()
+            .find((t) => t.isLiteral());
+        if (typeNameType == null)
+            continue;
+        const typeConfigType = typeConfigTypeOrUndefined
+            .getUnionTypes()
+            .find((t) => t.isObject());
+        if (typeConfigType == null)
+            continue;
+        const typeName = typeNameType.getLiteralValue();
+        if (typeof typeName !== 'string') {
+            throw new Error(`CustomType's second argument (TypeName) needs to be a string! Instead, it is a ${typeof typeName} (${typeName})`);
+        }
+        const includeType = typeConfigType
+            .getPropertyOrThrow('include')
+            .getTypeAtLocation(declaration);
+        const include = includeType.getLiteralValue();
+        if (typeof include !== 'string')
+            throw new Error(`CustomType's third argument (Config) needs to contain { include }, which should be a string! (It is ${includeType.getText()} instead)`);
+        const canBePassedByReferenceType = typeConfigType
+            .getProperty('canBePassedByReference')
+            ?.getTypeAtLocation(declaration)
+            .getUnionTypes()
+            .find((u) => u.isBooleanLiteral())
+            ?.getLiteralValue();
+        const canBePassedByReference = typeof canBePassedByReferenceType === 'boolean'
+            ? canBePassedByReferenceType
+            : false;
+        return {
+            name: typeName,
+            config: {
+                include: include,
+                canBePassedByReference: canBePassedByReference,
+            },
+        };
+    }
+    throw new Error(`Type looks like a CustomType<...>, but doesn't have generic arguments! ${type.getText()}`);
+}

package/lib/syntax/getHybridObjectName.d.ts

@@ -0,0 +1,36 @@
+export interface HybridObjectName {
+    /**
+     * The raw name of the Hybrid Object (same as the TS interface name).
+     * @example "Image"
+     */
+    T: string;
+    /**
+     * The debug-only description name of the Hybrid Object as it can be described in natively.
+     * @example "HybridImage"
+     */
+    HybridT: string;
+    /**
+     * The name of the C++ class, Kotlin interface or Swift protocol that represents the
+     * specification (all of it's virtual properties and methods) of the Hybrid Object.
+     * @example "HybridImageSpec"
+     */
+    HybridTSpec: string;
+    /**
+     * The name of the Swift class that bridges any types from
+     * {@linkcode HybridTSpec} over to C++.
+     * This includes a few type conversions or result/exception wrapping.
+     * @example "HybridImage_cxx"
+     */
+    HybridTSpecCxx: string;
+    /**
+     * The name of the C++ class that actually bridges to the Java Hybrid Object.
+     * @example "JHybridImage"
+     */
+    JHybridTSpec: string;
+    /**
+     * The name of the C++ class that extends the Hybrid Object and bridges over to the Swift C++ wrapper class.
+     * @example "HybridImageSwift"
+     */
+    HybridTSpecSwift: string;
+}
+export declare function getHybridObjectName(hybridObjectName: string): HybridObjectName;

package/lib/syntax/getHybridObjectName.js

@@ -0,0 +1,10 @@
+export function getHybridObjectName(hybridObjectName) {
+    return {
+        T: hybridObjectName,
+        HybridT: `Hybrid${hybridObjectName}`,
+        HybridTSpec: `Hybrid${hybridObjectName}Spec`,
+        HybridTSpecCxx: `Hybrid${hybridObjectName}Spec_cxx`,
+        JHybridTSpec: `JHybrid${hybridObjectName}Spec`,
+        HybridTSpecSwift: `Hybrid${hybridObjectName}SpecSwift`,
+    };
+}

package/lib/syntax/getInterfaceProperties.js

@@ -0,0 +1,9 @@
+import { createNamedType } from './createType.js';
+export function getInterfaceProperties(language, interfaceType) {
+    return interfaceType.getProperties().map((prop) => {
+        const declaration = prop.getValueDeclarationOrThrow();
+        const propType = prop.getTypeAtLocation(declaration);
+        const refType = createNamedType(language, prop.getName(), propType, prop.isOptional() || propType.isNullable());
+        return refType;
+    });
+}