nitrogen 0.2.24 → 0.29.5

package/lib/syntax/types/VariantType.js

@@ -0,0 +1,75 @@
+import { escapeCppName, isNotDuplicate } from '../helpers.js';
+import {} from '../SourceFile.js';
+export const VariantLabels = [
+    'first',
+    'second',
+    'third',
+    'fourth',
+    'fifth',
+    'sixth',
+    'seventh',
+    'eigth',
+    'ninth',
+    'tenth',
+];
+export class VariantType {
+    variants;
+    aliasName;
+    constructor(variants, aliasName) {
+        this.variants = variants;
+        this.aliasName = aliasName;
+    }
+    get canBePassedByReference() {
+        // It's a variant<..> - heavy to copy
+        return true;
+    }
+    get kind() {
+        return 'variant';
+    }
+    get jsType() {
+        return this.variants.map((v) => v.kind).join(' | ');
+    }
+    get cases() {
+        return this.variants.map((v, i) => {
+            const label = VariantLabels[i];
+            if (label == null)
+                throw new Error(`Variant<...> (\`${this.jsType}\`) does not support ${i} cases!`);
+            return [label, v];
+        });
+    }
+    getAliasName(language, options) {
+        if (this.aliasName == null) {
+            const variants = this.variants.map((v) => v.getCode(language, options));
+            return escapeCppName(`Variant_${variants.join('_')}`);
+        }
+        return this.aliasName;
+    }
+    getCode(language, options) {
+        const types = this.variants
+            .map((v) => v.getCode(language, options))
+            .filter(isNotDuplicate);
+        switch (language) {
+            case 'c++':
+                return `std::variant<${types.join(', ')}>`;
+            case 'swift':
+            case 'kotlin':
+                return this.getAliasName(language, options);
+            default:
+                throw new Error(`Language ${language} is not yet supported for VariantType!`);
+        }
+    }
+    getExtraFiles() {
+        return this.variants.flatMap((v) => v.getExtraFiles());
+    }
+    getRequiredImports(language) {
+        const imports = this.variants.flatMap((v) => v.getRequiredImports(language));
+        if (language === 'c++') {
+            imports.push({
+                language: 'c++',
+                name: 'variant',
+                space: 'system',
+            });
+        }
+        return imports;
+    }
+}

package/lib/syntax/types/VoidType.js

@@ -0,0 +1,27 @@
+export class VoidType {
+    get canBePassedByReference() {
+        // It's void.
+        return false;
+    }
+    get kind() {
+        return 'void';
+    }
+    getCode(language) {
+        switch (language) {
+            case 'c++':
+                return 'void';
+            case 'swift':
+                return 'Void';
+            case 'kotlin':
+                return 'Unit';
+            default:
+                throw new Error(`Language ${language} is not yet supported for VoidType!`);
+        }
+    }
+    getExtraFiles() {
+        return [];
+    }
+    getRequiredImports() {
+        return [];
+    }
+}

package/lib/syntax/types/getTypeAs.js

@@ -0,0 +1,12 @@
+import { NamedWrappingType } from './NamedWrappingType.js';
+export function getTypeAs(type, classReference) {
+    if (type instanceof classReference) {
+        return type;
+    }
+    else if (type instanceof NamedWrappingType) {
+        return getTypeAs(type.type, classReference);
+    }
+    else {
+        throw new Error(`Type of kind "${type.kind}" is not a ${classReference}!`);
+    }
+}

package/lib/utils.js

@@ -0,0 +1,126 @@
+import path from 'path';
+import fs from 'fs';
+import { isNotDuplicate } from './syntax/helpers.js';
+import { readUserConfig } from './config/getConfig.js';
+import { NitroConfig } from './config/NitroConfig.js';
+export const NITROGEN_VERSION = process.env.npm_package_version ?? '?.?.?';
+export function capitalizeName(name) {
+    if (name.length === 0)
+        return name;
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+export function createIndentation(spacesCount) {
+    return Array.from(Array(spacesCount)).fill(' ').join('');
+}
+export function indent(string, indentation) {
+    let spaces;
+    if (typeof indentation === 'number') {
+        spaces = createIndentation(indentation);
+    }
+    else {
+        spaces = indentation;
+    }
+    return string.replaceAll('\n', `\n${spaces}`);
+}
+export function errorToString(error) {
+    if (error == null) {
+        return `null`;
+    }
+    if (typeof error !== 'object') {
+        return `${error}`;
+    }
+    if (error instanceof Error) {
+        let message = `${error.name}: ${error.message}`;
+        if (error.cause != null) {
+            message += ` (cause: ${JSON.stringify(error.cause)})`;
+        }
+        return message;
+    }
+    if ('toString' in error) {
+        return error.toString();
+    }
+    return JSON.stringify(error);
+}
+export function escapeComments(string) {
+    return string
+        .replace(/\/\*/g, '/ *') // Escape start of comment
+        .replace(/\*\//g, '* /') // Escape end of comment
+        .replace(/\/\//g, '/ /'); // Escape single-line comment
+}
+const HAS_UNIX_PATHS = path.join('a', 'b').includes('/');
+export function toUnixPath(p) {
+    if (HAS_UNIX_PATHS)
+        return p;
+    return p.replaceAll('\\', '/');
+}
+const sep = path.sep;
+export function unsafeFastJoin(...segments) {
+    // this function should really not take any unsafe strings like `/` or `\`.
+    return segments.join(sep);
+}
+function getFullPath(file) {
+    return unsafeFastJoin(file.platform, file.language, ...file.subdirectory, file.name);
+}
+/**
+ * Deduplicates all files via their full path.
+ * If content differs, you are f*cked.
+ */
+export function deduplicateFiles(files) {
+    const map = new Map();
+    for (const file of files) {
+        const filePath = getFullPath(file);
+        if (!map.has(filePath)) {
+            map.set(filePath, file);
+        }
+    }
+    return [...map.values()];
+}
+export function filterDuplicateHelperBridges(bridge, i, array) {
+    const otherIndex = array.findIndex((f2) => bridge.specializationName === f2.specializationName);
+    return otherIndex === i;
+}
+export function toLowerCamelCase(string) {
+    const parts = string.split('_').filter((part) => part !== '');
+    if (parts.length === 0)
+        return '';
+    const camelCaseString = parts[0].toLowerCase();
+    const camelCased = parts
+        .slice(1)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase());
+    return camelCaseString + camelCased.join('');
+}
+export function getBaseTypes(type) {
+    const baseTypes = type.getBaseTypes();
+    const symbol = type.getSymbol();
+    if (symbol != null) {
+        baseTypes.push(...symbol.getDeclaredType().getBaseTypes());
+    }
+    const recursive = baseTypes.flatMap((b) => [b, ...getBaseTypes(b)]);
+    return recursive.filter(isNotDuplicate);
+}
+export function getHybridObjectNitroModuleConfig(type) {
+    const symbol = type.getSymbol() ?? type.getAliasSymbol();
+    if (!symbol)
+        return undefined;
+    const declarations = symbol.getValueDeclaration() || symbol.getDeclarations()[0];
+    if (!declarations)
+        return undefined;
+    const sourceFile = declarations.getSourceFile();
+    let filePath = sourceFile.getFilePath();
+    while (true) {
+        // go up one dir
+        const newFilePath = path.resolve(path.join(filePath, '..'));
+        if (filePath === newFilePath) {
+            // going 'cd ..' in that path didn't change a thing - so we
+            // reached the root directory. we didn't find a nitro.json anywhere.
+            return undefined;
+        }
+        filePath = newFilePath;
+        const nitroJsonPath = path.join(filePath, 'nitro.json');
+        const hasNitroJson = fs.existsSync(nitroJsonPath);
+        if (hasNitroJson) {
+            const config = readUserConfig(nitroJsonPath);
+            return new NitroConfig(config);
+        }
+    }
+}

package/lib/views/CppHybridViewComponent.js

@@ -0,0 +1,256 @@
+import { createIndentation, indent } from '../utils.js';
+import { createFileMetadataString, escapeCppName, isFunction, isNotDuplicate, } from '../syntax/helpers.js';
+import { getHybridObjectName } from '../syntax/getHybridObjectName.js';
+import { includeHeader } from '../syntax/c++/includeNitroHeader.js';
+import { createHostComponentJs } from './createHostComponentJs.js';
+import { Property } from '../syntax/Property.js';
+import { FunctionType } from '../syntax/types/FunctionType.js';
+import { VoidType } from '../syntax/types/VoidType.js';
+import { HybridObjectType } from '../syntax/types/HybridObjectType.js';
+import { NamedWrappingType } from '../syntax/types/NamedWrappingType.js';
+import { OptionalType } from '../syntax/types/OptionalType.js';
+export function getViewComponentNames(spec) {
+    const name = getHybridObjectName(spec.name);
+    return {
+        propsClassName: `${name.HybridT}Props`,
+        stateClassName: `${name.HybridT}State`,
+        nameVariable: `${name.HybridT}ComponentName`,
+        shadowNodeClassName: `${name.HybridT}ShadowNode`,
+        descriptorClassName: `${name.HybridT}ComponentDescriptor`,
+        component: `${name.HybridT}Component`,
+        manager: `${name.HybridT}Manager`,
+    };
+}
+function getHybridRefProperty(spec) {
+    const hybrid = new HybridObjectType(spec);
+    const type = new FunctionType(new VoidType(), [
+        new NamedWrappingType('ref', hybrid),
+    ]);
+    return new Property('hybridRef', new OptionalType(type), false);
+}
+export function createViewComponentShadowNodeFiles(spec) {
+    if (!spec.isHybridView) {
+        throw new Error(`Cannot create View Component ShadowNode code for ${spec.name} - it's not a HybridView!`);
+    }
+    const { T, HybridT } = getHybridObjectName(spec.name);
+    const { propsClassName, stateClassName, nameVariable, shadowNodeClassName, descriptorClassName, component, } = getViewComponentNames(spec);
+    const namespace = spec.config.getCxxNamespace('c++', 'views');
+    const props = [...spec.properties, getHybridRefProperty(spec)];
+    const properties = props.map((p) => `CachedProp<${p.type.getCode('c++')}> ${escapeCppName(p.name)};`);
+    const cases = props.map((p) => `case hashString("${p.name}"): return true;`);
+    const includes = props
+        .flatMap((p) => p.getRequiredImports('c++').map((i) => includeHeader(i, true)))
+        .filter(isNotDuplicate);
+    // .hpp code
+    const shadowIndent = createIndentation(shadowNodeClassName.length);
+    const componentHeaderCode = `
+${createFileMetadataString(`${component}.hpp`)}
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+${includes.join('\n')}
+
+namespace ${namespace} {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char ${nameVariable}[];
+
+  /**
+   * Props for the "${spec.name}" View.
+   */
+  class ${propsClassName} final: public react::ViewProps {
+  public:
+    ${propsClassName}() = default;
+    ${propsClassName}(const ${propsClassName}&);
+    ${propsClassName}(const react::PropsParserContext& context,
+  ${createIndentation(propsClassName.length)}   const ${propsClassName}& sourceProps,
+  ${createIndentation(propsClassName.length)}   const react::RawProps& rawProps);
+
+  public:
+    ${indent(properties.join('\n'), '    ')}
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "${spec.name}" View.
+   */
+  class ${stateClassName} final {
+  public:
+    ${stateClassName}() = default;
+
+  public:
+    void setProps(const ${propsClassName}& props) { _props.emplace(props); }
+    const std::optional<${propsClassName}>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  ${stateClassName}(const ${stateClassName}& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("${stateClassName} does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("${stateClassName} does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<${propsClassName}> _props;
+  };
+
+  /**
+   * The Shadow Node for the "${spec.name}" View.
+   */
+  using ${shadowNodeClassName} = react::ConcreteViewShadowNode<${nameVariable} /* "${HybridT}" */,
+        ${shadowIndent}                                 ${propsClassName} /* custom props */,
+        ${shadowIndent}                                 react::ViewEventEmitter /* default */,
+        ${shadowIndent}                                 ${stateClassName} /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "${spec.name}" View.
+   */
+  class ${descriptorClassName} final: public react::ConcreteComponentDescriptor<${shadowNodeClassName}> {
+  public:
+    ${descriptorClassName}(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from \`${propsClassName}\`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "${spec.name}" needs to be implemented in platform-specific code. */
+
+} // namespace ${namespace}
+`.trim();
+    // .cpp code
+    const propInitializers = [
+        'react::ViewProps(context, sourceProps, rawProps, filterObjectKeys)',
+    ];
+    const propCopyInitializers = ['react::ViewProps()'];
+    for (const prop of props) {
+        const name = escapeCppName(prop.name);
+        const type = prop.type.getCode('c++');
+        let valueConversion = `value`;
+        if (isFunction(prop.type)) {
+            // Due to a React limitation, functions cannot be passed to native directly,
+            // because RN converts them to booleans (`true`). Nitro knows this and just
+            // wraps functions as objects - the original function is stored in `f`.
+            valueConversion = `value.asObject(*runtime).getProperty(*runtime, "f")`;
+        }
+        propInitializers.push(`
+${name}([&]() -> CachedProp<${type}> {
+  try {
+    const react::RawValue* rawValue = rawProps.at("${prop.name}", nullptr, nullptr);
+    if (rawValue == nullptr) return sourceProps.${name};
+    const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+    return CachedProp<${type}>::fromRawValue(*runtime, ${valueConversion}, sourceProps.${name});
+  } catch (const std::exception& exc) {
+    throw std::runtime_error(std::string("${spec.name}.${prop.name}: ") + exc.what());
+  }
+}())`.trim());
+        propCopyInitializers.push(`${name}(other.${name})`);
+    }
+    const ctorIndent = createIndentation(propsClassName.length * 2);
+    const descriptorIndent = createIndentation(descriptorClassName.length);
+    const componentCode = `
+${createFileMetadataString(`${component}.cpp`)}
+
+#include "${component}.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace ${namespace} {
+
+  extern const char ${nameVariable}[] = "${T}";
+
+  ${propsClassName}::${propsClassName}(const react::PropsParserContext& context,
+  ${ctorIndent}   const ${propsClassName}& sourceProps,
+  ${ctorIndent}   const react::RawProps& rawProps):
+    ${indent(propInitializers.join(',\n'), '    ')} { }
+
+  ${propsClassName}::${propsClassName}(const ${propsClassName}& other):
+    ${indent(propCopyInitializers.join(',\n'), '    ')} { }
+
+  bool ${propsClassName}::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      ${indent(cases.join('\n'), '      ')}
+      default: return false;
+    }
+  }
+
+  ${descriptorClassName}::${descriptorClassName}(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> ${descriptorClassName}::cloneProps(const react::PropsParserContext& context,
+                                      ${descriptorIndent}             const std::shared_ptr<const react::Props>& props,
+                                      ${descriptorIndent}             react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return ${shadowNodeClassName}::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void ${descriptorClassName}::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after \`ShadowNode\` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<${shadowNodeClassName}&>(shadowNode);
+    const ${propsClassName}& props = concreteShadowNode.getConcreteProps();
+    ${stateClassName} state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace ${namespace}
+`.trim();
+    const files = [
+        {
+            name: `${component}.hpp`,
+            content: componentHeaderCode,
+            language: 'c++',
+            platform: 'shared',
+            subdirectory: ['views'],
+        },
+        {
+            name: `${component}.cpp`,
+            content: componentCode,
+            language: 'c++',
+            platform: 'shared',
+            subdirectory: ['views'],
+        },
+    ];
+    const jsFiles = createHostComponentJs(spec);
+    files.push(...jsFiles);
+    return files;
+}

package/lib/views/createHostComponentJs.js

@@ -0,0 +1,27 @@
+import { getHybridObjectName } from '../syntax/getHybridObjectName.js';
+import { indent } from '../utils.js';
+export function createHostComponentJs(spec) {
+    const { T } = getHybridObjectName(spec.name);
+    const props = spec.properties.map((p) => `"${p.name}": true`);
+    props.push(`"hybridRef": true`);
+    const code = `
+{
+  "uiViewClassName": "${T}",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    ${indent(props.join(',\n'), '    ')}
+  }
+}
+  `.trim();
+    return [
+        {
+            content: code,
+            language: 'json',
+            name: `${T}Config.json`,
+            platform: 'shared',
+            subdirectory: [],
+        },
+    ];
+}