@multiplatform.one/forms 8.6.0 → 9.0.1

package/src/fields/ColorPicker/expoLinearGradientLoader.ts

@@ -0,0 +1,44 @@
+import { hasExpoNativeModule } from "../../shared/expoNativeModule";
+
+export type ExpoLinearGradientModule = typeof import("expo-linear-gradient");
+
+export interface ExpoLinearGradientSources {
+  hasNativeModule(name: string): boolean;
+  linearGradient(): unknown;
+}
+
+const appSources: ExpoLinearGradientSources = {
+  hasNativeModule: hasExpoNativeModule,
+  linearGradient: () => {
+    try {
+      return require("expo-linear-gradient");
+    } catch {
+      return null;
+    }
+  },
+};
+
+/**
+ * `expo-linear-gradient` is an optional peer: the host app installs it at the
+ * version its Expo SDK ships. Returns null when the package is not installed
+ * or the binary lacks the native view, and the ColorPicker then draws its
+ * gradients with react-native-svg (FZ-10637).
+ */
+export function resolveExpoLinearGradient(
+  sources: ExpoLinearGradientSources = appSources,
+): ExpoLinearGradientModule | null {
+  try {
+    if (!sources.hasNativeModule("ExpoLinearGradient")) return null;
+    const mod = sources.linearGradient() as Partial<ExpoLinearGradientModule> | null | undefined;
+    return mod?.LinearGradient ? (mod as ExpoLinearGradientModule) : null;
+  } catch {
+    return null;
+  }
+}
+
+let cached: ExpoLinearGradientModule | null | undefined;
+
+export function loadExpoLinearGradient(): ExpoLinearGradientModule | null {
+  if (cached === undefined) cached = resolveExpoLinearGradient();
+  return cached;
+}

package/src/fields/ColorPicker/gradients.native.tsx

@@ -1,4 +1,4 @@
-import { LinearGradient } from "expo-linear-gradient";
+import { LinearGradient } from "./nativeLinearGradient";
 import { StyleSheet, View as RNView } from "react-native";
 
 /**

package/src/fields/ColorPicker/nativeLinearGradient.spec.tsx

@@ -0,0 +1,109 @@
+import { render } from "@testing-library/react";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { resolveExpoLinearGradient } from "./expoLinearGradientLoader";
+import { gradientStop, pickLinearGradient, SvgLinearGradient } from "./nativeLinearGradient";
+
+vi.mock("./expoLinearGradientLoader", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./expoLinearGradientLoader")>()),
+  loadExpoLinearGradient: () => null,
+}));
+
+const ExpoGradient = () => null;
+
+// FZ-10637. expo-linear-gradient is an optional peer the host installs at its
+// own SDK version, so the ColorPicker has to draw without it.
+describe("resolveExpoLinearGradient", () => {
+  it("returns the module when the package and the native view are both present", () => {
+    const mod = { LinearGradient: ExpoGradient };
+    expect(
+      resolveExpoLinearGradient({ hasNativeModule: () => true, linearGradient: () => mod }),
+    ).toBe(mod);
+  });
+
+  it("returns null when the app does not install expo-linear-gradient", () => {
+    const missing = () => {
+      throw new Error("Cannot find module 'expo-linear-gradient'");
+    };
+    expect(
+      resolveExpoLinearGradient({ hasNativeModule: () => true, linearGradient: missing }),
+    ).toBeNull();
+    expect(
+      resolveExpoLinearGradient({ hasNativeModule: () => true, linearGradient: () => null }),
+    ).toBeNull();
+  });
+
+  it("returns null without loading the package when the binary lacks the native view", () => {
+    const load = vi.fn(() => ({ LinearGradient: ExpoGradient }));
+    expect(
+      resolveExpoLinearGradient({ hasNativeModule: () => false, linearGradient: load }),
+    ).toBeNull();
+    expect(load).not.toHaveBeenCalled();
+  });
+
+  it("loads expo-linear-gradient from inside a try block, never a static import, so Metro bundles without it", () => {
+    const loader = readFileSync(join(__dirname, "expoLinearGradientLoader.ts"), "utf8");
+    expect(loader).toMatch(/try \{\s*return require\("expo-linear-gradient"\);/);
+    const gradients = readFileSync(join(__dirname, "gradients.native.tsx"), "utf8");
+    expect(gradients).not.toMatch(/from "expo-linear-gradient"/);
+  });
+});
+
+describe("the ColorPicker gradient without expo-linear-gradient", () => {
+  it("uses expo-linear-gradient when the app has it and react-native-svg when it does not", () => {
+    expect(pickLinearGradient({ LinearGradient: ExpoGradient })).toBe(ExpoGradient);
+    expect(pickLinearGradient(null)).toBe(SvgLinearGradient);
+  });
+
+  it("draws the same stops and axis with react-native-svg", () => {
+    const { container } = render(
+      <SvgLinearGradient
+        colors={["#FF0000", "#00FF00", "#0000FF"]}
+        start={{ x: 0, y: 0.5 }}
+        end={{ x: 1, y: 0.5 }}
+      />,
+    );
+    const gradient = container.querySelector("linearGradient");
+    expect(gradient?.getAttribute("x1")).toBe("0");
+    expect(gradient?.getAttribute("y1")).toBe("0.5");
+    expect(gradient?.getAttribute("x2")).toBe("1");
+    expect(gradient?.getAttribute("y2")).toBe("0.5");
+    const stops = [...container.querySelectorAll("stop")];
+    expect(stops.map((stop) => stop.getAttribute("offset"))).toEqual(["0", "0.5", "1"]);
+    expect(stops.map((stop) => stop.getAttribute("stop-color"))).toEqual([
+      "#FF0000",
+      "#00FF00",
+      "#0000FF",
+    ]);
+    const rect = container.querySelector("rect");
+    expect(rect?.getAttribute("fill")).toBe(`url(#${gradient?.getAttribute("id")})`);
+  });
+
+  it("keeps explicit stop locations", () => {
+    const { container } = render(
+      <SvgLinearGradient colors={["#FF0000", "#FFFF00", "#FF0000"]} locations={[0, 0.17, 1]} />,
+    );
+    expect(
+      [...container.querySelectorAll("stop")].map((stop) => stop.getAttribute("offset")),
+    ).toEqual(["0", "0.17", "1"]);
+  });
+
+  it("splits an rgba stop into a colour and an opacity, which is how svg takes alpha", () => {
+    expect(gradientStop("rgba(0,0,0,0)")).toEqual({ stopColor: "rgb(0,0,0)", stopOpacity: 0 });
+    expect(gradientStop("#00FF00")).toEqual({ stopColor: "#00FF00", stopOpacity: 1 });
+  });
+
+  it("the native gradient backgrounds render through the fallback", async () => {
+    const { AlphaBackground, HueBackground, SaturationBackground } =
+      await import("./gradients.native");
+    const { container } = render(
+      <>
+        <SaturationBackground hueColor="#FF0000" width={100} height={100} />
+        <HueBackground width={100} height={14} />
+        <AlphaBackground hex="#00FF00" width={100} height={14} />
+      </>,
+    );
+    expect(container.querySelectorAll("linearGradient").length).toBe(4);
+  });
+});

package/src/fields/ColorPicker/nativeLinearGradient.tsx

@@ -0,0 +1,84 @@
+import type { ComponentType } from "react";
+import type { StyleProp, ViewStyle } from "react-native";
+import { Defs, LinearGradient as SvgGradient, Rect, Stop, Svg } from "react-native-svg";
+import { loadExpoLinearGradient } from "./expoLinearGradientLoader";
+
+interface GradientPoint {
+  x: number;
+  y: number;
+}
+
+export interface LinearGradientProps {
+  colors: readonly string[];
+  locations?: readonly number[];
+  start?: GradientPoint;
+  end?: GradientPoint;
+  style?: StyleProp<ViewStyle>;
+  pointerEvents?: "none" | "auto" | "box-none" | "box-only";
+  testID?: string;
+}
+
+const rgbaPattern = /^rgba\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)$/;
+
+/**
+ * react-native-svg takes a stop's alpha as `stopOpacity`, not inside the
+ * colour, so an rgba() stop is split into the two.
+ */
+export function gradientStop(color: string): { stopColor: string; stopOpacity: number } {
+  const rgba = rgbaPattern.exec(color);
+  if (!rgba) return { stopColor: color, stopOpacity: 1 };
+  return { stopColor: `rgb(${rgba[1]},${rgba[2]},${rgba[3]})`, stopOpacity: Number(rgba[4]) };
+}
+
+let gradientIds = 0;
+
+/**
+ * The same fill as expo-linear-gradient, drawn with react-native-svg, which
+ * every native MPO host already carries. `start` and `end` are fractions of
+ * the box, as in expo-linear-gradient, and stops without `locations` are
+ * spread evenly.
+ */
+export function SvgLinearGradient({
+  colors,
+  locations,
+  start = { x: 0.5, y: 0 },
+  end = { x: 0.5, y: 1 },
+  style,
+  pointerEvents,
+  testID,
+}: LinearGradientProps) {
+  const id = `mpo-linear-gradient-${(gradientIds += 1)}`;
+  const last = Math.max(colors.length - 1, 1);
+  return (
+    <Svg
+      style={style}
+      pointerEvents={pointerEvents}
+      testID={testID ?? "svg-linear-gradient"}
+      preserveAspectRatio="none"
+    >
+      <Defs>
+        <SvgGradient id={id} x1={start.x} y1={start.y} x2={end.x} y2={end.y}>
+          {colors.map((color, index) => (
+            <Stop
+              key={`${index}-${color}`}
+              offset={locations?.[index] ?? index / last}
+              {...gradientStop(color)}
+            />
+          ))}
+        </SvgGradient>
+      </Defs>
+      <Rect x="0" y="0" width="100%" height="100%" fill={`url(#${id})`} />
+    </Svg>
+  );
+}
+
+export function pickLinearGradient(
+  expo: { LinearGradient?: unknown } | null,
+): ComponentType<LinearGradientProps> {
+  return (
+    (expo?.LinearGradient as ComponentType<LinearGradientProps> | undefined) ?? SvgLinearGradient
+  );
+}
+
+export const LinearGradient: ComponentType<LinearGradientProps> =
+  pickLinearGradient(loadExpoLinearGradient());

package/src/metroPreset.spec.ts

@@ -0,0 +1,132 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+const packageDir = join(import.meta.dirname, "..");
+const requireFromPackage = createRequire(join(packageDir, "package.json"));
+const { phosphorIconBase, withMultiplatformOne } = requireFromPackage("./metro/index.js") as {
+  phosphorIconBase: string;
+  withMultiplatformOne: <T extends object>(config: T, options?: { router?: string }) => T;
+};
+const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")) as {
+  exports: Record<string, unknown>;
+  files: string[];
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+};
+
+type Resolution = { type: string; filePath: string };
+type ResolveRequest = (
+  context: MetroContext,
+  moduleName: string,
+  platform: string | null,
+) => Resolution;
+interface MetroContext {
+  originModulePath: string;
+  resolveRequest: ResolveRequest;
+}
+interface MetroConfig {
+  resolver: { resolveRequest?: ResolveRequest; sourceExts?: string[] };
+}
+
+const phosphorOrigin = "/app/node_modules/@phosphor-icons/react/dist/csr/Check.es.js";
+const routerOrigin = "/app/node_modules/@multiplatform.one/router/dist/esm/router/index.mjs";
+
+function context(originModulePath: string): MetroContext {
+  return {
+    originModulePath,
+    resolveRequest: vi.fn((_context, moduleName) => ({
+      type: "sourceFile",
+      filePath: `/stock/${moduleName}`,
+    })),
+  };
+}
+
+function resolverOf(config: MetroConfig): ResolveRequest {
+  const resolveRequest = config.resolver.resolveRequest;
+  if (!resolveRequest) throw new Error("the preset set no resolveRequest");
+  return resolveRequest;
+}
+
+// FZ-10629, FZ-10634. The host bindings ship with forms, so an Expo app needs
+// no shim of its own.
+describe("@multiplatform.one/forms/metro", () => {
+  it("ships in the package: the ./metro export, the files entry and the shim", () => {
+    expect(manifest.exports["./metro"]).toBe("./metro/index.js");
+    expect(manifest.files).toContain("metro");
+    expect(existsSync(phosphorIconBase)).toBe(true);
+    expect(phosphorIconBase).toBe(join(packageDir, "metro", "phosphor-icon-base.js"));
+  });
+
+  it("the shim loads only packages forms declares, so it resolves from forms in any install layout", () => {
+    const declared = { ...manifest.dependencies, ...manifest.peerDependencies };
+    const required = [...readFileSync(phosphorIconBase, "utf8").matchAll(/require\("([^"]+)"\)/g)];
+    expect(required.map((match) => match[1]).sort()).toEqual([
+      "@tamagui/web",
+      "react",
+      "react-native-svg",
+    ]);
+    for (const [, name] of required) expect(declared).toHaveProperty(name);
+  });
+
+  it("swaps phosphor's IconBase for the react-native-svg one on a phone", () => {
+    const resolve = resolverOf(withMultiplatformOne<MetroConfig>({ resolver: {} }));
+    for (const platform of ["ios", "android"]) {
+      expect(resolve(context(phosphorOrigin), "../lib/IconBase.es.js", platform)).toEqual({
+        type: "sourceFile",
+        filePath: phosphorIconBase,
+      });
+    }
+  });
+
+  it("leaves phosphor's own IconBase on web, and every other request alone", () => {
+    const resolve = resolverOf(withMultiplatformOne<MetroConfig>({ resolver: {} }));
+    expect(resolve(context(phosphorOrigin), "../lib/IconBase.es.js", "web").filePath).toBe(
+      "/stock/../lib/IconBase.es.js",
+    );
+    expect(resolve(context("/app/src/IconBase.tsx"), "./IconBase", "ios").filePath).toBe(
+      "/stock/./IconBase",
+    );
+    expect(resolve(context(phosphorOrigin), "react", "ios").filePath).toBe("/stock/react");
+  });
+
+  it("chains the resolveRequest the app already set and keeps the rest of its config", () => {
+    const appResolver = vi.fn<ResolveRequest>(() => ({ type: "sourceFile", filePath: "/app/own" }));
+    const config = withMultiplatformOne<MetroConfig>({
+      resolver: { resolveRequest: appResolver, sourceExts: ["tsx"] },
+    });
+    expect(config.resolver.sourceExts).toEqual(["tsx"]);
+    const ctx = context("/app/src/index.tsx");
+    expect(resolverOf(config)(ctx, "./x", "ios").filePath).toBe("/app/own");
+    expect(appResolver).toHaveBeenCalledWith(ctx, "./x", "ios");
+    expect(ctx.resolveRequest).not.toHaveBeenCalled();
+  });
+
+  it("applies once", () => {
+    const once = withMultiplatformOne<MetroConfig>({ resolver: {} });
+    expect(withMultiplatformOne(once)).toBe(once);
+  });
+
+  it("with router: expo-router, a web bundle resolves the router's one to the Expo Router binding", () => {
+    const resolve = resolverOf(
+      withMultiplatformOne<MetroConfig>({ resolver: {} }, { router: "expo-router" }),
+    );
+    expect(resolve(context(routerOrigin), "one", "web").filePath).toBe(
+      "/stock/@multiplatform.one/router/expo-router",
+    );
+    expect(resolve(context(routerOrigin), "one", "ios").filePath).toBe("/stock/one");
+    expect(resolve(context("/app/src/screen.tsx"), "one", "web").filePath).toBe("/stock/one");
+  });
+
+  it("leaves one alone on web without the option, as a One app needs", () => {
+    const resolve = resolverOf(withMultiplatformOne<MetroConfig>({ resolver: {} }));
+    expect(resolve(context(routerOrigin), "one", "web").filePath).toBe("/stock/one");
+  });
+
+  it("refuses a router it has no binding for", () => {
+    expect(() => withMultiplatformOne({ resolver: {} }, { router: "react-navigation" })).toThrow(
+      /unknown router "react-navigation"\. Known: expo-router/,
+    );
+  });
+});

package/src/shared/expoNativeModule.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether this binary carries an Expo native module (LC-19 preflight). An OTA
+ * can ship a package's JS to a binary built without it, and requiring such a
+ * package runs a module factory that throws, which Metro reports as a fatal
+ * LogBox in dev even when the caller catches it. Asking expo-modules-core
+ * first keeps that factory from running. A host without expo-modules-core
+ * answers true, so the caller's own guarded require decides.
+ */
+export function hasExpoNativeModule(name: string): boolean {
+  try {
+    const core = require("expo-modules-core") as {
+      requireOptionalNativeModule?: (name: string) => unknown;
+    };
+    if (!core.requireOptionalNativeModule) return true;
+    const nativeModule = core.requireOptionalNativeModule(name);
+    return nativeModule !== null && nativeModule !== undefined;
+  } catch {
+    return true;
+  }
+}

package/src/shared/i18n.ts

@@ -1,14 +1,12 @@
 import * as ReactI18next from "react-i18next";
 
 /**
- * react-i18next is an OPTIONAL peer: apps that never render the i18n-using
- * fields may omit it entirely and tree-shake them away. When it is missing,
- * the bundler substitutes an empty optional-peer-dep stub for the package —
- * direct named imports would then surface as cryptic MISSING_EXPORT failures
- * far from the cause. Route every usage through this namespace access
- * instead, so omission stays warning-free for tree-shakers and fails loudly —
- * naming the package and the fix — the moment an i18n-using field actually
- * renders.
+ * react-i18next is a required peer. When an app leaves it out anyway, the
+ * bundler can substitute an empty stub for the package, and direct named
+ * imports would then surface as cryptic MISSING_EXPORT failures far from the
+ * cause. Route every usage through this namespace access instead, so the
+ * omission fails loudly, naming the package and the fix, the moment an
+ * i18n-using field actually renders.
  */
 export const useTranslation = ((...args: unknown[]) => {
   const impl = (ReactI18next as { useTranslation?: (...args: unknown[]) => unknown })
@@ -17,8 +15,7 @@ export const useTranslation = ((...args: unknown[]) => {
     throw new Error(
       "[@multiplatform.one/forms] react-i18next is not installed, but a component that " +
         "translates its built-in copy was rendered. Add react-i18next and i18next to your " +
-        "app's dependencies (they are optional peers so apps that never render these " +
-        "components can omit them).",
+        "app's dependencies.",
     );
   }
   return impl(...args);

package/src/shared/i18nPeers.spec.ts

@@ -0,0 +1,49 @@
+import { renderHook } from "@testing-library/react";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const manifest = JSON.parse(
+  readFileSync(join(import.meta.dirname, "..", "..", "package.json"), "utf8"),
+) as {
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+};
+
+// FZ-10637, FZ-1854. forms translates its built-in copy through react-i18next on
+// every render, so the i18n pair is a required peer. Listed as optional it
+// left a host to find out from a failed bundle.
+describe("the i18n peers forms translates through", () => {
+  afterEach(() => {
+    vi.doUnmock("react-i18next");
+    vi.resetModules();
+  });
+
+  it("declares i18next and react-i18next as required peers, never as dependencies", () => {
+    for (const name of ["i18next", "react-i18next"]) {
+      expect(manifest.dependencies ?? {}).not.toHaveProperty(name);
+      expect(manifest.peerDependencies).toHaveProperty(name);
+      expect(manifest.peerDependenciesMeta?.[name]?.optional).not.toBe(true);
+    }
+  });
+
+  it("accepts the i18next majors react-i18next 16 and 17 run on", () => {
+    expect(manifest.peerDependencies?.i18next).toBe(">=25.0.0");
+    expect(manifest.peerDependencies?.["react-i18next"]).toBe(">=14");
+  });
+
+  it("translates built-in copy with the host's react-i18next", async () => {
+    const { useTranslation } = await import("./i18n");
+    const { result } = renderHook(() => useTranslation());
+    expect(result.current.t("Close")).toBe("Close");
+  });
+
+  it("names the packages to install when an app leaves them out", async () => {
+    vi.doMock("react-i18next", () => ({ useTranslation: undefined }));
+    const { useTranslation } = await import("./i18n");
+    expect(() => useTranslation()).toThrow(
+      /react-i18next is not installed.*Add react-i18next and i18next to your app's dependencies\./s,
+    );
+  });
+});

package/types/fields/Barcode/BarcodeScanner.native.d.ts

@@ -8,18 +8,5 @@ import type { BarcodeScannerProps, CameraPreflightResult } from "./scannerTypes"
  * stable scanner surface, never as a present-fail-dismiss flash.
  */
 export declare function preflightCamera(): Promise<CameraPreflightResult>;
-/**
- * Native barcode scanner — `expo-camera`'s `CameraView` with built-in barcode
- * scanning (bundled in Expo Go SDK 55). Replaces the web `html5-qrcode`, so no
- * `getUserMedia` / DOM browser code reaches the Hermes bundle.
- *
- * LC-19 CAPABILITY-PREFLIGHT: only mounts after a passing `preflightCamera()`.
- * While the permission prompt is pending the surface shows a stable
- * "Requesting camera…" state; a denial renders the error INSIDE the still-open
- * surface with Retry + Close — it never self-dismisses on error.
- *
- * Note: the iOS simulator has no camera, so live scanning can only be verified
- * on a physical device; in the simulator the camera surface renders empty.
- */
-export declare function BarcodeScanner({ active, onScan, onError, onClose, knobProps, formats, }: BarcodeScannerProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function BarcodeScanner(props: BarcodeScannerProps): import("react/jsx-runtime").JSX.Element | null;
 //# sourceMappingURL=BarcodeScanner.native.d.ts.map

package/types/fields/Barcode/BarcodeScanner.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BarcodeScanner.native.d.ts","sourceRoot":"","sources":["../../../src/fields/Barcode/BarcodeScanner.native.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAGjF;;;;;;;GAOG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAetE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,OAAO,GACR,EAAE,mBAAmB,kDAgFrB"}
+{"version":3,"file":"BarcodeScanner.native.d.ts","sourceRoot":"","sources":["../../../src/fields/Barcode/BarcodeScanner.native.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAGjF;;;;;;;GAOG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAiBtE;AA6ID,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,kDAIxD"}

package/types/fields/Barcode/expoCameraLoader.d.ts

@@ -0,0 +1,15 @@
+export type ExpoCameraModule = typeof import("expo-camera");
+export interface ExpoCameraSources {
+    hasNativeModule(name: string): boolean;
+    camera(): unknown;
+}
+/**
+ * `expo-camera` is an optional peer: the host app installs it at the version
+ * its Expo SDK ships, and an app that never scans a barcode leaves it out.
+ * Returns null when the package is not installed or the binary lacks the
+ * native module, and the Barcode field then reports the camera as unavailable
+ * instead of presenting the scanner (FZ-10637).
+ */
+export declare function resolveExpoCamera(sources?: ExpoCameraSources): ExpoCameraModule | null;
+export declare function loadExpoCamera(): ExpoCameraModule | null;
+//# sourceMappingURL=expoCameraLoader.d.ts.map

package/types/fields/Barcode/expoCameraLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expoCameraLoader.d.ts","sourceRoot":"","sources":["../../../src/fields/Barcode/expoCameraLoader.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG,cAAc,aAAa,CAAC,CAAC;AAE5D,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,MAAM,IAAI,OAAO,CAAC;CACnB;AAaD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,iBAA8B,GACtC,gBAAgB,GAAG,IAAI,CASzB;AAID,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,IAAI,CAGxD"}

package/types/fields/ColorPicker/expoLinearGradientLoader.d.ts

@@ -0,0 +1,14 @@
+export type ExpoLinearGradientModule = typeof import("expo-linear-gradient");
+export interface ExpoLinearGradientSources {
+    hasNativeModule(name: string): boolean;
+    linearGradient(): unknown;
+}
+/**
+ * `expo-linear-gradient` is an optional peer: the host app installs it at the
+ * version its Expo SDK ships. Returns null when the package is not installed
+ * or the binary lacks the native view, and the ColorPicker then draws its
+ * gradients with react-native-svg (FZ-10637).
+ */
+export declare function resolveExpoLinearGradient(sources?: ExpoLinearGradientSources): ExpoLinearGradientModule | null;
+export declare function loadExpoLinearGradient(): ExpoLinearGradientModule | null;
+//# sourceMappingURL=expoLinearGradientLoader.d.ts.map

package/types/fields/ColorPicker/expoLinearGradientLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expoLinearGradientLoader.d.ts","sourceRoot":"","sources":["../../../src/fields/ColorPicker/expoLinearGradientLoader.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,wBAAwB,GAAG,cAAc,sBAAsB,CAAC,CAAC;AAE7E,MAAM,WAAW,yBAAyB;IACxC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,cAAc,IAAI,OAAO,CAAC;CAC3B;AAaD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,yBAAsC,GAC9C,wBAAwB,GAAG,IAAI,CAQjC;AAID,wBAAgB,sBAAsB,IAAI,wBAAwB,GAAG,IAAI,CAGxE"}

package/types/fields/ColorPicker/nativeLinearGradient.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentType } from "react";
+import type { StyleProp, ViewStyle } from "react-native";
+interface GradientPoint {
+    x: number;
+    y: number;
+}
+export interface LinearGradientProps {
+    colors: readonly string[];
+    locations?: readonly number[];
+    start?: GradientPoint;
+    end?: GradientPoint;
+    style?: StyleProp<ViewStyle>;
+    pointerEvents?: "none" | "auto" | "box-none" | "box-only";
+    testID?: string;
+}
+/**
+ * react-native-svg takes a stop's alpha as `stopOpacity`, not inside the
+ * colour, so an rgba() stop is split into the two.
+ */
+export declare function gradientStop(color: string): {
+    stopColor: string;
+    stopOpacity: number;
+};
+/**
+ * The same fill as expo-linear-gradient, drawn with react-native-svg, which
+ * every native MPO host already carries. `start` and `end` are fractions of
+ * the box, as in expo-linear-gradient, and stops without `locations` are
+ * spread evenly.
+ */
+export declare function SvgLinearGradient({ colors, locations, start, end, style, pointerEvents, testID, }: LinearGradientProps): import("react/jsx-runtime").JSX.Element;
+export declare function pickLinearGradient(expo: {
+    LinearGradient?: unknown;
+} | null): ComponentType<LinearGradientProps>;
+export declare const LinearGradient: ComponentType<LinearGradientProps>;
+export {};
+//# sourceMappingURL=nativeLinearGradient.d.ts.map

package/types/fields/ColorPicker/nativeLinearGradient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeLinearGradient.d.ts","sourceRoot":"","sources":["../../../src/fields/ColorPicker/nativeLinearGradient.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzD,UAAU,aAAa;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,GAAG,CAAC,EAAE,aAAa,CAAC;IACpB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAItF;AAID;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,SAAS,EACT,KAAwB,EACxB,GAAsB,EACtB,KAAK,EACL,aAAa,EACb,MAAM,GACP,EAAE,mBAAmB,2CAwBrB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GACxC,aAAa,CAAC,mBAAmB,CAAC,CAIpC;AAED,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,mBAAmB,CAChB,CAAC"}

package/types/shared/expoNativeModule.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether this binary carries an Expo native module (LC-19 preflight). An OTA
+ * can ship a package's JS to a binary built without it, and requiring such a
+ * package runs a module factory that throws, which Metro reports as a fatal
+ * LogBox in dev even when the caller catches it. Asking expo-modules-core
+ * first keeps that factory from running. A host without expo-modules-core
+ * answers true, so the caller's own guarded require decides.
+ */
+export declare function hasExpoNativeModule(name: string): boolean;
+//# sourceMappingURL=expoNativeModule.d.ts.map

package/types/shared/expoNativeModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expoNativeModule.d.ts","sourceRoot":"","sources":["../../src/shared/expoNativeModule.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAWzD"}

package/types/shared/i18n.d.ts

@@ -1,13 +1,11 @@
 import * as ReactI18next from "react-i18next";
 /**
- * react-i18next is an OPTIONAL peer: apps that never render the i18n-using
- * fields may omit it entirely and tree-shake them away. When it is missing,
- * the bundler substitutes an empty optional-peer-dep stub for the package —
- * direct named imports would then surface as cryptic MISSING_EXPORT failures
- * far from the cause. Route every usage through this namespace access
- * instead, so omission stays warning-free for tree-shakers and fails loudly —
- * naming the package and the fix — the moment an i18n-using field actually
- * renders.
+ * react-i18next is a required peer. When an app leaves it out anyway, the
+ * bundler can substitute an empty stub for the package, and direct named
+ * imports would then surface as cryptic MISSING_EXPORT failures far from the
+ * cause. Route every usage through this namespace access instead, so the
+ * omission fails loudly, naming the package and the fix, the moment an
+ * i18n-using field actually renders.
  */
 export declare const useTranslation: typeof ReactI18next.useTranslation;
 //# sourceMappingURL=i18n.d.ts.map

package/types/shared/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/shared/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAE9C;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAYrB,OAAO,YAAY,CAAC,cAAc,CAAC"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/shared/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAWrB,OAAO,YAAY,CAAC,cAAc,CAAC"}