@farm.js/core 0.1.51-beta.3 → 0.1.60

package/dist/chunk-SJRCWF4Z.mjs

@@ -0,0 +1,237 @@
+import {
+  readFarmNativeWebSpec
+} from "./chunk-6UUH4N4J.mjs";
+import {
+  isPlainObject,
+  readAppPackageJson
+} from "./chunk-UB7RVEMX.mjs";
+
+// src/mobile/modules.ts
+import { existsSync, readdirSync, readFileSync, realpathSync } from "fs";
+import * as path from "path";
+var MODULE_KEYS = /* @__PURE__ */ new Set(["permissions", "usage", "web"]);
+var PERMISSION = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/;
+var BARE_PERMISSION = /^[A-Z][A-Z0-9_]*$/;
+var USAGE_KEY = /^NS[A-Za-z0-9]+UsageDescription$/;
+var SPEC_FILE = /^Native[A-Za-z0-9_]+\.(?:ts|js)$/;
+var SPEC_NAME = /TurboModuleRegistry\s*\.\s*(?:getEnforcing|get)\s*(?:<[^>]*>)?\s*\(\s*(["'`])([A-Za-z_$][\w$]*)\1/;
+function relative2(root, file) {
+  return path.relative(root, file).split(path.sep).join("/");
+}
+function scanFarmMobileAppModules(options) {
+  const dir = path.resolve(options.root, options.srcDir ?? "src", "native");
+  if (!existsSync(dir)) return void 0;
+  const entries = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  const specs = [];
+  const names = /* @__PURE__ */ new Map();
+  for (const name of entries.filter((entry) => SPEC_FILE.test(entry))) {
+    const file = path.join(dir, name);
+    const match = SPEC_NAME.exec(readFileSync(file, "utf8"));
+    const shown = relative2(options.root, file);
+    if (!match) {
+      throw new TypeError(
+        `${shown} is a native module spec (Native*.ts) without a registered name. Export TurboModuleRegistry.getEnforcing<Spec>("${name.replace(/^Native|\.\w+$/g, "")}") as its default, as in a React Native app.`
+      );
+    }
+    const other = names.get(match[2]);
+    if (other) {
+      throw new TypeError(
+        `${shown} and ${other} both register the native module "${match[2]}". Give each spec its own name.`
+      );
+    }
+    names.set(match[2], shown);
+    specs.push({ name: match[2], file });
+  }
+  const android = entries.filter((entry) => entry.endsWith(".kt")).map((entry) => path.join(dir, entry));
+  const ios = entries.filter((entry) => entry.endsWith(".swift")).map((entry) => path.join(dir, entry));
+  if (specs.length === 0 && android.length === 0 && ios.length === 0) return void 0;
+  return { dir, specs, android, ios };
+}
+function findPackage(name, from) {
+  let dir = from;
+  for (; ; ) {
+    const candidate = path.join(dir, "node_modules", name);
+    if (existsSync(path.join(candidate, "package.json"))) return realpathSync(candidate);
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function installedModuleProblem(name, root, dependencies) {
+  if (!(name in dependencies)) return "unknown";
+  const dir = findPackage(name, root);
+  if (!dir) return "missing";
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+    return isPlainObject(pkg) && isPlainObject(pkg.codegenConfig) ? void 0 : "not-a-module";
+  } catch {
+    return "not-a-module";
+  }
+}
+function resolveFarmMobileModules(input, options, fail) {
+  if (input === void 0) return {};
+  if (!isPlainObject(input)) {
+    fail(
+      'modules must be an object keyed by module name, such as { Device: { permissions: ["android.permission.VIBRATE"] } }.'
+    );
+  }
+  const issues = [];
+  const resolved = {};
+  const appModules = new Set(options.appModules ?? []);
+  const usageOwners = /* @__PURE__ */ new Map();
+  let dependencies;
+  const specDir = relative2(
+    options.root,
+    path.resolve(options.root, options.srcDir ?? "src", "native")
+  );
+  for (const name of Object.keys(input).sort()) {
+    const where = `modules[${JSON.stringify(name)}]`;
+    const entry = input[name];
+    if (!appModules.has(name)) {
+      dependencies ?? (dependencies = ((value) => isPlainObject(value) ? value : {})(
+        readAppPackageJson(options.root).dependencies
+      ));
+      const problem = installedModuleProblem(name, options.root, dependencies);
+      if (problem === "unknown") {
+        issues.push(
+          `${where} is not one of the app's native modules or an installed React Native module. Use the name a ${specDir}/Native*.ts spec registers, or a package in dependencies in package.json.`
+        );
+      } else if (problem === "missing") {
+        issues.push(
+          `${where} is in dependencies but not installed. Install the app's dependencies, then run the command again.`
+        );
+      } else if (problem === "not-a-module") {
+        issues.push(
+          `${where} names a package with no "codegenConfig" in its package.json, so it is not a React Native module for the new architecture. Remove the entry, or upgrade the package.`
+        );
+      }
+    }
+    if (!isPlainObject(entry)) {
+      issues.push(
+        `${where} must be an object, such as { permissions: ["android.permission.VIBRATE"] }.`
+      );
+      continue;
+    }
+    for (const key of Object.keys(entry)) {
+      if (!MODULE_KEYS.has(key)) {
+        issues.push(`unknown option ${where}.${key}. Supported: permissions, usage, web.`);
+      }
+    }
+    const permissions = [];
+    if (entry.permissions !== void 0) {
+      if (!Array.isArray(entry.permissions)) {
+        issues.push(
+          `${where}.permissions must be an array of Android permissions, such as ["android.permission.VIBRATE"].`
+        );
+      } else {
+        entry.permissions.forEach((permission, index) => {
+          const at = `${where}.permissions[${index}]`;
+          if (typeof permission !== "string" || !PERMISSION.test(permission)) {
+            const hint = typeof permission === "string" && BARE_PERMISSION.test(permission) ? ` Use "android.permission.${permission}".` : "";
+            issues.push(
+              `${at} must be a full Android permission name such as "android.permission.VIBRATE", got ${JSON.stringify(permission)}.${hint}`
+            );
+          } else if (!permissions.includes(permission)) {
+            permissions.push(permission);
+          }
+        });
+      }
+    }
+    const usage = {};
+    if (entry.usage !== void 0) {
+      if (!isPlainObject(entry.usage)) {
+        issues.push(
+          `${where}.usage must be an object of iOS usage strings, such as { NSCameraUsageDescription: "Scans receipts." }.`
+        );
+      } else {
+        for (const [key, value] of Object.entries(entry.usage)) {
+          const at = `${where}.usage.${key}`;
+          if (!USAGE_KEY.test(key)) {
+            issues.push(
+              `${at} is not an iOS usage-description key. Keys are NS...UsageDescription, such as NSCameraUsageDescription.`
+            );
+          } else if (typeof value !== "string" || !value.trim()) {
+            issues.push(
+              `${at} must be a non-empty string: the sentence iOS shows when it asks for access.`
+            );
+          } else {
+            const owner = usageOwners.get(key);
+            if (owner && owner.value !== value.trim()) {
+              issues.push(
+                `${at} and modules[${JSON.stringify(owner.name)}].usage.${key} set different strings, and Info.plist has one per key. Set it on one module.`
+              );
+            }
+            usageOwners.set(key, { name, value: value.trim() });
+            usage[key] = value.trim();
+          }
+        }
+      }
+    }
+    let web = false;
+    if (entry.web !== void 0) {
+      if (typeof entry.web !== "boolean") {
+        issues.push(`${where}.web must be true or false.`);
+      } else if (entry.web && !appModules.has(name)) {
+        issues.push(
+          `${where}.web is true, but web screens reach only the app's own modules in ${specDir}. "${name}" needs the React Native JS runtime, which web screens do not have. Remove web, and call the module from a native screen (page.native.tsx).`
+        );
+      } else {
+        web = entry.web;
+      }
+    }
+    resolved[name] = { permissions, usage, web };
+  }
+  if (issues.length === 1) fail(issues[0]);
+  if (issues.length > 1) {
+    fail(
+      `modules has ${issues.length} problems:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`
+    );
+  }
+  return resolved;
+}
+function readFarmMobileWebModules(appModules, modules, options) {
+  const issues = [];
+  const specs = appModules.specs.map((spec) => {
+    if (!modules[spec.name]?.web) return spec;
+    const shown = relative2(options.root, spec.file);
+    const where = `modules[${JSON.stringify(spec.name)}].web`;
+    let web;
+    try {
+      web = readFarmNativeWebSpec({ root: options.root, file: spec.file });
+    } catch (error) {
+      issues.push(`${where}: ${error.message}`);
+      return spec;
+    }
+    for (const { method, reason } of web.unsupported) {
+      issues.push(
+        `${where}: ${shown} declares ${method}(), but ${reason}. Change the parameter to a string, number, boolean, object, or array, or remove web and call the module from a native screen (page.native.tsx).`
+      );
+    }
+    if (web.methods.some((method) => method.name === "available")) {
+      issues.push(
+        `${where}: ${shown} declares available(), which web screens use to check for the module (native.<module>.available()). Rename the method.`
+      );
+    }
+    if (web.methods.length === 0 && web.unsupported.length === 0) {
+      issues.push(
+        `${where}: ${shown} declares no method that returns a Promise, and web screens call only those. Remove web, or declare one, such as model(): Promise<string>.`
+      );
+    }
+    return { ...spec, web };
+  });
+  if (issues.length === 1) throw new TypeError(issues[0]);
+  if (issues.length > 1) {
+    throw new TypeError(
+      `modules has ${issues.length} problems:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`
+    );
+  }
+  return { ...appModules, specs };
+}
+
+export {
+  scanFarmMobileAppModules,
+  resolveFarmMobileModules,
+  readFarmMobileWebModules
+};

package/dist/{chunk-4353ZRE5.mjs → chunk-SX7EECTS.mjs}

@@ -1,20 +1,20 @@
 import {
   FARM_RSC_INSTALL_HINT,
   findFarmAppPackageDir
-} from "./chunk-SHS6KXOZ.mjs";
+} from "./chunk-UR25Z5Z6.mjs";
 import {
   createFarmDevLoopbackPlugin
-} from "./chunk-LMFJCXDD.mjs";
+} from "./chunk-FN5UEC7I.mjs";
 import {
   resolveDeployOutputPath
-} from "./chunk-GAO7MS5O.mjs";
+} from "./chunk-VPTWKOCY.mjs";
 import {
   farmDesktopDevGuardPlugin,
   loadFarmReactPlugin
 } from "./chunk-QOSDWGKT.mjs";
 import {
   loadTailwindVitePlugin
-} from "./chunk-PIHKO25G.mjs";
+} from "./chunk-OM7WILES.mjs";
 import {
   resolveFarmPlatform
 } from "./chunk-SMUW7UST.mjs";
@@ -93,12 +93,15 @@ async function createFarmRscViteConfig(userConfig, options) {
   }
   const createReactPlugin = hasPluginNamed(vitePlugins, "vite:react") ? void 0 : viteReact?.default ?? (options.command === "serve" ? (await loadFarmReactPlugin()).default : void 0);
   const tailwind = hasPluginNamed(vitePlugins, "@tailwindcss/vite") ? void 0 : await loadTailwindVitePlugin();
+  const platform = resolveFarmPlatform();
+  const mobileClient = userConfig.mobile === void 0 || platform === "desktop" ? void 0 : options.command === "build" ? "entry" : platform === "mobile" ? "inline" : void 0;
   const farmConfig = pluginRsc.defineConfig({
     ...rscConfig,
+    ...mobileClient ? { mobileClient } : {},
     experimental: { ...userConfig.experimental, serverComponents: true },
     port: options.port ?? userConfig.server?.port,
     plugins: [
-      ...options.command === "serve" && resolveFarmPlatform() === "desktop" ? [
+      ...options.command === "serve" && platform === "desktop" ? [
         farmDesktopDevGuardPlugin(
           typeof userConfig.basePath === "string" ? userConfig.basePath : void 0
         )

package/dist/{chunk-LDNSSHEG.mjs → chunk-T4TBK5NY.mjs}

@@ -1,9 +1,9 @@
 import {
   isFarmMetadataNoIndex
-} from "./chunk-YAJTD3ZG.mjs";
+} from "./chunk-KVW2M6PI.mjs";
 import {
   matchesFarmMarkdownRoutePattern
-} from "./chunk-LPDKG6RA.mjs";
+} from "./chunk-YSXTNSXS.mjs";
 import {
   applyFarmBasePath
 } from "./chunk-SF3JB56B.mjs";