@rejaul/react-native-rust 1.0.2 → 2.0.0

package/dist/codegen/spec.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var spec_exports = {};
+__export(spec_exports, {
+  callbackInfo: () => callbackInfo,
+  parseSpec: () => parseSpec,
+  toSnakeCase: () => toSnakeCase,
+  typeInfo: () => typeInfo,
+  validateIdentifier: () => validateIdentifier
+});
+module.exports = __toCommonJS(spec_exports);
+var import_constants = require("./constants");
+function typeInfo(typeNode, sourceFile, methodName, role) {
+  const info = import_constants.supportedTypes.get(typeNode.kind);
+  if (info && !(role === "parameter" && typeNode.kind === import_constants.ts.SyntaxKind.VoidKeyword)) return info;
+  if (role === "return" && import_constants.ts.isTypeReferenceNode(typeNode) && typeNode.typeName.getText(sourceFile) === "Promise") {
+    if (typeNode.typeArguments?.length !== 1) throw new Error(`Promise return in ${methodName}() must declare one result type.`);
+    const result = typeInfo(typeNode.typeArguments[0], sourceFile, methodName, "promise result");
+    if (result.promise) {
+      throw new Error(`Nested Promise or callback results are not supported in ${methodName}().`);
+    }
+    return { ...result, typescript: typeNode.getText(sourceFile), promise: true };
+  }
+  const typeName = import_constants.ts.isTypeReferenceNode(typeNode) ? typeNode.typeName.getText(sourceFile) : "";
+  const objectType = typeNode.kind === import_constants.ts.SyntaxKind.ObjectKeyword || ["CodegenTypes.UnsafeObject", "UnsafeObject"].includes(typeName);
+  if (objectType) {
+    return {
+      kind: "json",
+      typescript: typeNode.getText(sourceFile),
+      rust: "serde_json::Value",
+      cpp: "jsi::Object",
+      defaultValue: "serde_json::json!({})"
+    };
+  }
+  const arrayElement = import_constants.ts.isArrayTypeNode(typeNode) ? typeNode.elementType : import_constants.ts.isTypeReferenceNode(typeNode) && ["Array", "ReadonlyArray"].includes(typeNode.typeName.getText(sourceFile)) && typeNode.typeArguments?.length === 1 ? typeNode.typeArguments[0] : null;
+  if (arrayElement) {
+    const elementType = typeInfo(arrayElement, sourceFile, methodName, "array element");
+    if (elementType.promise || elementType.kind === "void") {
+      throw new Error(`Unsupported array element type in ${methodName}().`);
+    }
+    return {
+      kind: "json",
+      typescript: typeNode.getText(sourceFile),
+      rust: "serde_json::Value",
+      cpp: "jsi::Array",
+      defaultValue: "serde_json::json!([])"
+    };
+  }
+  const text = typeNode.getText(sourceFile);
+  throw new Error(`Unsupported ${role} type "${text}" in ${methodName}(). Supported types are number, boolean, string, arrays, and CodegenTypes.UnsafeObject${role === "return" ? ", plus void and Promise<T>" : ""}.`);
+}
+function callbackInfo(typeNode, sourceFile, methodName) {
+  if (!import_constants.ts.isFunctionTypeNode(typeNode) || typeNode.typeParameters?.length) {
+    throw new Error(`Unsupported callback signature in ${methodName}().`);
+  }
+  if (typeNode.type.kind !== import_constants.ts.SyntaxKind.VoidKeyword || typeNode.parameters.length > 4) {
+    throw new Error(`Callbacks in ${methodName}() must return void and have at most four parameters.`);
+  }
+  const params = typeNode.parameters.map((parameter) => {
+    if (!import_constants.ts.isIdentifier(parameter.name) || parameter.questionToken || parameter.dotDotDotToken || !parameter.type) {
+      throw new Error(`Callback parameters in ${methodName}() must be named, required, and explicitly typed.`);
+    }
+    const info = typeInfo(parameter.type, sourceFile, methodName, "callback parameter");
+    if (info.promise || info.kind === "void") {
+      throw new Error(`Unsupported callback parameter type in ${methodName}().`);
+    }
+    return { name: parameter.name.text, ...info };
+  });
+  return { kind: "callback", typescript: typeNode.getText(sourceFile), cpp: "jsi::Function", params };
+}
+function toSnakeCase(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function validateIdentifier(name, location) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name) || import_constants.rustKeywords.has(name) || import_constants.cppKeywords.has(name)) {
+    throw new Error(`Unsupported identifier "${name}" in ${location}; use a non-keyword identifier.`);
+  }
+}
+function parseSpec(sourceText, fileName = "NativeModule.ts") {
+  const sourceFile = import_constants.ts.createSourceFile(fileName, sourceText, import_constants.ts.ScriptTarget.Latest, true, import_constants.ts.ScriptKind.TS);
+  if (sourceFile.parseDiagnostics.length > 0) {
+    const diagnostic = sourceFile.parseDiagnostics[0];
+    throw new Error(`Could not parse ${fileName}: ${import_constants.ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`);
+  }
+  const spec = sourceFile.statements.find((statement) => import_constants.ts.isInterfaceDeclaration(statement) && statement.name.text === "Spec");
+  if (!spec) throw new Error(`No "Spec" interface was found in ${fileName}.`);
+  if (spec.typeParameters?.length) throw new Error("Generic TurboModule Spec interfaces are not supported.");
+  if (spec.members.length === 0) throw new Error("The Spec interface must declare at least one method.");
+  const names = /* @__PURE__ */ new Set();
+  const rustNames = /* @__PURE__ */ new Set();
+  const methods = spec.members.map((member) => {
+    if (!import_constants.ts.isMethodSignature(member)) {
+      throw new Error("Only method signatures are supported in the Spec interface.");
+    }
+    if (!member.name || !import_constants.ts.isIdentifier(member.name) || member.questionToken || member.typeParameters?.length) {
+      throw new Error("Optional, computed, and generic Spec methods are not supported.");
+    }
+    const name = member.name.text;
+    validateIdentifier(name, "Spec method");
+    if (names.has(name)) throw new Error(`Overloaded method "${name}" is not supported.`);
+    names.add(name);
+    const rustName = toSnakeCase(name);
+    validateIdentifier(rustName, `Rust mapping for ${name}()`);
+    if (rustNames.has(rustName)) throw new Error(`Multiple Spec methods map to the Rust name "${rustName}".`);
+    rustNames.add(rustName);
+    const params = member.parameters.map((parameter) => {
+      if (!import_constants.ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.questionToken || parameter.initializer) {
+        throw new Error(`Rest, optional, and destructured parameters are not supported in ${name}().`);
+      }
+      const paramName = parameter.name.text;
+      validateIdentifier(paramName, `parameter in ${name}()`);
+      if (!parameter.type) throw new Error(`Parameter "${paramName}" in ${name}() needs an explicit type.`);
+      const info = import_constants.ts.isFunctionTypeNode(parameter.type) ? callbackInfo(parameter.type, sourceFile, name) : typeInfo(parameter.type, sourceFile, name, "parameter");
+      return { name: paramName, ...info };
+    });
+    if (new Set(params.map((param) => param.name)).size !== params.length) {
+      throw new Error(`Duplicate parameter names are not supported in ${name}().`);
+    }
+    if (!member.type) throw new Error(`Method "${name}()" needs an explicit return type.`);
+    return {
+      name,
+      rustName,
+      symbol: `rnrs_${rustName}`,
+      params,
+      returnType: typeInfo(member.type, sourceFile, name, "return")
+    };
+  });
+  for (const method of methods) {
+    if (method.returnType.promise && method.params.some((param) => param.kind === "callback")) {
+      throw new Error(`Callbacks in Promise method ${method.name}() are not supported. Use a Codegen event emitter for asynchronous callbacks.`);
+    }
+  }
+  return methods;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callbackInfo,
+  parseSpec,
+  toSnakeCase,
+  typeInfo,
+  validateIdentifier
+});

package/dist/codegen/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/codegen.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codegen_exports = {};
+module.exports = __toCommonJS(codegen_exports);
+__reExport(codegen_exports, require("./codegen/index"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./codegen/index")
+});

package/dist/dev/buildQueue.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildQueue_exports = {};
+__export(buildQueue_exports, {
+  SingleFlightQueue: () => SingleFlightQueue
+});
+module.exports = __toCommonJS(buildQueue_exports);
+class SingleFlightQueue {
+  constructor(task) {
+    this.task = task;
+  }
+  task;
+  running = false;
+  pending = false;
+  /** Requests a run. Coalesced into the in-flight run's follow-up if one is already running. */
+  request() {
+    if (this.running) {
+      this.pending = true;
+      return;
+    }
+    void this.run();
+  }
+  async run() {
+    this.running = true;
+    do {
+      this.pending = false;
+      try {
+        await this.task();
+      } catch {
+      }
+    } while (this.pending);
+    this.running = false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SingleFlightQueue
+});

package/dist/dev/watcher.js

@@ -0,0 +1,90 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var watcher_exports = {};
+__export(watcher_exports, {
+  classifyChange: () => classifyChange,
+  watchRustProject: () => watchRustProject
+});
+module.exports = __toCommonJS(watcher_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+function classifyChange(filePath, target) {
+  const resolved = import_node_path.default.resolve(filePath);
+  if (resolved === import_node_path.default.resolve(target.specPath)) return "spec";
+  const rustSrc = import_node_path.default.resolve(target.rustRoot, "src");
+  const cargoToml = import_node_path.default.resolve(target.rustRoot, "Cargo.toml");
+  const cargoLock = import_node_path.default.resolve(target.rustRoot, "Cargo.lock");
+  if (resolved === cargoToml || resolved === cargoLock) return "rust";
+  if (resolved.startsWith(`${rustSrc}${import_node_path.default.sep}`) && resolved.endsWith(".rs")) return "rust";
+  return "other";
+}
+function watchRustProject(options) {
+  const { target, onChange, debounceMs = 200, log = console.log } = options;
+  const watcher = import_chokidar.default.watch(
+    [import_node_path.default.join(target.rustRoot, "**", "*.rs"), import_node_path.default.join(target.rustRoot, "Cargo.toml"), import_node_path.default.join(target.rustRoot, "Cargo.lock"), target.specPath],
+    {
+      ignored: [
+        import_node_path.default.join(target.rustRoot, "target", "**"),
+        import_node_path.default.join(target.rustRoot, "build", "**"),
+        import_node_path.default.join(target.rustRoot, "include", "**"),
+        "**/node_modules/**",
+        "**/.git/**"
+      ],
+      ignoreInitial: true,
+      // Waits for a file's size to stop changing before firing, so editors that write in
+      // multiple chunks (atomic saves, rename-into-place) produce one event, not several.
+      awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 20 }
+    }
+  );
+  let pendingKinds = /* @__PURE__ */ new Set();
+  let timer = null;
+  const schedule = (filePath, eventLabel) => {
+    const kind = classifyChange(filePath, target);
+    if (kind === "other") return;
+    pendingKinds.add(kind);
+    log(`[Rust] ${eventLabel} ${import_node_path.default.relative(import_node_path.default.dirname(target.rustRoot), filePath)}`);
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const kinds = pendingKinds;
+      pendingKinds = /* @__PURE__ */ new Set();
+      timer = null;
+      onChange(kinds);
+    }, debounceMs);
+  };
+  watcher.on("add", (filePath) => schedule(filePath, "Added"));
+  watcher.on("change", (filePath) => schedule(filePath, "Changed"));
+  watcher.on("unlink", (filePath) => schedule(filePath, "Deleted"));
+  watcher.on("error", (error) => log(`[Rust] Watcher error: ${error.message}`));
+  return watcher;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  classifyChange,
+  watchRustProject
+});

package/dist/metro.js

@@ -0,0 +1,100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metro_exports = {};
+__export(metro_exports, {
+  findRustDir: () => findRustDir,
+  stopRustWatcher: () => stopRustWatcher,
+  withRust: () => withRust
+});
+module.exports = __toCommonJS(metro_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+let watcherProcess = null;
+function findRustDir(projectRoot, rustDir) {
+  const resolved = import_node_path.default.resolve(projectRoot, rustDir || "rust");
+  return import_node_fs.default.existsSync(import_node_path.default.join(resolved, "Cargo.toml")) ? resolved : null;
+}
+function ensureWatcherRunning(projectRoot, notify) {
+  if (watcherProcess) return;
+  const cliEntry = import_node_path.default.join(__dirname, "react-native-rust.js");
+  const child = (0, import_node_child_process.spawn)(process.execPath, [cliEntry, "watch"], { cwd: projectRoot });
+  watcherProcess = child;
+  child.stdout?.on("data", (chunk) => process.stdout.write(chunk));
+  child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+  child.on("exit", (code) => {
+    watcherProcess = null;
+    if (code !== 0 && code !== null) {
+      notify(`[RN Rust] The Rust watcher exited unexpectedly (code ${code}). Restart Metro to retry, or run \`npx react-native-rust watch\` manually.`);
+    }
+  });
+  const stop = () => {
+    if (watcherProcess) watcherProcess.kill("SIGINT");
+  };
+  process.once("exit", stop);
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+}
+function stopRustWatcher() {
+  if (!watcherProcess) return Promise.resolve();
+  const child = watcherProcess;
+  return new Promise((resolve) => {
+    child.once("exit", () => resolve());
+    child.kill("SIGINT");
+  });
+}
+function withRust(config, options = {}) {
+  const projectRoot = config.projectRoot || process.cwd();
+  const rustDir = findRustDir(projectRoot, options.rustDir);
+  const existingWatchFolders = config.watchFolders || [];
+  const watchFolders = rustDir && !existingWatchFolders.includes(rustDir) ? [...existingWatchFolders, rustDir] : existingWatchFolders;
+  const previousEnhanceMiddleware = config.server?.enhanceMiddleware;
+  return {
+    ...config,
+    watchFolders,
+    server: {
+      ...config.server,
+      enhanceMiddleware: (middleware, server) => {
+        const next = previousEnhanceMiddleware ? previousEnhanceMiddleware(middleware, server) : middleware;
+        if (rustDir) {
+          ensureWatcherRunning(projectRoot, console.log);
+        } else {
+          console.log("[RN Rust] No rust/Cargo.toml found; skipping the automatic Rust watcher. Run `npx react-native-rust init` (or `init --app`) to add Rust support.");
+        }
+        return next;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findRustDir,
+  stopRustWatcher,
+  withRust
+});