react-native-config-ultimate 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Maksym Komarychev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# react-native-config-ultimate
+
+_Config that works_
+
+[![NPM](https://img.shields.io/npm/l/react-native-config-ultimate)](https://www.npmjs.com/package/react-native-config-ultimate)
+[![npm](https://img.shields.io/npm/v/react-native-config-ultimate?color=green&label=version)](https://www.npmjs.com/package/react-native-config-ultimate)
+[![npm](https://img.shields.io/npm/dw/react-native-config-ultimate?color=green)](https://www.npmjs.com/package/react-native-config-ultimate)
+
+---
+
+> **This is a community-maintained fork** of
+> [`react-native-ultimate-config`](https://github.com/maxkomarychev/react-native-ultimate-config)
+> originally created by [Max Komarychev](https://github.com/maxkomarychev).
+>
+> The original library has not received updates since September 2023 and does not
+> support React Native's New Architecture (TurboModules), React 19, or modern
+> tooling. This fork picks up where it left off.
+>
+> **Full credit and gratitude to Max** for the original design, architecture, and
+> years of maintenance. This project would not exist without his work.
+> The MIT license is preserved in its entirety.
+
+---
+
+## Gradle compatibility
+
+| react-native-config-ultimate | gradle |
+| ---------------------------- | ------ |
+| ^7                           | 8      |
+
+> For older versions see the original package [`react-native-ultimate-config`](https://github.com/maxkomarychev/react-native-ultimate-config).
+
+## React Native compatibility
+
+| react-native-config-ultimate | react-native | react  | New Architecture |
+| ---------------------------- | ------------ | ------ | ---------------- |
+| ^7                           | >=0.60 <1.x  | >=19   | ✅ TurboModules  |
+
+## TL;DR usage
+
+1. install
+   | npm | yarn |
+   |-|-|
+   |`npm install react-native-config-ultimate` | `yarn add react-native-config-ultimate`|
+2. [one-off setup for native projects](./docs/quickstart.md)
+3. initialize env
+   | npm | yarn |
+   |-|-|
+   |`npx rncu .env`|`yarn rncu .env`|
+4. build! `react-native run-{ios,android}`
+
+## ☝❗Approach to versioning and breaking changes
+
+This library is using [semver](https://semver.org/) and heavily relying on codegeneration. Many new features and/or bugfixes will require these files to be regenerated. Changes to codegenerated files will not be considered breaking
+unless they affect behavior of API or CLI.
+
+Therefore every time this library is updated all files MUST be regenerated using `rncu` command.
+
+## Table of contents
+
+1. [Features 🎆](#features)
+1. [Mission 🥾](#mission)
+1. [Quickstart Guide 🏃](./docs/quickstart.md)
+1. [API 🧰](./docs/api.md)
+1. [Testing Guide 🧪](./docs/testing.md)
+1. [Changelog 📓](./packages/react-native-ultimate-config/CHANGELOG.md)
+1. [Cookbook 🥦](./docs/cookbook.md)
+1. [Troubleshooting 🎱](./docs/troubleshooting.md)
+1. [Contributor notes](./docs/contributor-notes.md)
+1. [Alternatives](./docs/alternatives.md)
+
+## Features
+
+1. Simple one-off [setup](./docs/quickstart.md) for native projects
+1. No need to mess with xcode schemes or android flavors
+1. Access from [javascript](./docs/api.md#javascript)
+1. Access from native code: [java](./docs/api.md#java) and [objective-c](./docs/api.md#objective-c)
+1. Access in build tools: [xcode](./docs/api.md#ios), [gradle](./docs/api.md#buildgradle) and [AndroidManifest.xml](./docs/api.md#androidmanifestxml)
+1. [Web support](./docs/api.md#web) (works with React Native for Web)
+1. [Hooks](./docs/api.md#hooks)
+1. [Monorepo support](./docs/monorepo-tips.md) (yarn workspaces or lerna)
+1. **[New Architecture](./docs/api.md#new-architecture)** — TurboModules support (RN 0.68+), fully backward-compatible with old arch
+1. **[Multi-env file merging](./docs/api.md#multi-env-file-merging)** — `rncu .env.base .env.staging` (v7+)
+1. **[Dotenv variable expansion](./docs/api.md#dotenv-variable-expansion)** — `API_URL=$BASE_URL/v1` (v7+)
+1. **[Schema validation](./docs/api.md#schema-validation)** — fail at build time on missing or invalid vars (v7+)
+1. Unit tested with jest (83 tests)
+1. Written in TypeScript with strict mode — [exact typings](./docs/api.md#typescript) generated for your env vars
+1. Supports [dotenv and yaml](./docs/api.md#files)
+1. [Fully typed](./docs/api.md#note-about-types) values available when using yaml config
+1. Configure values [per platform](./docs/api.md#per-platform-values) in one file
+
+## Mission
+
+React-Native brings together 3 platforms: ios, android, javascript each of
+which have different conventions and approaches how to manage environment
+settings.
+
+A typical app is usually operating in some environment defined by server urls
+various api keys or feature flags. When dealing with react-native such things
+often need to exist in 3 places: ios, android and js code. Even managing things
+as simple as application name or bundle id needs to be done in 2 places:
+`Info.plist` and `AndroidManifest.xml`
+
+`react-native-config-ultimate` tries to reduce friction in managing these things
+by abstracting away from nuances of native projects.
+
+With `react-native-config-ultimate` it is possible to [consume](./docs/api.md) variables in
+every place of a typical react-native app:
+
+- javascript
+- native code
+  - java
+  - objective-c
+- native build configuration
+  - ios
+    - build settings
+    - infoplist
+  - android
+    - build config
+    - string resources
+    - project.ext
+
+```
+|-------------------------------------------------------|
+|                                                       |
+|                     javascript                        |
+|                                                       |
+|-------------------------------------------------------|
+|                          |                            |
+|       objective-c        |           java             |
+|                          |                            |
+|-------------------------------------------------------|
+|                          |                            |
+|      build settings      |     AndroidManifest.xml    |
+|         infoplist        |        build.gradle        |
+|                          |                            |
+|-------------------------------------------------------|
+```

package/android/build.gradle

@@ -0,0 +1,180 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def resolveReactNativeDirectory() {
+    def reactNativeLocation = safeExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocation != null) {
+        println "Using react-native dir from REACT_NATIVE_NODE_MODULES_DIR:" + reactNativeLocation
+        return file(reactNativeLocation)
+    }
+
+    // monorepo workaround
+    // react-native can be hoisted or in project's own node_modules
+    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
+    println "Using react-native dir from default location:" + reactNativeFromProjectNodeModules
+    if (reactNativeFromProjectNodeModules.exists()) {
+        return reactNativeFromProjectNodeModules
+    }
+
+    throw new Exception(
+        "[react-native-config-ultimate] Unable to resolve react-native location in " +
+            "node_modules. You should add project extension property (in app/build.gradle) " +
+            "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+    )
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+
+// Apply the React Native Gradle Plugin for New Architecture support (TurboModules, Codegen).
+// When newArchEnabled=true, this plugin runs Codegen to generate NativeUltimateConfigSpec.
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["UltimateConfig_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["UltimateConfig_" + name]).toInteger()
+}
+
+def REACT_NATIVE_DIR = resolveReactNativeDirectory()
+
+def reactProperties = new Properties()
+file("$REACT_NATIVE_DIR/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+
+android {
+  // 'namespace' is required by Android Gradle Plugin 8.0+.
+  // For AGP < 8.0 this property is silently ignored.
+  namespace "com.reactnativeultimateconfig"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  // Java 11 is the minimum for React Native 0.73+; Java 17 is recommended for RN 0.74+.
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo.
+  // For >= 0.71, version is substituted by the React Native Gradle Plugin (RNGP).
+  //noinspection GradleDynamicVersion
+  if (REACT_NATIVE_MINOR_VERSION >= 71) {
+    implementation "com.facebook.react:react-android:+" // version substituted by RNGP
+  } else {
+    implementation 'com.facebook.react:react-native:+' // from node_modules
+  }
+}
+
+// Codegen configuration — only runs when New Architecture is enabled.
+// Reads NativeUltimateConfig.ts (in src/) and generates NativeUltimateConfigSpec.java.
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "UltimateConfig"
+    codegenJavaPackageName = "com.reactnativeultimateconfig"
+  }
+}
+
+afterEvaluate { project ->
+  task androidSourcesJar(type: Jar) {
+    archiveClassifier = 'sources'
+    from android.sourceSets.main.java.srcDirs
+    include '**/*.java'
+  }
+
+  android.libraryVariants.all { variant ->
+    def name = variant.name.capitalize()
+    def javaCompileTask = variant.javaCompileProvider.get()
+
+    task "jar${name}"(type: Jar, dependsOn: javaCompileTask) {
+      from javaCompileTask.destinationDir
+    }
+  }
+
+  artifacts {
+    archives androidSourcesJar
+  }
+
+  publishing {
+    publications {
+      maven(MavenPublication) {
+        def packageJson = new groovy.json.JsonSlurper().parseText(file('../package.json').text)
+
+        pom {
+          name = packageJson.title
+          artifactId = packageJson.name
+          version = packageJson.version
+          group = "com.reactnativeultimateconfig"
+          description packageJson.description
+          url = packageJson.repository.url
+
+          licenses {
+            license {
+              name = packageJson.license
+              url = packageJson.repository.baseUrl + '/blob/master/' + packageJson.licenseFilename
+              distribution = 'repo'
+            }
+          }
+
+          developers {
+            developer {
+              id = packageJson.author.username
+              name = packageJson.author.name
+            }
+          }
+        }
+      }
+    }
+
+    repositories {
+      maven {
+        url "file://${projectDir}/../android/maven"
+      }
+    }
+  }
+}

package/android/rncu.gradle

@@ -0,0 +1,132 @@
+// DO NOT COMMIT OR EDIT THIS FILE
+import java.nio.file.Paths 
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath group: 'org.yaml', name: 'snakeyaml', version: '1.19'
+    }
+}
+
+
+def readYaml(yamlPath) {
+    def yamlFile = new File(yamlPath.toAbsolutePath().toString())
+    if (!yamlFile.exists()) {
+        throw new GradleException("yaml file at path ${yamlPath.toAbsolutePath().toString()} does not exist")
+    }
+    def cfg = new org.yaml.snakeyaml.Yaml().load(yamlFile.newInputStream())
+    if (
+        cfg instanceof String
+    || cfg instanceof Integer
+    || cfg instanceof Double
+    || cfg instanceof Boolean
+    ) {
+        throw new GradleException("could not read object from ${yamlPath} but got '${cfg.class.name}'")
+    } else if (cfg == null) {
+        throw new GradleException("could not read object from ${yamlPath} but got 'null'")
+    }
+    return cfg
+}
+
+def buildRootConfig() {
+    def flavorMappingExists = project.ext.has('flavorEnvMapping')
+    if (flavorMappingExists) {
+        def config = [:]
+        def flavorMapping = project.ext.get('flavorEnvMapping')
+        println "Flavor mapping detected: ${flavorMapping}"
+        flavorMapping.each { flavor, yamlPath -> 
+            def absolutePath = Paths.get(project.rootDir.getAbsolutePath(), yamlPath)
+            config.put(flavor, readYaml(absolutePath))
+        }
+        return config
+    } else {
+        println "No flavor mapping detected. Reading injected file"
+        def cfg = readYaml(Paths.get(buildscript.sourceFile.getParent(), "rncu.yaml"))
+        return cfg
+    }
+}
+
+def flattenConfig(cfg) {
+    def result = [:]
+    cfg.each { k,v ->
+        if (
+            v instanceof String
+        || v instanceof Integer
+        || v instanceof Double
+        || v instanceof Boolean
+        ) {
+            result.put(k,v)
+        } else {
+            def androidValue = v.get("android")
+            if (androidValue == null) {
+                throw new GradleException("key ${k} is missing android value")
+            }
+            result.put(k, v.get("android"))
+        }
+    }
+    return result
+}
+
+def rootConfig = buildRootConfig()
+println "Root config ${rootConfig}"
+
+def configPerFlavor(flavorName, rootConfig) {
+    def mapping = project.ext.has('flavorEnvMapping')
+    if (mapping && !flavorName.isEmpty()) {
+        println "mapping exists"
+        def f = rootConfig.get(flavorName)
+        return f
+    } else {
+        println "mapping does not exist or flavor is not defined"
+        return rootConfig
+    }
+}
+
+def escape_double(str) {
+    return str.replace('"', '\\"')
+}
+def escape_single(str) {
+    return str.replace("'", "\\'")
+}
+
+android {
+    // patch all variants with config values
+    applicationVariants.all { variant ->
+        println "processing variant ${variant.name}"
+        def flavorName = variant.flavorName 
+
+        def cfg = flattenConfig(configPerFlavor(flavorName, rootConfig))
+        println "config per flavor ${flavorName} ${cfg}"
+        def keySet = cfg.keySet().collect()
+        println "all keys ${keySet}"
+        def rncuKeys = java.lang.String.join(",", keySet)
+        println "all keys as string ${rncuKeys}"
+        variant.buildConfigField "String", "__RNCU_KEYS", "\"${rncuKeys}\""
+        variant.mergedFlavor.manifestPlaceholders.putAll(cfg)
+
+        cfg.each { k,v -> 
+            if (v instanceof java.lang.String) {
+                variant.buildConfigField "String", k, "\"${escape_double(v)}\""
+                variant.resValue "string", k, "${escape_single(v)}"
+            } else if (v instanceof Integer) {
+                variant.buildConfigField "int", k, "${v}"
+                variant.resValue "integer", k, "${v}"
+            } else if (v instanceof Double) {
+                variant.buildConfigField "double", k, "${v}"
+                variant.resValue "string", k, "${v}"
+            } else if (v instanceof Boolean) {
+                variant.buildConfigField "boolean", k, "${v}"
+                variant.resValue "bool", k, "${v}"
+            } else {
+                throw new GradleException("unknown type for key ${k} in flavor ${flavorName}: ${v.getClass()}")
+            }
+        }
+
+    }
+    defaultConfig {
+        project.ext.set("config", rootConfig)
+    }
+}
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.reactnativeultimateconfig">
+
+</manifest>

package/android/src/main/java/com/reactnativeultimateconfig/UltimateConfigModule.java

@@ -0,0 +1,56 @@
+package com.reactnativeultimateconfig;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ReactModule(name = UltimateConfigModule.NAME)
+public class UltimateConfigModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "UltimateConfig";
+
+  @Nullable
+  private static Class<?> _buildConfig;
+
+  public static void setBuildConfig(Class<?> buildConfig) {
+    _buildConfig = buildConfig;
+  }
+
+  public UltimateConfigModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  @NonNull
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    try {
+      Class<?> act = _buildConfig;
+      if (act == null) return constants;
+      String keys = (String) act.getField("__RNUC_KEYS").get(act);
+      if (keys == null || keys.isEmpty()) return constants;
+      for (String k : keys.split(",")) {
+        Object value = act.getField(k).get(act);
+        if (value != null) {
+          constants.put(k, value);
+        }
+      }
+    } catch (Exception e) {
+      Log.w(NAME, "Failed to read config constants from BuildConfig: " + e.getMessage());
+    }
+    return constants;
+  }
+}

package/android/src/main/java/com/reactnativeultimateconfig/UltimateConfigPackage.java

@@ -0,0 +1,53 @@
+package com.reactnativeultimateconfig;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * React Native package for UltimateConfig.
+ *
+ * Extends TurboReactPackage to support both the Old Architecture (Bridge)
+ * and the New Architecture (TurboModules / JSI). When IS_NEW_ARCHITECTURE_ENABLED
+ * is true the module is registered as a TurboModule; otherwise it runs as a
+ * classic bridge module.
+ */
+public class UltimateConfigPackage extends TurboReactPackage {
+
+  @Nullable
+  @Override
+  public NativeModule getModule(@NonNull String name, @NonNull ReactApplicationContext reactContext) {
+    if (UltimateConfigModule.NAME.equals(name)) {
+      return new UltimateConfigModule(reactContext);
+    }
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+        UltimateConfigModule.NAME,
+        new ReactModuleInfo(
+          UltimateConfigModule.NAME,
+          UltimateConfigModule.NAME,
+          false,  // canOverrideExistingModule
+          false,  // needsEagerInit
+          true,   // hasConstants  — constants are the primary API
+          false,  // isCxxModule
+          BuildConfig.IS_NEW_ARCHITECTURE_ENABLED  // isTurboModule
+        )
+      );
+      return moduleInfos;
+    };
+  }
+}

package/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const cli = require("./src/cli").default;
+
+cli();

package/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+// override.js is dynamically generated by the rncu CLI.
+// It contains platform-specific overrides. Do not commit override.js to git.
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+const override = require('./override');
+const { UltimateConfig } = react_native_1.NativeModules;
+exports.default = Object.assign(Object.assign({}, UltimateConfig), override);

package/index.ts

@@ -0,0 +1,18 @@
+import { NativeModules } from 'react-native';
+import type { ConfigValue } from './src/NativeUltimateConfig';
+
+export type { ConfigValue, Spec } from './src/NativeUltimateConfig';
+
+type Config = Record<string, ConfigValue>;
+
+// override.js is dynamically generated by the rncu CLI.
+// It contains platform-specific overrides. Do not commit override.js to git.
+// eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+const override: Config = require('./override');
+
+const { UltimateConfig } = NativeModules;
+
+export default {
+  ...(UltimateConfig as Config | undefined),
+  ...override,
+} as Config;

package/ios/ConfigValues.h

@@ -0,0 +1 @@
+#error "invoke bin.js with env file before compiling native project"

package/ios/UltimateConfig.h

@@ -0,0 +1,12 @@
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNUltimateConfigSpec.h"
+
+@interface UltimateConfig : NSObject <NativeUltimateConfigSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface UltimateConfig : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/UltimateConfig.mm

@@ -0,0 +1,27 @@
+#import "UltimateConfig.h"
+#import "ConfigValues.h"
+
+@implementation UltimateConfig
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+    // getConstants() reads from a static in-memory struct — no UI or main thread access needed.
+    return NO;
+}
+
+- (NSDictionary *)constantsToExport
+{
+    return getValues();
+}
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeUltimateConfigSpecJSI>(params);
+}
+#endif
+
+@end