react-native-impeller-platform 0.0.0-stage → 0.3.1

package/src/resolve.js

@@ -0,0 +1,238 @@
+'use strict';
+// Locates the prebuilt Impeller engine binary for the current platform.
+//
+// Delivery model (PLAN D4): the main package declares every
+// `@blbaker/react-native-impeller-platform-engine-<platform>-<arch>` as an OPTIONAL dependency.
+// npm installs only the one matching the host, so a consumer never compiles C++.
+//
+// Rules this file enforces:
+//   1. `IMPELLER_ENGINE_BINARY` env var wins  (local engine development).
+//   2. Otherwise resolve the per-platform package from THIS file's location
+//      (`__dirname`) FIRST -- install and tarball must both work, and an
+//      installed copy must never be outranked by something in the CWD.
+//   3. On failure, throw an error that NAMES the missing package. A resolver that
+//      says "not found" without the package name costs the consumer an hour.
+//   4. Refuse a version mismatch between the engine package and this package.
+//      Silent lockstep drift produces ABI crashes that look like renderer bugs.
+//
+// ⛔ `__dirname` ALONE IS NOT ENOUGH UNDER link:/file: (P10, 2026-09-02)
+//
+// The original comment here said "never from CWD -- link, install and tarball
+// must all work". The first two words were right and the last claim was not
+// TESTED: no gate ever ran the resolver through a symlinked package, so the
+// linked case was asserted in a comment and broken in fact.
+//
+// Under `file:`/`npm link`, node_modules/react-native-impeller-platform is a
+// SYMLINK back to this source checkout. `__dirname` therefore lands in the
+// checkout, whose node_modules does NOT contain the engine package -- the
+// engine lives in the checkout's sibling `packages-engine/engine-<triple>/`,
+// which is where tools/engine-build.sh writes it and which no node_modules
+// walk from anywhere will ever reach. Reproduced: a linked consumer app with
+// the engine package ALSO linked into its own node_modules still failed,
+// because resolution started from the symlink TARGET, not the app.
+//
+// So the anchor list is ordered, not replaced:
+//   a. __dirname                     -- installed + tarball. Unchanged, first.
+//   b. INIT_CWD / process.cwd()      -- the consumer's own tree, which is what
+//                                       __dirname stops pointing at under link:.
+//   c. <checkout>/packages-engine/   -- the linked source tree's own build
+//                                       output, read directly by path.
+// (a) still wins in every shipped install, so this cannot change what a real
+// consumer resolves. It only gives the linked case somewhere true to look.
+//
+// This is deliberately NOT "just set IMPELLER_ENGINE_BINARY in the app's
+// script". Line 79 of this file already rules that out: a package that needs
+// an env var to function has not shipped. That applies to our own dev loop
+// too -- an env var in a downstream app's paint-proof script is a workaround
+// that hides this defect instead of fixing it.
+
+const fs = require('fs');
+const path = require('path');
+
+// ⛔ THIS SET IS A PROMISE, NOT A ROADMAP (P7, 2026-08-14)
+//
+// A triple listed here with no published engine package produces the WORST
+// possible failure: npm silently skips a missing optionalDependency and exits
+// 0, so the user gets a clean install with no engine, then hits the "Missing
+// engine package" error below — which instructs them to install a package that
+// does not exist. A good error message with an impossible instruction.
+//
+// So a triple joins this list when its engine package is BUILT, not when it is
+// planned. `tools/ci-release-meta.sh` fails the build if the two ever disagree.
+// darwin-arm64/darwin-x64/linux-arm64 belong here the moment P6 ships them.
+const SUPPORTED = new Set([
+  'linux-x64',
+  'win32-x64',
+  'darwin-arm64',
+]);
+
+function hostTriple(platform = process.platform, arch = process.arch) {
+  return `${platform}-${arch}`;
+}
+
+function packageNameFor(triple) {
+  return `@blbaker/react-native-impeller-platform-engine-${triple}`;
+}
+
+function binaryFileName(platform = process.platform) {
+  return platform === 'win32' ? 'rn-impeller.exe' : 'rn-impeller';
+}
+
+function ownVersion() {
+  return require('../package.json').version;
+}
+
+/**
+ * Ordered list of places to look for the engine package's package.json.
+ *
+ * ⛔ ORDER IS THE WHOLE SAFETY ARGUMENT. __dirname is index 0, so for any
+ * normally-installed consumer this function returns on the first candidate and
+ * behaves exactly as it did before link: support existed. Everything after it
+ * is reached ONLY when the __dirname walk found nothing -- i.e. only in the
+ * case that used to throw.
+ */
+function engineCandidates(triple, opts) {
+  const env = opts.env || process.env;
+  const cwd = opts.cwd || process.cwd();
+  const out = [];
+
+  // (a) Installed / tarball. Unchanged, and always first.
+  out.push({kind: 'resolve', from: __dirname, source: 'package'});
+
+  // (b) The consumer's own tree. Under link:/file: this is the only anchor that
+  //     still points at the app, because __dirname followed the symlink out of
+  //     it. npm sets INIT_CWD to the directory the command was run from, which
+  //     survives npm running scripts from elsewhere; process.cwd() covers a
+  //     plain `node ...` invocation.
+  const consumerRoots = [env.INIT_CWD, cwd].filter(Boolean);
+  for (const root of consumerRoots) {
+    out.push({kind: 'resolve', from: path.join(root, 'node_modules'), source: 'linked-consumer'});
+  }
+
+  // (c) The linked SOURCE CHECKOUT's own build output. package/src/resolve.js
+  //     -> ../../packages-engine/engine-<triple>. This is a direct path probe,
+  //     not a node_modules walk, because engine-build.sh writes the binary
+  //     there and nothing ever installs it into a node_modules anywhere.
+  out.push({
+    kind: 'path',
+    // The directory is named by the triple, not the package: the npm name is
+    // scoped under a different prefix and does not match the folder.
+    dir: path.join(__dirname, '..', '..', 'packages-engine', `engine-${triple}`),
+    source: 'linked-checkout',
+  });
+
+  return out;
+}
+
+/**
+ * @returns {{binary: string, source: string, packageName: string|null, version: string|null}}
+ */
+function resolveEngine(opts = {}) {
+  const platform = opts.platform || process.platform;
+  const arch = opts.arch || process.arch;
+  const env = opts.env || process.env;
+  const triple = hostTriple(platform, arch);
+
+  const override = env.IMPELLER_ENGINE_BINARY;
+  if (override) {
+    if (!fs.existsSync(override)) {
+      throw new Error(
+        `IMPELLER_ENGINE_BINARY is set to "${override}" but no file exists there.\n` +
+          'Unset it to fall back to the installed engine package.'
+      );
+    }
+    return {binary: path.resolve(override), source: 'env', packageName: null, version: null};
+  }
+
+  if (!SUPPORTED.has(triple)) {
+    // ⛔ DO NOT TELL A CONSUMER TO BUILD THE ENGINE.
+    // This message used to lead with `export IMPELLER_ENGINE_BINARY=...`, which
+    // reads as "the supported fix is to compile a C++ engine yourself" — a
+    // 40-minute Hermes build, a native toolchain, and an env var the app now
+    // depends on forever. That is contributor work leaking into a consumer
+    // error path. A package that needs an env var to function has not shipped.
+    //
+    // Say what is true (this platform is not supported yet) and point at the
+    // one place that will change when it is. The env var is still honoured and
+    // still documented under contributing — it is simply not the answer we hand
+    // to someone whose install just failed.
+    throw new Error(
+      `react-native-impeller-platform does not support ${triple} yet.\n` +
+        `Supported: ${[...SUPPORTED].join(', ')}\n\n` +
+        'Track or request platform support:\n' +
+        '    https://github.com/blbaker/react-native-impeller-platform/issues\n'
+    );
+  }
+
+  const pkgName = packageNameFor(triple);
+  let pkgJsonPath = null;
+  let source = null;
+  const tried = [];
+  for (const cand of engineCandidates(triple, {env, cwd: opts.cwd})) {
+    if (cand.kind === 'resolve') {
+      tried.push(cand.from);
+      try {
+        pkgJsonPath = require.resolve(`${pkgName}/package.json`, {paths: [cand.from]});
+      } catch (e) {
+        continue;
+      }
+    } else {
+      const p = path.join(cand.dir, 'package.json');
+      tried.push(cand.dir);
+      if (!fs.existsSync(p)) continue;
+      pkgJsonPath = p;
+    }
+    source = cand.source;
+    break;
+  }
+
+  if (!pkgJsonPath) {
+    throw new Error(
+      `Missing engine package "${pkgName}".\n` +
+        'It ships as an optional dependency of react-native-impeller-platform and should\n' +
+        'been installed automatically. Install it explicitly:\n\n' +
+        `    npm install ${pkgName}@${ownVersion()}\n\n` +
+        // ⛔ SAY WHERE WE LOOKED. The old message named the package but not the
+        // search path, so a linked checkout whose engine was simply never built
+        // produced the same text as a genuinely broken install.
+        'Looked in:\n' +
+        tried.map((t) => `    ${t}`).join('\n') +
+        '\n\nOr point IMPELLER_ENGINE_BINARY at a locally built engine.'
+    );
+  }
+
+  const enginePkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+  const expected = ownVersion();
+  if (enginePkg.version !== expected) {
+    throw new Error(
+      `Engine version mismatch: ${pkgName}@${enginePkg.version} is installed but\n` +
+        `react-native-impeller-platform@${expected} requires exactly ${expected}.\n` +
+        'The engine C ABI is versioned in lockstep; mixed versions crash at runtime.\n\n' +
+        `    npm install ${pkgName}@${expected}`
+    );
+  }
+
+  const binary = path.join(path.dirname(pkgJsonPath), 'bin', binaryFileName(platform));
+  if (!fs.existsSync(binary)) {
+    throw new Error(
+      `Engine package "${pkgName}" is installed but its binary is missing:\n  ${binary}\n` +
+        // A linked checkout reaches this when the package.json is committed but
+        // packages-engine/*/bin is gitignored and was never built. "Corrupt --
+        // reinstall it" is the wrong instruction there, so name the real fix.
+        (source === 'linked-checkout'
+          ? `This is a LINKED SOURCE CHECKOUT, not an installed package. Build the engine:\n` +
+            `    bash tools/engine-build.sh ${platform} ${arch}`
+          : 'The package is corrupt -- reinstall it.')
+    );
+  }
+  return {binary, source, packageName: pkgName, version: enginePkg.version};
+}
+
+module.exports = {
+  resolveEngine,
+  hostTriple,
+  packageNameFor,
+  binaryFileName,
+  engineCandidates,
+  SUPPORTED,
+};

package/src/selftest.js

@@ -0,0 +1,123 @@
+/**
+ * Self-test for the engine resolver.
+ *
+ * Runs as `npm test` INSIDE THE PUBLISHED PACKAGE, which is the point: it is
+ * the one check a user can run on the artifact they actually installed, on a
+ * machine we have never seen. So it must depend on nothing but this package —
+ * no dev dependencies, no test runner, no network, no engine binary.
+ *
+ * package.json declared this script for the whole of P1-P6 while the file did
+ * not exist; `npm test` died with MODULE_NOT_FOUND. tools/ci-release-meta.sh
+ * now fails the build when a declared entry point is missing.
+ */
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {resolveEngine, hostTriple, packageNameFor, binaryFileName, SUPPORTED} =
+  require('./resolve');
+
+let passed = 0;
+function check(name, fn) {
+  try {
+    fn();
+    console.log(`  ok  ${name}`);
+    passed++;
+  } catch (e) {
+    console.error(`  FAIL ${name}\n       ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+
+console.log('react-native-impeller-platform selftest');
+
+check('host triple is platform-arch', () => {
+  assert.strictEqual(hostTriple('linux', 'x64'), 'linux-x64');
+  assert.strictEqual(hostTriple('win32', 'x64'), 'win32-x64');
+});
+
+check('engine package name is derived from the triple', () => {
+  assert.strictEqual(
+    packageNameFor('linux-x64'),
+    '@blbaker/react-native-impeller-platform-engine-linux-x64'
+  );
+});
+
+check('binary name is .exe only on win32', () => {
+  assert.strictEqual(binaryFileName('linux'), 'rn-impeller');
+  assert.strictEqual(binaryFileName('darwin'), 'rn-impeller');
+  assert.strictEqual(binaryFileName('win32'), 'rn-impeller.exe');
+});
+
+check('every SUPPORTED triple names a real optionalDependency', () => {
+  // The defect this guards: a triple advertised as supported with no package
+  // published. npm SKIPS a missing optional dependency and exits 0, so the
+  // user gets a silent no-engine install and then an error instructing them to
+  // install something that does not exist.
+  const pkg = require('../package.json');
+  const opt = Object.keys(pkg.optionalDependencies || {});
+  for (const triple of SUPPORTED) {
+    assert.ok(
+      opt.includes(packageNameFor(triple)),
+      `${triple} is SUPPORTED but ${packageNameFor(triple)} is not an optionalDependency`
+    );
+  }
+});
+
+check('every engine optionalDependency is pinned exactly, never a range', () => {
+  // The engine exposes an unstable C ABI. A ^ or ~ range lets npm resolve a
+  // newer engine against an older host, which crashes at runtime rather than
+  // failing to install.
+  const pkg = require('../package.json');
+  for (const [name, spec] of Object.entries(pkg.optionalDependencies || {})) {
+    assert.strictEqual(spec, pkg.version, `${name} is pinned '${spec}', expected '${pkg.version}'`);
+  }
+});
+
+check('an unsupported triple is refused, without demanding the user build it', () => {
+  // ⛔ THIS TEST USED TO REQUIRE THE OPPOSITE.
+  // It asserted the error names IMPELLER_ENGINE_BINARY — i.e. it ENFORCED
+  // telling a consumer whose install just failed to go compile a C++ engine.
+  // A test can pin the wrong behaviour just as firmly as the right one; this
+  // one kept contributor workflow in a consumer error path.
+  assert.throws(
+    () => resolveEngine({platform: 'sunos', arch: 'sparc', env: {}}),
+    (e) =>
+      /does not support sunos-sparc yet/.test(e.message) &&
+      /Supported: /.test(e.message) &&
+      // The message must NOT hand a consumer a build instruction.
+      !/IMPELLER_ENGINE_BINARY/.test(e.message)
+  );
+});
+
+check('IMPELLER_ENGINE_BINARY overrides the installed package', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rni-selftest-'));
+  const fake = path.join(tmp, 'rn-impeller');
+  fs.writeFileSync(fake, '');
+  try {
+    const r = resolveEngine({env: {IMPELLER_ENGINE_BINARY: fake}});
+    assert.strictEqual(r.source, 'env');
+    assert.strictEqual(r.binary, fake);
+  } finally {
+    fs.rmSync(tmp, {recursive: true, force: true});
+  }
+});
+
+check('a missing IMPELLER_ENGINE_BINARY fails loudly, not silently', () => {
+  // "Cannot find it" and "using the default" must never share an outcome: an
+  // override that silently falls back would run a DIFFERENT engine than the
+  // developer asked for, which is the hardest kind of bug to see.
+  assert.throws(
+    () => resolveEngine({env: {IMPELLER_ENGINE_BINARY: '/nonexistent/rn-impeller'}}),
+    /no file exists there/
+  );
+});
+
+console.log(
+  process.exitCode
+    ? 'SELFTEST_FAIL'
+    : `SELFTEST_PASS (${passed} checks)`
+);

package/src/storage/index.js

@@ -0,0 +1,161 @@
+'use strict';
+// ENG-04 shape B, the JS half. An AsyncStorage-shaped API composed on top of
+// the engine's ONE file primitive.
+//
+// WHY THIS LIVES IN JS
+// -------------------
+// The engine vends AppStorage.readFile/writeFile/deleteFile/listFiles and
+// nothing more. That is a deliberate boundary: persistence is not a renderer
+// concern, and if the engine owned a key-value API instead, every later need
+// (structured values, namespacing, encryption, migration) would be a new C++
+// row against a surface frozen in a native release. Here it is a JS change.
+//
+// Same division as Alert.impeller.js: the engine owns the CAPABILITY, JS owns
+// the SHAPE.
+//
+// ⛔ ASYNC ON PURPOSE, OVER A SYNCHRONOUS PRIMITIVE.
+// The native calls are synchronous (small flat files, called from the JS
+// thread). This wrapper is async anyway, because async is the shape every RN
+// storage consumer expects and the one you cannot retrofit later without
+// breaking every caller. If the native half ever moves to a thread pool, no
+// consumer of this module changes.
+
+const {TurboModuleRegistry} = require('react-native');
+
+// ⚠️ get, NOT getEnforcing. An engine built before ENG-04 does not vend
+// AppStorage, and a hard throw at import time would take the whole bundle down
+// on a version mismatch rather than failing the one feature. The null check in
+// mod() turns that into a rejected Promise from the call that needed it.
+const Native = TurboModuleRegistry.get('AppStorage');
+
+function mod() {
+  if (Native == null) {
+    throw new Error(
+      'AppStorage native module is unavailable. The engine binary predates ' +
+        'ENG-04 (run `rn-impeller --list-modules` to confirm) — storage calls ' +
+        'cannot work until the engine is updated.',
+    );
+  }
+  return Native;
+}
+
+// ⛔ KEY ENCODING IS NOT OPTIONAL AND IT IS NOT COSMETIC.
+//
+// The native side enforces a conservative allowlist ([A-Za-z0-9._-], one flat
+// file per key, no nesting) because that is what keeps the container listable
+// and the containment check simple. Real storage keys are not like that:
+// '@myapp/user:profile' is an ordinary AsyncStorage key and would be REJECTED
+// by the primitive.
+//
+// So keys are hex-encoded here. That is reversible, which listKeys() depends
+// on, and it means no key can ever collide with another or escape the
+// container -- a sanitising scheme (replace bad chars with '_') would silently
+// map 'a/b' and 'a_b' onto ONE file, and the caller would never be told.
+function encodeKey(key) {
+  if (typeof key !== 'string') {
+    throw new TypeError('storage key must be a string, got ' + typeof key);
+  }
+  let out = '';
+  for (let i = 0; i < key.length; i++) {
+    const code = key.charCodeAt(i);
+    // Encode the whole BMP code unit, not a byte: charCodeAt can return > 255
+    // for non-ASCII keys, and a 2-hex-digit assumption would truncate them
+    // into collisions ('\u0141' and 'A' both -> '41').
+    out += code.toString(16).padStart(4, '0');
+  }
+  return out + '.v1';
+}
+
+function decodeKey(name) {
+  if (!name.endsWith('.v1')) return null;
+  const body = name.slice(0, -3);
+  if (body.length % 4 !== 0) return null;
+  let out = '';
+  for (let i = 0; i < body.length; i += 4) {
+    const code = parseInt(body.slice(i, i + 4), 16);
+    if (Number.isNaN(code)) return null;
+    out += String.fromCharCode(code);
+  }
+  return out;
+}
+
+// A missing key resolves to null, never to ''. Those are different facts --
+// "nothing stored" vs "an empty string was stored" -- and the native primitive
+// preserves the distinction specifically so this layer can too. Collapsing
+// them would make removeItem() indistinguishable from setItem(k, '').
+async function getItem(key) {
+  return mod().readFile(encodeKey(key));
+}
+
+async function setItem(key, value) {
+  if (typeof value !== 'string') {
+    throw new TypeError(
+      'storage values must be strings (stringify first), got ' + typeof value,
+    );
+  }
+  const ok = mod().writeFile(encodeKey(key), value);
+  if (!ok) {
+    // The primitive returns false for a rejected key, a full disk, or a failed
+    // atomic rename. It does not distinguish them, and neither can this layer
+    // honestly, so the error says what is known rather than guessing.
+    throw new Error('storage write failed for key: ' + key);
+  }
+}
+
+// Idempotent, matching the native half: removing an absent key is success, not
+// an error, because that is the state the caller asked for.
+async function removeItem(key) {
+  const ok = mod().deleteFile(encodeKey(key));
+  if (!ok) throw new Error('storage delete failed for key: ' + key);
+}
+
+// Enumeration comes from the DIRECTORY, not from an index file this module
+// maintains. An index is a second source of truth that drifts the moment a
+// write succeeds and the index update does not.
+async function getAllKeys() {
+  const names = mod().listFiles();
+  const keys = [];
+  for (const name of names) {
+    const decoded = decodeKey(name);
+    // Skip anything this module did not write. A foreign file in the container
+    // is not an error and must not break enumeration for everything else.
+    if (decoded !== null) keys.push(decoded);
+  }
+  return keys;
+}
+
+async function clear() {
+  const keys = await getAllKeys();
+  for (const key of keys) {
+    await removeItem(key);
+  }
+}
+
+async function multiGet(keys) {
+  const out = [];
+  for (const key of keys) {
+    out.push([key, await getItem(key)]);
+  }
+  return out;
+}
+
+async function multiSet(pairs) {
+  for (const [key, value] of pairs) {
+    await setItem(key, value);
+  }
+}
+
+module.exports = {
+  getItem,
+  setItem,
+  removeItem,
+  getAllKeys,
+  clear,
+  multiGet,
+  multiSet,
+  // Exported for the gate: it asserts on the encoding round trip directly
+  // rather than inferring it from a get/set pair, so an encoding bug and a
+  // storage bug cannot be confused for each other.
+  encodeKey,
+  decodeKey,
+};

package/src/viewshot/index.js

@@ -0,0 +1,98 @@
+'use strict';
+// FP-43 — react-native-view-shot's JS API on the engine's RNViewShot module.
+//
+// The engine implements view-shot's native module (captureRef, captureScreen,
+// releaseCapture), so an app that depends on react-native-view-shot works as
+// is; this file is the same surface for apps that do not. The snapshot renders
+// the view's subtree into an offscreen on the raster thread, the png/jpg is
+// encoded off the JS thread, and the Promise resolves on the JS thread.
+//
+// options: {format: 'png' | 'jpg', quality: 0..1, result: 'tmpfile' | 'base64'
+// | 'data-uri', width, height (output pixels), fileName}.
+
+const {TurboModuleRegistry, findNodeHandle} = require('react-native');
+
+const Native = TurboModuleRegistry.get('RNViewShot');
+
+function mod() {
+  if (Native == null) {
+    throw new Error(
+      'RNViewShot native module is unavailable. The engine binary predates FP-43: ' +
+        'view snapshots cannot work until the engine is updated.',
+    );
+  }
+  return Native;
+}
+
+const DEFAULTS = {format: 'png', quality: 1, result: 'tmpfile'};
+
+// view-shot's validateOptions: defaults filled in, bad values reported.
+function validateOptions(input) {
+  const options = {...DEFAULTS, ...(input || {})};
+  const errors = [];
+  if ('width' in options && (typeof options.width !== 'number' || options.width <= 0)) {
+    errors.push('option width should be a positive number');
+    delete options.width;
+  }
+  if ('height' in options && (typeof options.height !== 'number' || options.height <= 0)) {
+    errors.push('option height should be a positive number');
+    delete options.height;
+  }
+  if (typeof options.quality !== 'number' || options.quality < 0 || options.quality > 1) {
+    errors.push('option quality should be a number between 0.0 and 1.0');
+    options.quality = DEFAULTS.quality;
+  }
+  if (options.format === 'jpeg') options.format = 'jpg';
+  if (options.format !== 'png' && options.format !== 'jpg') {
+    errors.push(`option format '${options.format}' is not in valid formats: png | jpg`);
+    options.format = DEFAULTS.format;
+  }
+  if (!['tmpfile', 'base64', 'data-uri'].includes(options.result)) {
+    errors.push(`option result '${options.result}' is not in valid results: tmpfile | base64 | data-uri`);
+    options.result = DEFAULTS.result;
+  }
+  return {options, errors};
+}
+
+function toTag(view) {
+  if (view && typeof view === 'object' && 'current' in view) view = view.current;
+  if (typeof view === 'number') return view;
+  const tag = view == null ? null : findNodeHandle(view);
+  if (tag == null) throw new Error('findNodeHandle failed to resolve view=' + String(view));
+  return tag;
+}
+
+// Resolves with a file:// uri, base64 or a data uri (options.result).
+function captureRef(view, optionsObject) {
+  let tag;
+  try {
+    tag = toTag(view);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+  const {options, errors} = validateOptions(optionsObject);
+  if (__DEV__ && errors.length > 0) {
+    console.warn('react-native-view-shot captureRef options: ' + errors.join(', '));
+  }
+  return mod().captureRef(tag, options);
+}
+
+function captureScreen(optionsObject) {
+  const {options, errors} = validateOptions(optionsObject);
+  if (__DEV__ && errors.length > 0) {
+    console.warn('react-native-view-shot captureScreen options: ' + errors.join(', '));
+  }
+  return mod().captureScreen(options);
+}
+
+// Deletes a tmpfile capture.
+function releaseCapture(uri) {
+  if (typeof uri !== 'string') return;
+  mod().releaseCapture(uri);
+}
+
+function isSupported() {
+  return Native != null;
+}
+
+module.exports = {captureRef, captureScreen, releaseCapture, isSupported};