react-native-config-ultimate 0.0.5 → 0.0.7

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "react-native-config-ultimate",
   "title": "React Native Config Ultimate",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Config that works. A community-maintained fork of react-native-ultimate-config.",
   "main": "index.js",
+  "module": "index.js",
   "react-native": "index.js",
+  "source": "index.ts",
   "browser": "index.web.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "react-native": "./index.js",
+      "import": "./index.js",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
   "files": [
     "bin.js",
     "index.js",
@@ -14,10 +24,8 @@
     "index.web.js",
     "src/*.js",
     "!src/*.spec.js",
-    "src/*.ts",
-    "!src/*.spec.ts",
+    "src/NativeUltimateConfig.ts",
     "src/templates",
-    "index.ts",
     "override.js",
     "ios/UltimateConfig.{h,mm}",
     "ios/ConfigValues.h",

package/index.ts

@@ -1,37 +0,0 @@
-import { TurboModuleRegistry, NativeModules } from 'react-native';
-import type { Spec } from './src/NativeUltimateConfig';
-
-export type ConfigValue = string | number | boolean;
-export type { 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');
-
-// New Architecture: TurboModules are accessed via TurboModuleRegistry.
-// The spec exposes getAll(): string — returns config values as JSON.
-// Old Architecture: constants are exposed directly on NativeModules via constantsToExport.
-const turboModule = TurboModuleRegistry.get<Spec>('UltimateConfig');
-
-let nativeConstants: Config;
-
-if (turboModule != null && typeof turboModule.getAll === 'function') {
-  // New Arch: call getAll() and parse JSON
-  try {
-    const raw = turboModule.getAll();
-    nativeConstants = JSON.parse(raw) as Config;
-  } catch {
-    nativeConstants = {};
-  }
-} else {
-  // Old Arch / interop bridge: constants are properties on NativeModules.UltimateConfig
-  nativeConstants = (NativeModules.UltimateConfig as Config | undefined) ?? {};
-}
-
-export default {
-  ...nativeConstants,
-  ...override,
-} as Config;

package/src/cli.ts

@@ -1,158 +0,0 @@
-import yargs from 'yargs';
-import * as path from 'path';
-import * as fs from 'fs';
-import { watch } from 'chokidar';
-import main from './main';
-import type { RC } from './resolve-env';
-
-/**
- * Load the RC file fresh on every call (clears require cache so
- * changes to .rncurc.js are picked up during --watch mode).
- */
-function load_rc(rc_file: string): RC | undefined {
-  if (!fs.existsSync(rc_file)) return undefined;
-  delete require.cache[require.resolve(rc_file)];
-  // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
-  return require(rc_file) as RC;
-}
-
-function log(msg: string): void {
-  process.stdout.write(`[rncu] ${msg}\n`);
-}
-
-function log_err(msg: string): void {
-  process.stderr.write(`[rncu] ✗ ${msg}\n`);
-}
-
-export default async function cli(): Promise<void> {
-  const argv = await yargs(process.argv.slice(2))
-    .option('projectRoot', {
-      type: 'string',
-      default: process.cwd(),
-      description: 'Root directory of the React Native project',
-    })
-    .option('libRoot', {
-      type: 'string',
-      description:
-        'Root directory of react-native-config-ultimate ' +
-        '(defaults to <projectRoot>/node_modules/react-native-config-ultimate)',
-    })
-    .option('watch', {
-      alias: 'w',
-      type: 'boolean',
-      default: false,
-      description:
-        'Watch env file(s) for changes and regenerate automatically. ' +
-        'Note: changes to native vars (iOS xcconfig, Android BuildConfig) ' +
-        'still require a full native rebuild.',
-    })
-    .usage('Usage: $0 <env-file> [env-file2 ...] [options]')
-    .help()
-    .parseAsync();
-
-  const project_root = argv.projectRoot;
-
-  /**
-   * Resolve the library root directory.
-   *
-   * Priority:
-   * 1. --libRoot flag (explicit override)
-   * 2. Conventional path <projectRoot>/node_modules/react-native-config-ultimate
-   *    — used when the directory exists (standard install, or bin.spec.ts integration test).
-   * 3. require.resolve() — handles npm workspaces hoisting, pnpm, Yarn PnP,
-   *    and any layout where the package is hoisted above projectRoot.
-   * 4. Fall back to conventional path even if it doesn't exist yet
-   *    (write-env.ts will create the directories on first run).
-   */
-  const lib_root: string = (() => {
-    if (argv.libRoot) return argv.libRoot;
-
-    const conventional = path.join(project_root, 'node_modules', 'react-native-config-ultimate');
-
-    // If the directory already exists at the conventional location, use it.
-    // This handles standard installs and the integration test temp-dir setup.
-    if (fs.existsSync(conventional)) return conventional;
-
-    // Otherwise, try require.resolve to handle hoisted workspaces.
-    try {
-      const pkg_json = require.resolve('react-native-config-ultimate/package.json', {
-        paths: [project_root],
-      });
-      return path.dirname(pkg_json);
-    } catch {
-      // Last resort: return the conventional path and let write-env create it.
-      return conventional;
-    }
-  })();
-
-  // Accept one or more positional env file paths.
-  // Multiple files are merged left-to-right (last file wins for conflicting keys).
-  const env_files = argv._.map(String);
-
-  // Validate env files exist before running anything.
-  const missing_files = env_files.filter((f) => !fs.existsSync(f));
-  if (missing_files.length > 0) {
-    for (const f of missing_files) {
-      log_err(`env file not found: ${f}`);
-    }
-    process.exit(1);
-  }
-
-  const rc_file = path.resolve(project_root, '.rncurc.js');
-
-  // Helper: run the full pipeline once, returning duration in ms.
-  // Never throws — errors are caught and logged so watch mode stays alive.
-  async function run(changed_path?: string): Promise<void> {
-    if (changed_path) {
-      log(`${changed_path} changed → regenerating...`);
-    }
-    const start = Date.now();
-    try {
-      const rc = load_rc(rc_file);
-      await main(project_root, lib_root, env_files, rc);
-      if (changed_path) {
-        log(`✓ done in ${Date.now() - start}ms`);
-      }
-    } catch (err) {
-      log_err(err instanceof Error ? err.message : String(err));
-    }
-  }
-
-  // Initial run (always runs, throws on error in non-watch mode).
-  if (!argv.watch) {
-    const rc = load_rc(rc_file);
-    await main(project_root, lib_root, env_files, rc);
-    return;
-  }
-
-  // --watch mode ────────────────────────────────────────────────────────────
-  // Initial run (errors are caught — we still want to start watching).
-  await run();
-
-  // Files to watch: env files + RC file (if it exists).
-  const files_to_watch = [...env_files, ...(fs.existsSync(rc_file) ? [rc_file] : [])];
-
-  const watcher = watch(files_to_watch, {
-    ignoreInitial: true,
-    persistent: true,
-  });
-
-  log(
-    `watching: ${files_to_watch.join(', ')}\n` +
-      `[rncu] ⚠  native vars (xcconfig/BuildConfig) require a full rebuild to take effect`
-  );
-
-  watcher.on('change', (p) => void run(p));
-  watcher.on('add', (p) => void run(p));
-
-  // Keep the process alive (chokidar persistent:true already does this,
-  // but stdin.resume makes it explicit and survives edge cases).
-  process.stdin.resume();
-
-  // Graceful shutdown on Ctrl+C.
-  process.on('SIGINT', () => {
-    process.stdout.write('\n');
-    log('stopping...');
-    void watcher.close().then(() => process.exit(0));
-  });
-}

package/src/flatten.ts

@@ -1,26 +0,0 @@
-import assert from 'assert';
-
-type Platform = 'ios' | 'android' | 'web';
-export type ConfigValue = string | number | boolean;
-export type PerPlatformValue = Partial<Record<Platform, ConfigValue>>;
-export type EnvConfig = Record<string, ConfigValue | PerPlatformValue>;
-export type FlatConfig = Record<string, ConfigValue | undefined>;
-
-const VALID_PLATFORMS: Platform[] = ['ios', 'android', 'web'];
-
-export default function flatten(config: EnvConfig, platform: Platform): FlatConfig {
-  assert(config && typeof config === 'object', 'Config should be non-null object');
-  assert(
-    VALID_PLATFORMS.includes(platform),
-    '`platform` should one of: ' + VALID_PLATFORMS.join(', ')
-  );
-  const result: FlatConfig = {};
-  for (const [key, value] of Object.entries(config)) {
-    if (value && typeof value === 'object') {
-      result[key] = (value as PerPlatformValue)[platform];
-    } else {
-      result[key] = value as ConfigValue;
-    }
-  }
-  return result;
-}

package/src/load-env.ts

@@ -1,80 +0,0 @@
-import * as dotenv from 'dotenv';
-import { expand } from 'dotenv-expand';
-import * as yaml from 'js-yaml';
-import * as path from 'path';
-import * as fs from 'fs';
-
-import type { EnvData } from './resolve-env';
-
-type FileFormat = 'dotenv' | 'yaml';
-
-function detect_format(config_path: string): FileFormat {
-  const { ext } = path.parse(config_path);
-  return ext === '.yml' || ext === '.yaml' ? 'yaml' : 'dotenv';
-}
-
-function read_yaml(config_path: string): EnvData {
-  const data = yaml.load(fs.readFileSync(config_path).toString());
-  if (typeof data === 'undefined' || data === null || typeof data !== 'object') {
-    throw new Error(`Expected to read object from ${config_path}, but got '${data}'`);
-  }
-  return data as EnvData;
-}
-
-/**
- * Load one or more env files and merge them (last file wins for conflicting keys).
- *
- * Dotenv files (.env, .env.staging, etc.):
- *   - All files are merged first, then variable expansion runs once.
- *   - This means cross-file `$VAR` references work:
- *     .env.base:    BASE_URL=https://api.example.com
- *     .env.staging: API_URL=$BASE_URL/v1  →  https://api.example.com/v1
- *
- * YAML files (.yml, .yaml):
- *   - Each file is loaded and shallow-merged (last wins for top-level keys).
- *   - No variable expansion is applied (use YAML anchors instead).
- *
- * @example
- * // Single file (backward-compatible):
- * load_env('.env')
- *
- * // Multi-file merge:
- * load_env(['.env.base', '.env.staging'])
- */
-export default function load_env(config_paths: string | string[]): EnvData {
-  const paths = Array.isArray(config_paths) ? config_paths : [config_paths];
-
-  if (paths.length === 0) {
-    throw new Error('No env file specified. Usage: rncu <env-file> [env-file2 ...]');
-  }
-
-  const formats = paths.map(detect_format);
-  const allDotenv = formats.every((f) => f === 'dotenv');
-
-  if (allDotenv) {
-    // Merge raw parsed content first, then expand once —
-    // so cross-file $VAR references resolve correctly.
-    const raw: Record<string, string> = {};
-    for (const p of paths) {
-      const content = fs.readFileSync(p, 'utf8');
-      Object.assign(raw, dotenv.parse(content));
-    }
-    const result = expand({ parsed: raw });
-    return (result.parsed ?? raw) as EnvData;
-  }
-
-  // YAML or mixed: load each file individually and shallow-merge.
-  const merged: EnvData = {};
-  for (let i = 0; i < paths.length; i++) {
-    const p = paths[i];
-    if (formats[i] === 'yaml') {
-      Object.assign(merged, read_yaml(p));
-    } else {
-      const content = fs.readFileSync(p, 'utf8');
-      const parsed = dotenv.parse(content);
-      const expanded = expand({ parsed });
-      Object.assign(merged, expanded.parsed ?? parsed);
-    }
-  }
-  return merged;
-}

package/src/main.ts

@@ -1,39 +0,0 @@
-import load_env from './load-env';
-import render_env from './render-env';
-import write_env from './write-env';
-import flatten from './flatten';
-import resolve_env from './resolve-env';
-import { validate_env } from './validate-env';
-
-import type { RC, EnvData } from './resolve-env';
-import type { EnvConfig } from './flatten';
-
-/**
- * Main build-time pipeline:
- *   load → resolve (on_env hook) → validate (schema) → flatten → render → write
- *
- * @param project_root  Root of the React Native project
- * @param lib_root      Root of the react-native-config-ultimate install
- * @param env_file      Path(s) to env file(s). Multiple files are merged (last wins).
- * @param rc            Optional RC config from `.rncurc.js`
- */
-export default async function main(
-  project_root: string,
-  lib_root: string,
-  env_file: string | string[],
-  rc?: RC
-): Promise<void> {
-  const env: EnvData = await resolve_env(load_env(env_file), rc);
-
-  if (rc?.schema) {
-    validate_env(env, rc.schema);
-  }
-
-  const flat = {
-    ios: flatten(env as EnvConfig, 'ios'),
-    android: flatten(env as EnvConfig, 'android'),
-    web: flatten(env as EnvConfig, 'web'),
-  };
-  const files_to_write = render_env(project_root, lib_root, flat, rc);
-  write_env(files_to_write);
-}

package/src/render-env.ts

@@ -1,111 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import handlebars from 'handlebars';
-
-import type { FlatConfig } from './flatten';
-import type { RC } from './resolve-env';
-import type { FileMap } from './write-env';
-
-const code_file_name = 'ConfigValues';
-const config_file_name = 'rncu';
-
-// ─── Handlebars helpers (registered once at module load, not per-call) ────────
-
-function is_string(value: unknown): boolean {
-  return typeof value === 'string';
-}
-
-function is_number(value: unknown): boolean {
-  return typeof value === 'number';
-}
-
-function is_boolean(value: unknown): boolean {
-  return typeof value === 'boolean';
-}
-
-function escape(value: unknown): unknown {
-  if (is_string(value)) {
-    return (value as string)
-      .replace(/\\/gm, '\\\\')
-      .replace(/"/gm, '\\"')
-      .replace(/\n/gm, '\\n')
-      .replace(/\r/gm, '\\r');
-  }
-  return value;
-}
-
-function xcconfig_format(value: unknown): unknown {
-  if (is_string(value)) {
-    return (value as string).replace(/\/\//gm, '/$()/');
-  }
-  return value;
-}
-
-function to_json(value: unknown): string {
-  return JSON.stringify(value, null, 2);
-}
-
-handlebars.registerHelper('isBoolean', is_boolean);
-handlebars.registerHelper('isString', is_string);
-handlebars.registerHelper('isNumber', is_number);
-handlebars.registerHelper('escape', escape);
-handlebars.registerHelper('xcconfigFormat', xcconfig_format);
-handlebars.registerHelper('toJSON', to_json);
-
-// ─── Template cache (compiled once per template name, not per build) ──────────
-
-const template_cache = new Map<string, HandlebarsTemplateDelegate>();
-
-function get_compiled_template(template_name: string): HandlebarsTemplateDelegate {
-  const cached = template_cache.get(template_name);
-  if (cached) return cached;
-
-  const template_path = path.join(__dirname, 'templates', `${template_name}.handlebars`);
-  const compiled = handlebars.compile(fs.readFileSync(template_path, 'utf8'));
-  template_cache.set(template_name, compiled);
-  return compiled;
-}
-
-function render_template(template_name: string, data: unknown): string {
-  return get_compiled_template(template_name)(data);
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-interface PlatformEnv {
-  ios: FlatConfig;
-  android: FlatConfig;
-  web: FlatConfig;
-}
-
-export default function render_env(
-  project_root: string,
-  lib_root: string,
-  env: PlatformEnv,
-  rc?: RC
-): FileMap {
-  const { ios, android, web } = env;
-  const map: FileMap = {
-    [path.join(lib_root, 'index.d.ts')]: render_template('index.d.ts', ios),
-    [path.join(lib_root, 'index.web.js')]: render_template('index.web.js', web),
-    [path.join(lib_root, 'ios', `${code_file_name}.h`)]: render_template('ConfigValues.h', ios),
-    [path.join(lib_root, 'android', 'rncu.yaml')]: render_template('rncu.yaml', android),
-  };
-
-  // Only write xcconfig if the project has an ios folder.
-  // All RN apps have it; some react-native-web apps may not.
-  if (fs.existsSync(path.join(project_root, 'ios'))) {
-    map[path.join(project_root, 'ios', `${config_file_name}.xcconfig`)] = render_template(
-      'rncu.xcconfig',
-      ios
-    );
-  }
-
-  const js_override = rc && typeof rc.js_override === 'boolean' && rc.js_override;
-  map[path.join(lib_root, 'override.js')] = render_template('override.js', {
-    ios: js_override ? ios : {},
-    android: js_override ? android : {},
-  });
-
-  return map;
-}

package/src/resolve-env.ts

@@ -1,45 +0,0 @@
-export type EnvData = Record<string, unknown>;
-
-/**
- * Schema definition for a single environment variable.
- * Used in `.rncurc.js` to validate env vars at build time.
- *
- * @example
- * module.exports = {
- *   schema: {
- *     API_URL:    { type: 'string',  required: true },
- *     TIMEOUT_MS: { type: 'number',  required: true },
- *     DEBUG:      { type: 'boolean', required: false },
- *     ENV_NAME:   { type: 'string',  required: true, pattern: '^(dev|staging|prod)$' },
- *   }
- * };
- */
-export interface SchemaField {
-  /** Expected type. Strings are always accepted as-is; number/boolean validate parsability. */
-  type: 'string' | 'number' | 'boolean';
-  /** If true, build fails when this var is missing or empty. Default: false. */
-  required?: boolean;
-  /** Optional regex pattern the value must match (applied to string representation). */
-  pattern?: string;
-}
-
-export type Schema = Record<string, SchemaField>;
-
-export interface RC {
-  on_env?: (env: EnvData) => unknown;
-  js_override?: boolean;
-  /**
-   * Optional schema for build-time validation of env vars.
-   * Validated after `on_env` runs (so the hook can add/transform vars before validation).
-   */
-  schema?: Schema;
-}
-
-export default async function resolve_env(env: EnvData, rc?: RC): Promise<EnvData> {
-  if (rc && rc.on_env) {
-    const patched_env = await rc.on_env(env);
-    return typeof patched_env === 'undefined' ? env : (patched_env as EnvData);
-  } else {
-    return env;
-  }
-}

package/src/validate-env.ts

@@ -1,71 +0,0 @@
-import type { EnvData, Schema } from './resolve-env';
-
-const VALID_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-/**
- * Validate env data against a schema defined in `.rncurc.js`.
- * Called after `on_env` so the hook can add/transform vars before validation.
- *
- * Throws with a human-readable error listing ALL failures at once
- * (not just the first one), so users can fix everything in one pass.
- */
-export function validate_env(env: EnvData, schema: Schema): void {
-  const errors: string[] = [];
-
-  // Validate all env key names are valid identifiers
-  for (const key of Object.keys(env)) {
-    if (!VALID_KEY_PATTERN.test(key)) {
-      errors.push(
-        `Invalid env key name: "${key}". Keys must start with a letter or underscore and contain only letters, numbers, and underscores.`
-      );
-    }
-  }
-
-  // Pre-compile all regex patterns once, before iterating over env values.
-  // This avoids re-compiling the same pattern for every validated key.
-  const compiled_patterns = new Map<string, RegExp>();
-  for (const [key, field] of Object.entries(schema)) {
-    if (field.pattern) {
-      try {
-        compiled_patterns.set(key, new RegExp(field.pattern));
-      } catch {
-        errors.push(`${key}: invalid regex pattern /${field.pattern}/`);
-      }
-    }
-  }
-
-  for (const [key, field] of Object.entries(schema)) {
-    const raw = env[key];
-    const missing = raw === undefined || raw === null || String(raw).trim() === '';
-
-    if (field.required && missing) {
-      errors.push(`Missing required env var: ${key}`);
-      continue; // can't type-check a missing value
-    }
-
-    if (missing) continue; // optional and not present → OK
-
-    const value = String(raw);
-
-    if (field.type === 'number' && isNaN(Number(value))) {
-      errors.push(`${key} must be a number, got "${value}"`);
-    }
-
-    if (field.type === 'boolean' && !['true', 'false', '1', '0'].includes(value.toLowerCase())) {
-      errors.push(`${key} must be a boolean (true/false/1/0), got "${value}"`);
-    }
-
-    const pattern = compiled_patterns.get(key);
-    if (pattern && !pattern.test(value)) {
-      errors.push(`${key} does not match pattern /${field.pattern}/, got "${value}"`);
-    }
-  }
-
-  if (errors.length > 0) {
-    throw new Error(
-      `\n\n❌ react-native-config-ultimate: env validation failed:\n` +
-        errors.map((e) => `  • ${e}`).join('\n') +
-        '\n'
-    );
-  }
-}

package/src/write-env.ts

@@ -1,74 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-export type FileMap = Record<string, string>;
-
-/**
- * Atomically write all generated files.
- *
- * Strategy: write each file to a temp path first, then rename (atomic on POSIX).
- * If any write fails, we abort before committing any renames so the project
- * is never left in a partially-written state.
- *
- * On Windows, `fs.renameSync` across drives may fail — in that case we fall
- * back to a direct `writeFileSync` (best-effort, still better than nothing).
- */
-export default function write_env(files: FileMap): void {
-  const tmp_dir = os.tmpdir();
-  // Phase 1: write all content to temp files — if anything fails, no real files are touched.
-  const pending: Array<{ tmp: string; dest: string }> = [];
-
-  try {
-    for (const dest of Object.keys(files)) {
-      // Ensure the destination directory exists (handles first-run and hoisted workspaces).
-      fs.mkdirSync(path.dirname(dest), { recursive: true });
-      const tmp = path.join(tmp_dir, `rncu_${Date.now()}_${Math.random().toString(36).slice(2)}`);
-      fs.writeFileSync(tmp, files[dest], 'utf8');
-      pending.push({ tmp, dest });
-    }
-  } catch (err) {
-    // Clean up any temp files we already created.
-    for (const { tmp } of pending) {
-      try {
-        fs.unlinkSync(tmp);
-      } catch {
-        /* ignore */
-      }
-    }
-    throw new Error(
-      `[rncu] Failed to prepare output files: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-
-  // Phase 2: atomically rename temp → dest.
-  // We collect errors and rethrow at the end so the caller gets a clear message.
-  const rename_errors: string[] = [];
-
-  for (const { tmp, dest } of pending) {
-    try {
-      fs.renameSync(tmp, dest);
-    } catch {
-      // Cross-device rename (e.g. Windows different drives) — fall back to copy+delete.
-      try {
-        fs.copyFileSync(tmp, dest);
-        fs.unlinkSync(tmp);
-      } catch (copy_err) {
-        rename_errors.push(
-          `${dest}: ${copy_err instanceof Error ? copy_err.message : String(copy_err)}`
-        );
-        try {
-          fs.unlinkSync(tmp);
-        } catch {
-          /* ignore */
-        }
-      }
-    }
-  }
-
-  if (rename_errors.length > 0) {
-    throw new Error(
-      `[rncu] Failed to write output files:\n` + rename_errors.map((e) => `  • ${e}`).join('\n')
-    );
-  }
-}