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

package/dist/chunk-6UUH4N4J.mjs

@@ -0,0 +1,251 @@
+// src/mobile/native-specs.ts
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+var UnsupportedType = class extends Error {
+};
+var parsers = /* @__PURE__ */ new Map();
+function loadCodegen(root) {
+  const cached = parsers.get(root);
+  if (cached) return cached;
+  let codegenDir;
+  let load;
+  try {
+    let reactNative;
+    for (let dir = root; ; dir = path.dirname(dir)) {
+      const candidate = path.join(dir, "node_modules", "react-native", "package.json");
+      if (existsSync(candidate)) {
+        reactNative = realpathSync(candidate);
+        break;
+      }
+      if (path.dirname(dir) === dir) throw new Error(`react-native is not installed in ${root}.`);
+    }
+    load = createRequire(reactNative);
+    codegenDir = path.dirname(load.resolve("@react-native/codegen/package.json"));
+  } catch (error) {
+    throw Object.assign(
+      new Error(
+        "Reading a native module spec needs React Native's Codegen (@react-native/codegen, installed with react-native). Add react-native to the app's dependencies and install them."
+      ),
+      { cause: error }
+    );
+  }
+  const typescript = load(path.join(codegenDir, "lib/parsers/typescript/parser.js"));
+  const flow = load(path.join(codegenDir, "lib/parsers/flow/parser.js"));
+  const loaded = { typescript: new typescript.TypeScriptParser(), flow: new flow.FlowParser() };
+  parsers.set(root, loaded);
+  return loaded;
+}
+function hasFarmNativeCodegen(root) {
+  try {
+    loadCodegen(root);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describe(annotation) {
+  switch (annotation.type) {
+    case "FunctionTypeAnnotation":
+      return "a callback";
+    case "MixedTypeAnnotation":
+      return "a mixed value";
+    case "ReservedTypeAnnotation":
+      return String(annotation.name ?? "a reserved type");
+    case "EventEmitterTypeAnnotation":
+      return "an event emitter";
+    default:
+      return annotation.type.replace(/TypeAnnotation$/, "");
+  }
+}
+function toType(annotation, module, options = {}) {
+  switch (annotation.type) {
+    case "NullableTypeAnnotation":
+      return {
+        ...toType(annotation.typeAnnotation, module, options),
+        nullable: true
+      };
+    case "StringTypeAnnotation":
+      return { type: "string" };
+    case "NumberTypeAnnotation":
+    case "DoubleTypeAnnotation":
+    case "FloatTypeAnnotation":
+      return { type: "number" };
+    case "Int32TypeAnnotation":
+      return { type: "number", integer: true };
+    case "BooleanTypeAnnotation":
+      return { type: "boolean" };
+    case "StringLiteralTypeAnnotation":
+    case "NumberLiteralTypeAnnotation":
+      return { type: "literal", values: [annotation.value] };
+    case "UnionTypeAnnotation":
+    case "StringLiteralUnionTypeAnnotation": {
+      const types = annotation.types ?? [];
+      const values = types.map((member) => member.value);
+      if (types.length > 0 && types.every(
+        (member) => member.type === "StringLiteralTypeAnnotation" || member.type === "NumberLiteralTypeAnnotation"
+      ) && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType("a union that is not all string or all number literals");
+    }
+    case "EnumDeclaration": {
+      const members = module.enumMap?.[String(annotation.name)]?.members ?? [];
+      const values = members.map((member) => member.value?.value);
+      if (values.length > 0 && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType(`the enum ${String(annotation.name)}`);
+    }
+    case "ObjectTypeAnnotation": {
+      const properties = annotation.properties ?? [];
+      return {
+        type: "object",
+        properties: properties.map((property) => ({
+          name: property.name,
+          optional: property.optional === true,
+          type: toType(property.typeAnnotation, module, options)
+        }))
+      };
+    }
+    case "TypeAliasTypeAnnotation": {
+      const alias = module.aliasMap?.[String(annotation.name)];
+      if (!alias) throw new UnsupportedType(`the unknown type ${String(annotation.name)}`);
+      return toType(alias, module, options);
+    }
+    case "GenericObjectTypeAnnotation":
+      return { type: "map" };
+    case "ArrayTypeAnnotation": {
+      const element = annotation.elementType;
+      if (!element || element.type === "AnyTypeAnnotation") return { type: "array" };
+      return { type: "array", element: toType(element, module, options) };
+    }
+    case "VoidTypeAnnotation":
+      if (options.returns) return { type: "void" };
+      break;
+  }
+  if (options.returns) return { type: "unknown" };
+  throw new UnsupportedType(describe(annotation));
+}
+function readFarmNativeWebSpec(options) {
+  const codegen = loadCodegen(options.root);
+  const parser = /\.tsx?$/.test(options.file) ? codegen.typescript : codegen.flow;
+  let schema;
+  try {
+    schema = parser.parseFile(options.file);
+  } catch (error) {
+    const shown = path.relative(options.root, options.file).split(path.sep).join("/");
+    throw Object.assign(
+      new Error(`React Native's Codegen rejected ${shown}: ${error.message}`),
+      { cause: error }
+    );
+  }
+  const module = Object.values(schema.modules).find((entry) => entry.type === "NativeModule");
+  const result = { methods: [], unsupported: [] };
+  for (const method of module?.spec?.methods ?? []) {
+    let fn = method.typeAnnotation;
+    if (fn.type === "NullableTypeAnnotation") fn = fn.typeAnnotation;
+    if (fn.type !== "FunctionTypeAnnotation") continue;
+    const returned = fn.returnTypeAnnotation;
+    if (returned?.type !== "PromiseTypeAnnotation") continue;
+    const params = fn.params ?? [];
+    try {
+      result.methods.push({
+        name: method.name,
+        params: params.map((param) => {
+          try {
+            return {
+              name: param.name,
+              optional: param.optional === true,
+              type: toType(param.typeAnnotation, module)
+            };
+          } catch (error) {
+            if (!(error instanceof UnsupportedType)) throw error;
+            throw new UnsupportedType(
+              `its parameter ${param.name} is ${error.message}, which a web screen cannot send`
+            );
+          }
+        }),
+        returns: toType(
+          returned.elementType ?? { type: "VoidTypeAnnotation" },
+          module,
+          { returns: true }
+        )
+      });
+    } catch (error) {
+      if (!(error instanceof UnsupportedType)) throw error;
+      result.unsupported.push({ method: method.name, reason: error.message });
+    }
+  }
+  return result;
+}
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function renderFarmNativeType(type) {
+  let rendered;
+  switch (type.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "void":
+    case "unknown":
+      rendered = type.type;
+      break;
+    case "literal":
+      rendered = type.values.map((value) => JSON.stringify(value)).join(" | ");
+      break;
+    case "map":
+      rendered = "Record<string, unknown>";
+      break;
+    case "array": {
+      const element = type.element ? renderFarmNativeType(type.element) : "unknown";
+      rendered = `Array<${element}>`;
+      break;
+    }
+    case "object":
+      rendered = type.properties.length ? `{ ${type.properties.map(
+        (property) => `${IDENTIFIER.test(property.name) ? property.name : JSON.stringify(property.name)}${property.optional ? "?" : ""}: ${renderFarmNativeType(property.type)}`
+      ).join("; ")} }` : "{}";
+      break;
+  }
+  return type.nullable ? `${rendered} | null` : rendered;
+}
+function renderFarmNativeMethod(method) {
+  const lastRequired = method.params.reduce(
+    (last, param, index) => param.optional ? last : index,
+    -1
+  );
+  const params = method.params.map((param, index) => {
+    const type = renderFarmNativeType(param.type);
+    if (!param.optional) return `${param.name}: ${type}`;
+    return index > lastRequired ? `${param.name}?: ${type}` : `${param.name}: ${type} | undefined`;
+  }).join(", ");
+  return `${method.name}(${params}): Promise<${renderFarmNativeType(method.returns)}>;`;
+}
+function createFarmNativeModuleTypeDeclarations(specs, options) {
+  if (specs.length === 0 || !hasFarmNativeCodegen(options.root)) return void 0;
+  const modules = specs.map((spec) => {
+    const { methods } = readFarmNativeWebSpec({ root: options.root, file: spec.file });
+    const body = methods.filter((method) => method.name !== "available").map((method) => `      ${renderFarmNativeMethod(method)}`).join("\n");
+    return `    ${spec.name}: {${body ? `
+${body}
+    ` : ""}};`;
+  });
+  return `/**
+ * Auto-generated from the Codegen specs in src/native: native.<module> from @farm.js/core/native.
+ * Web screens reach a module's Promise methods only when mobile.modules.<name>.web is true, and
+ * only inside the Android shell; check native.<module>.available() first.
+ */
+declare module "@farm.js/core/native" {
+  interface FarmNativeModules {
+${modules.join("\n")}
+  }
+}`;
+}
+
+export {
+  hasFarmNativeCodegen,
+  readFarmNativeWebSpec,
+  renderFarmNativeType,
+  renderFarmNativeMethod,
+  createFarmNativeModuleTypeDeclarations
+};

package/dist/{chunk-2NHOYYUT.mjs → chunk-7H45IJWO.mjs}

@@ -26,7 +26,7 @@ import {
 import {
   getFarmAPIBaseURL,
   resolveFarmAPIRequestURL
-} from "./chunk-BLD5GVCG.mjs";
+} from "./chunk-W6QLRQ3V.mjs";
 import {
   FARM_CACHE_INVALIDATION_HEADER,
   applyFarmCacheInvalidations,
@@ -2045,7 +2045,7 @@ function buildCacheKey(method, path, input, baseURL, defaultHeaders) {
   return `${method}:${url.origin}${url.pathname}:${stableStringify(keyInput ?? {})}`;
 }
 function isSameOriginAPIBaseURL(baseURL) {
-  if (typeof window === "undefined") return baseURL.startsWith("/");
+  if (typeof window === "undefined" || !window.location) return baseURL.startsWith("/");
   return resolveFarmAPIRequestURL("/api", baseURL).origin === window.location.origin;
 }
 function stableStringify(value) {

package/dist/{chunk-NN3MOPSI.mjs → chunk-A2MN5PQJ.mjs}

@@ -1,14 +1,14 @@
+import {
+  appendMiddlewareDirectory,
+  appendMiddlewareRoutePath,
+  compareMiddlewareRouteLocations
+} from "./chunk-MMK4MZUN.mjs";
 import {
   normalizeMiddlewareModule,
   parseMiddlewareCookieHeader,
   serializeMiddlewareCookie,
   serializeMiddlewareCookieDeletion
 } from "./chunk-KPAJWD3N.mjs";
-import {
-  appendMiddlewareDirectory,
-  appendMiddlewareRoutePath,
-  compareMiddlewareRouteLocations
-} from "./chunk-5ENW27SL.mjs";
 import {
   compileMiddlewareConfig,
   compileMiddlewareRoute,
@@ -27,7 +27,7 @@ import {
 } from "./chunk-TUOO6IK3.mjs";
 import {
   logger
-} from "./chunk-Y3N5BFRJ.mjs";
+} from "./chunk-JSDV2NUN.mjs";
 import {
   emitFarmEvent
 } from "./chunk-2DA7CLY7.mjs";
@@ -36,7 +36,7 @@ import {
 } from "./chunk-CO6UYM2D.mjs";
 import {
   createFarmAPIMiddlewarePathnames
-} from "./chunk-LM2YOGDK.mjs";
+} from "./chunk-2I6PUKWJ.mjs";
 import {
   getFarmRedirectError,
   isFarmNotFoundError,

package/dist/{chunk-KY32FWK7.mjs → chunk-BHJAYPYU.mjs}

@@ -17,7 +17,7 @@ import {
   matchAPIRouteAtBasePath,
   mergePluginAPIRoutes,
   resolveAPIRouteEndpoint
-} from "./chunk-LJDIFIJ2.mjs";
+} from "./chunk-RPUJHJHE.mjs";
 import {
   registerAPIRouteShape
 } from "./chunk-GWXZS7K5.mjs";
@@ -36,7 +36,7 @@ import {
 } from "./chunk-TUOO6IK3.mjs";
 import {
   logger
-} from "./chunk-Y3N5BFRJ.mjs";
+} from "./chunk-JSDV2NUN.mjs";
 import {
   AmbiguousRouteError,
   NonTerminalCatchAllRouteError

package/dist/{chunk-VAHBCI6X.mjs → chunk-BQWBHWEW.mjs}

@@ -7,10 +7,14 @@ import {
   notifyHistoryChange,
   readPageState,
   subscribeHistoryChange
-} from "./chunk-SN5VSO3Q.mjs";
+} from "./chunk-25T5VXOE.mjs";
 import {
   getFarmI18nClientState
 } from "./chunk-PTLXHRJZ.mjs";
+import {
+  hasFarmNavigationDelegates,
+  runFarmNavigationDelegates
+} from "./chunk-RSEAX5MW.mjs";
 import {
   _peekCurrentRequest
 } from "./chunk-VIXTAVEA.mjs";
@@ -56,6 +60,13 @@ function navigateViaRouter(href, basePath, replace, options = {}) {
     });
     return;
   }
+  if (hasFarmNavigationDelegates()) {
+    void writeHistoryUnlessDelegated(url, replace);
+    return;
+  }
+  writeHistory(url, replace);
+}
+function writeHistory(url, replace) {
   if (replace) {
     window.history.replaceState(null, "", url);
   } else {
@@ -63,6 +74,20 @@ function navigateViaRouter(href, basePath, replace, options = {}) {
   }
   notifyHistoryChange("url-search");
 }
+async function writeHistoryUnlessDelegated(url, replace) {
+  const target = new URL(url, window.location.href);
+  const from = window.location.pathname + window.location.search;
+  const to = target.pathname + target.search;
+  if (target.origin === window.location.origin && to !== from && await runFarmNavigationDelegates({
+    url: target.href,
+    from,
+    to,
+    action: replace ? "replace" : "push"
+  })) {
+    return;
+  }
+  writeHistory(url, replace);
+}
 function useRouter(options = {}) {
   const basePath = options.basePath === void 0 ? getFarmBasePath() : normalizeFarmBasePath(options.basePath);
   const routes = options.routes;

package/dist/{chunk-KJMWAUKE.mjs → chunk-C7GJDVN4.mjs}

@@ -1,7 +1,7 @@
 import {
   resolveFarmAPICanonicalPathname,
   resolveFarmAPIServerRoutePath
-} from "./chunk-LM2YOGDK.mjs";
+} from "./chunk-2I6PUKWJ.mjs";
 import {
   matchAPIRoute
 } from "./chunk-GUZC226X.mjs";

package/dist/{chunk-OYNNA4DD.cjs → chunk-CBKRS3M4.cjs}

@@ -15,12 +15,12 @@ var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
 var _chunkITV4QQL2cjs = require('./chunk-ITV4QQL2.cjs');
 
 
+var _chunk2OF5RPVUcjs = require('./chunk-2OF5RPVU.cjs');
 
 
-var _chunkLIFUPCXWcjs = require('./chunk-LIFUPCXW.cjs');
 
 
-var _chunkB5BBTPJQcjs = require('./chunk-B5BBTPJQ.cjs');
+var _chunkLIFUPCXWcjs = require('./chunk-LIFUPCXW.cjs');
 
 
 
@@ -28,7 +28,7 @@ var _chunkCA7DNRHOcjs = require('./chunk-CA7DNRHO.cjs');
 
 
 
-var _chunkIWFV5ZEDcjs = require('./chunk-IWFV5ZED.cjs');
+var _chunkPMJSG4JScjs = require('./chunk-PMJSG4JS.cjs');
 
 
 
@@ -160,23 +160,23 @@ function getAllowedAPIRouteMethods(route) {
   }
   return methods;
 }
-function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
   const directMatch = _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, pathname);
   if (directMatch) return directMatch;
-  const canonicalPathname = _chunkB5BBTPJQcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+  const canonicalPathname = _chunk2OF5RPVUcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
   return canonicalPathname === pathname ? null : _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, canonicalPathname);
 }
-function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
   const match = _chunkCA7DNRHOcjs.createStaticAPIRouteMatcher.call(void 0, routes);
   return (pathname) => {
     const directMatch = match(pathname);
     if (directMatch) return directMatch;
-    const canonicalPathname = _chunkB5BBTPJQcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+    const canonicalPathname = _chunk2OF5RPVUcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
     return canonicalPathname === pathname ? null : match(canonicalPathname);
   };
 }
-function isFarmAPIPathname(pathname, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
-  const basePath = _chunkIWFV5ZEDcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+function isFarmAPIPathname(pathname, serverBasePath = _chunkPMJSG4JScjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkPMJSG4JScjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
   return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
 }
 async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = _chunkLIFUPCXWcjs.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {