nitrogen 0.2.23 → 0.29.4

package/src/syntax/c++/CppHybridObject.ts

@@ -0,0 +1,165 @@
+import type { SourceFile } from '../SourceFile.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import { indent } from '../../utils.js'
+import type { HybridObjectSpec } from '../HybridObjectSpec.js'
+import { includeHeader, includeNitroHeader } from './includeNitroHeader.js'
+import { getHybridObjectName } from '../getHybridObjectName.js'
+import { HybridObjectType } from '../types/HybridObjectType.js'
+
+export function createCppHybridObject(spec: HybridObjectSpec): SourceFile[] {
+  // Extra includes
+  const extraFiles = [
+    ...spec.properties.flatMap((p) => p.getExtraFiles()),
+    ...spec.methods.flatMap((m) => m.getExtraFiles()),
+  ]
+  const extraIncludes = [
+    ...spec.properties.flatMap((p) => p.getRequiredImports('c++')),
+    ...spec.methods.flatMap((m) => m.getRequiredImports('c++')),
+    ...spec.baseTypes.flatMap((b) =>
+      new HybridObjectType(b).getRequiredImports('c++')
+    ),
+  ]
+  const cppForwardDeclarations = extraIncludes
+    .map((i) => i.forwardDeclaration)
+    .filter((v) => v != null)
+    .filter(isNotDuplicate)
+  const cppExtraIncludes = extraIncludes
+    .map((i) => includeHeader(i))
+    .filter(isNotDuplicate)
+  const cxxNamespace = spec.config.getCxxNamespace('c++')
+  const name = getHybridObjectName(spec.name)
+
+  const bases = ['public virtual HybridObject']
+  for (const base of spec.baseTypes) {
+    const baseName = getHybridObjectName(base.name).HybridTSpec
+    const fullName = base.config.isExternalConfig
+      ? base.config.getCxxNamespace('c++', baseName)
+      : baseName
+    bases.push(`public virtual ${fullName}`)
+  }
+
+  // Generate the full header / code
+  const cppHeaderCode = `
+${createFileMetadataString(`${name.HybridTSpec}.hpp`)}
+
+#pragma once
+
+${includeNitroHeader('HybridObject.hpp')}
+
+${cppForwardDeclarations.join('\n')}
+
+${cppExtraIncludes.join('\n')}
+
+namespace ${cxxNamespace} {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for \`${spec.name}\`
+   * Inherit this class to create instances of \`${name.HybridTSpec}\` in C++.
+   * You must explicitly call \`HybridObject\`'s constructor yourself, because it is virtual.
+   * @example
+   * \`\`\`cpp
+   * class ${name.HybridT}: public ${name.HybridTSpec} {
+   * public:
+   *   ${name.HybridT}(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * \`\`\`
+   */
+  class ${name.HybridTSpec}: ${bases.join(', ')} {
+    public:
+      // Constructor
+      explicit ${name.HybridTSpec}(): HybridObject(TAG) { }
+
+      // Destructor
+      ~${name.HybridTSpec}() override = default;
+
+    public:
+      // Properties
+      ${indent(spec.properties.map((p) => p.getCode('c++', { virtual: true })).join('\n'), '      ')}
+
+    public:
+      // Methods
+      ${indent(spec.methods.map((m) => m.getCode('c++', { virtual: true })).join('\n'), '      ')}
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "${spec.name}";
+  };
+
+} // namespace ${cxxNamespace}
+    `
+
+  // Each C++ method needs to be registered in the HybridObject - that's getters, setters and normal methods.
+  const registrations: string[] = []
+  for (const property of spec.properties) {
+    const getterMethod = property.getGetterName('other')
+    const setterMethod = property.getSetterName('other')
+    // getter
+    registrations.push(
+      `prototype.registerHybridGetter("${property.name}", &${name.HybridTSpec}::${getterMethod});`
+    )
+    if (!property.isReadonly) {
+      // setter
+      registrations.push(
+        `prototype.registerHybridSetter("${property.name}", &${name.HybridTSpec}::${setterMethod});`
+      )
+    }
+  }
+  for (const method of spec.methods) {
+    // method
+    registrations.push(
+      `prototype.registerHybridMethod("${method.name}", &${name.HybridTSpec}::${method.name});`
+    )
+  }
+
+  const basePrototypeRegistrations = ['HybridObject::loadHybridMethods();']
+  for (const base of spec.baseTypes) {
+    const hybridObjectName = getHybridObjectName(base.name)
+    basePrototypeRegistrations.push(
+      `${hybridObjectName.HybridTSpec}::loadHybridMethods();`
+    )
+  }
+
+  const cppBodyCode = `
+${createFileMetadataString(`${name.HybridTSpec}.cpp`)}
+
+#include "${name.HybridTSpec}.hpp"
+
+namespace ${cxxNamespace} {
+
+  void ${name.HybridTSpec}::loadHybridMethods() {
+    // load base methods/properties
+    ${indent(basePrototypeRegistrations.join('\n'), '    ')}
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      ${indent(registrations.join('\n'), '      ')}
+    });
+  }
+
+} // namespace ${cxxNamespace}
+    `
+
+  const files: SourceFile[] = []
+  files.push({
+    content: cppHeaderCode,
+    name: `${name.HybridTSpec}.hpp`,
+    subdirectory: [],
+    language: 'c++',
+    platform: 'shared',
+  })
+  files.push({
+    content: cppBodyCode,
+    name: `${name.HybridTSpec}.cpp`,
+    subdirectory: [],
+    language: 'c++',
+    platform: 'shared',
+  })
+  files.push(...extraFiles)
+  return files
+}

package/src/syntax/c++/CppHybridObjectRegistration.ts

@@ -0,0 +1,39 @@
+import type { SourceImport } from '../SourceFile.js'
+
+interface Props {
+  /**
+   * The name of the Hybrid Object under which it should be registered and exposed to JS to.
+   */
+  hybridObjectName: string
+  /**
+   * The name of the C++ class that will be default-constructed
+   */
+  cppClassName: string
+}
+
+interface CppHybridObjectRegistration {
+  cppCode: string
+  requiredImports: SourceImport[]
+}
+
+export function createCppHybridObjectRegistration({
+  hybridObjectName,
+  cppClassName,
+}: Props): CppHybridObjectRegistration {
+  return {
+    requiredImports: [
+      { name: `${cppClassName}.hpp`, language: 'c++', space: 'user' },
+    ],
+    cppCode: `
+HybridObjectRegistry::registerHybridObjectConstructor(
+  "${hybridObjectName}",
+  []() -> std::shared_ptr<HybridObject> {
+    static_assert(std::is_default_constructible_v<${cppClassName}>,
+                  "The HybridObject \\"${cppClassName}\\" is not default-constructible! "
+                  "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+    return std::make_shared<${cppClassName}>();
+  }
+);
+      `.trim(),
+  }
+}

package/src/syntax/c++/CppStruct.ts

@@ -0,0 +1,129 @@
+import type { FileWithReferencedTypes } from '../SourceFile.js'
+import { indent } from '../../utils.js'
+import { createFileMetadataString, isNotDuplicate } from '../helpers.js'
+import type { NamedType } from '../types/Type.js'
+import { includeHeader, includeNitroHeader } from './includeNitroHeader.js'
+import { NitroConfig } from '../../config/NitroConfig.js'
+import type { GetFunctionCodeOptions } from '../types/FunctionType.js'
+
+export function createCppStruct(
+  typename: string,
+  properties: NamedType[]
+): FileWithReferencedTypes {
+  // 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: GetFunctionCodeOptions = {
+    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/src/syntax/c++/CppUnion.ts

@@ -0,0 +1,105 @@
+import type { SourceFile } from '../SourceFile.js'
+import { createFileMetadataString } from './../helpers.js'
+import { indent, toLowerCamelCase } from '../../utils.js'
+import type { EnumMember } from '../types/EnumType.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: string,
+  enumMembers: EnumMember[]
+): SourceFile {
+  // 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/src/syntax/c++/getForwardDeclaration.ts

@@ -0,0 +1,19 @@
+type DeclarationKind = 'class' | 'struct' | 'enum class'
+
+export function getForwardDeclaration(
+  kind: DeclarationKind,
+  className: string,
+  namespace?: string
+): string {
+  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/src/syntax/c++/includeNitroHeader.ts

@@ -0,0 +1,40 @@
+import type { SourceImport } from '../SourceFile.js'
+
+/**
+ * Generates C++ code for including a `NitroModules` header.
+ * @example `Hash.hpp` -> `#include <NitroModules/Hash.hpp>`
+ */
+export function includeNitroHeader(headerName: string): string {
+  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: SourceImport,
+  force = true
+): string {
+  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: string, space: 'user' | 'system'): string {
+  switch (space) {
+    case 'user':
+      return `"${name}"`
+    case 'system':
+      return `<${name}>`
+  }
+}