@oxyhq/bloom 0.67.0 → 0.68.0

package/src/__tests__/exports-map-contract.test.ts

@@ -0,0 +1,112 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * The `react-native` export condition must stay SPLIT into `types` + `default`.
+ *
+ * Metro compiles Bloom from source, so `default` points at `src/`. TypeScript
+ * honours `react-native` as well (expo/tsconfig.base sets
+ * `customConditions: ["react-native"]`), and if the condition were a bare
+ * string every native-targeted consumer would type-check Bloom's own `.tsx`
+ * files — pulling `react-dom` (from the web forks) and optional peers like
+ * `expo-haptics` / `@react-native-community/netinfo` into a program that never
+ * declared them. Measured against a consumer fixture with no
+ * `@types/react-dom`, the string form produces TS7016 on
+ * `src/portal/index.web.tsx`, TS2307 on `src/hooks/useHaptics.tsx` and
+ * `src/connection-status/index.tsx`, plus a nativewind TS2769 on
+ * `src/dialog/DialogHeader.tsx`. `skipLibCheck` cannot suppress any of them —
+ * a `.tsx` is not a declaration file.
+ *
+ * Splitting the condition means tsc asks for `types` and gets the built
+ * declarations, while Metro (which never requests `types`) still falls through
+ * to `default` and bundles source. Verified end to end with a real
+ * `expo export --platform ios`.
+ *
+ * `package.json#exports` is generated by `scripts/generate-platform-exports.mjs`
+ * — fix a failure there, never by hand-editing `package.json`.
+ */
+
+type ExportEntry = Record<string, unknown>;
+
+// Read rather than `import` the manifest: tsconfig pins `rootDir` to `src`, so
+// a JSON import from outside it would drag package.json into the build program.
+const PKG_PATH = join(__dirname, '..', '..', 'package.json');
+const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf8')) as {
+  exports: Record<string, ExportEntry | string>;
+};
+const exportsMap = pkg.exports;
+
+/** Non-subpath entries that are legitimately plain strings (static assets). */
+const STRING_ENTRIES = ['./design-tokens/theme.css', './package.json'];
+
+/**
+ * Vacuity floor. `SUBPATHS` in the generator is 86 entries today; a traversal
+ * bug that silently found none must not read as a pass.
+ */
+const MIN_SUBPATHS = 80;
+
+const subpathEntries = Object.entries(exportsMap).filter(
+  (entry): entry is [string, ExportEntry] => typeof entry[1] !== 'string',
+);
+
+describe('package.json#exports — react-native condition', () => {
+  it(`declares at least ${MIN_SUBPATHS} conditional subpaths`, () => {
+    expect(subpathEntries.length).toBeGreaterThanOrEqual(MIN_SUBPATHS);
+  });
+
+  it('exposes only the known static assets as string exports', () => {
+    const strings = Object.entries(exportsMap)
+      .filter(([, value]) => typeof value === 'string')
+      .map(([name]) => name);
+    expect(strings.sort()).toEqual([...STRING_ENTRIES].sort());
+  });
+
+  it('splits every react-native condition into types + default, in that order', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'];
+      if (typeof condition !== 'object' || condition === null) {
+        offenders.push(`${name}: react-native is ${JSON.stringify(condition)}, expected an object`);
+        continue;
+      }
+      const keys = Object.keys(condition);
+      if (keys.join(',') !== 'types,default') {
+        offenders.push(`${name}: react-native keys are [${keys.join(', ')}], expected [types, default]`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it('points react-native.default at src and react-native.types at the built declarations', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'];
+      if (typeof condition !== 'object' || condition === null) continue;
+      const { types, default: def } = condition as { types?: unknown; default?: unknown };
+
+      if (typeof def !== 'string' || !def.startsWith('./src/')) {
+        offenders.push(`${name}: react-native.default is ${JSON.stringify(def)}, expected a ./src/ path`);
+      }
+      if (typeof types !== 'string' || !types.startsWith('./lib/typescript/')) {
+        offenders.push(
+          `${name}: react-native.types is ${JSON.stringify(types)}, expected a ./lib/typescript/ path`,
+        );
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it('resolves react-native.types to the same declarations as the import condition', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'] as { types?: unknown } | undefined;
+      const importCondition = entry.import as { types?: unknown } | undefined;
+      if (condition?.types !== importCondition?.types) {
+        offenders.push(
+          `${name}: react-native.types (${String(condition?.types)}) !== import.types (${String(importCondition?.types)})`,
+        );
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+});

package/src/__tests__/toast-single-outlet-guard.test.tsx

@@ -0,0 +1,176 @@
+import React from 'react';
+import { render } from '@testing-library/react-native';
+
+import { ToastOutlet } from '../toast';
+import { resetSingleOutletGuardForTests } from '../toast/use-single-outlet-guard';
+
+/**
+ * THE DUPLICATE-OUTLET GUARD.
+ *
+ * `Toaster` subscribes to the module-level `toastStore`, so two mounted outlets
+ * render two copies of every row — measured 1→1, 2→2, 3→3 in Mention, and 1→2→1
+ * in Alia with the second outlet gated on a query param inside ONE bundle so both
+ * arms came from identical bytes. The copies overlap almost exactly (bare outlets
+ * take identical defaults and land pixel-identical), so nothing but a row count
+ * reveals it — hence a warning.
+ *
+ * Every test here mounts outlets and fires NO toast: a second outlet duplicates
+ * rows from the moment it mounts, so the warning must not wait for one. An idle
+ * `Toaster` renders null, which is why these need no theme provider or portal.
+ *
+ * The guard's module state outlives a render tree, so `beforeEach` resets it.
+ * Without that, the first test to latch the warning would leave every later test
+ * asserting "did not warn" against a guard that can no longer fire — green
+ * whatever the implementation does. That vacuity is the specific failure mode
+ * this suite is mutation-tested against; see the per-test mutation notes.
+ */
+describe('duplicate toast outlet guard', () => {
+  let warn: jest.SpyInstance<void, Parameters<typeof console.warn>>;
+
+  beforeEach(() => {
+    resetSingleOutletGuardForTests();
+    // `__mocks__/setup.ts` already silences console.warn; this re-spies so the
+    // calls are recorded and stay scoped to one test.
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+  });
+
+  const bloomWarnings = () =>
+    warn.mock.calls.filter(
+      (call) => typeof call[0] === 'string' && call[0].startsWith('[Bloom] Toaster:'),
+    );
+
+  /** Mutation: `mountedOutlets > 1` → `>= 1` warns here. */
+  it('stays silent for a single outlet', () => {
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  it('warns exactly once when a second outlet mounts', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  it('names the cause rather than just the symptom', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    // The consumer's tree is the only place this is fixable, and the overwhelming
+    // cause is an app mounting its own outlet beside OxyProvider's.
+    expect(bloomWarnings()[0]?.[0]).toContain('OxyProvider');
+  });
+
+  /** Mutation: drop the `hasWarned` latch and this warns twice. */
+  it('warns once, not once per extra outlet, when a third mounts', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  /**
+   * Mutation: drop the unmount decrement and the second mount reads a count of 2
+   * and warns. This is the counter-never-resets failure mode.
+   */
+  it('does not warn across an unmount / remount cycle', () => {
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  /** Three cycles: a counter that leaks by one per mount crosses the threshold. */
+  it('does not warn across repeated remounts', () => {
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  /**
+   * A route change or provider reshuffle that moves the outlet: React runs the
+   * outgoing tree's cleanups before the incoming tree's setups, so the count dips
+   * to 0 and back to 1 rather than reaching 2.
+   */
+  it('does not warn when one outlet replaces another', () => {
+    const first = render(<ToastOutlet />);
+    const second = render(<ToastOutlet />);
+    first.unmount();
+    second.unmount();
+    render(<ToastOutlet />);
+
+    // Two were genuinely co-mounted in the middle, so one warning is correct...
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  /**
+   * StrictMode is the dominant dev environment and it replays effects
+   * (setup → cleanup → setup), so without the latch a real duplicate would warn
+   * TWICE and a well-behaved single outlet could warn at all. Verified against
+   * this renderer: it does double-invoke, so neither case below is vacuous.
+   */
+  describe('under StrictMode double-invoked effects', () => {
+    it('still stays silent for a single outlet', () => {
+      render(
+        <React.StrictMode>
+          <ToastOutlet />
+        </React.StrictMode>,
+      );
+
+      expect(bloomWarnings()).toHaveLength(0);
+    });
+
+    it('still warns exactly once for a duplicate', () => {
+      render(
+        <React.StrictMode>
+          <ToastOutlet />
+          <ToastOutlet />
+        </React.StrictMode>,
+      );
+
+      expect(bloomWarnings()).toHaveLength(1);
+    });
+  });
+
+  /**
+   * Mutation: drop the `process.env.NODE_ENV` gate and this warns. Bundlers fold
+   * the branch statically, so production ships neither the counter nor the
+   * message — the guard must not change production behaviour at all.
+   */
+  it('does not warn in production', () => {
+    const previous = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+    try {
+      render(
+        <>
+          <ToastOutlet />
+          <ToastOutlet />
+        </>,
+      );
+    } finally {
+      process.env.NODE_ENV = previous;
+    }
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+});

package/src/toast/Toaster.tsx

@@ -30,6 +30,7 @@ import type {
   ToastProps,
 } from './types';
 import { useAppStateChange } from './use-app-state';
+import { useSingleOutletGuard } from './use-single-outlet-guard';
 
 const ALL_POSITIONS: ToastPosition[] = [
   'top-center',
@@ -79,6 +80,11 @@ export const Toaster: React.FC<ToasterProps> = ({
   style,
   styles: styleOverrides,
 }) => {
+  // Before any early return, and independent of whether a toast is up: a second
+  // outlet duplicates every row from the moment it mounts, not from the first
+  // toast, so the warning must not wait for one.
+  useSingleOutletGuard();
+
   const { toasts, shouldShowOverlay, toastHeights, isExpanded } =
     React.useSyncExternalStore(
       toastStore.subscribe,

package/src/toast/use-single-outlet-guard.ts

@@ -0,0 +1,72 @@
+/**
+ * Bloom-original — the dev-only guard against a SECOND toast outlet.
+ *
+ * Every `Toaster` subscribes to the ONE module-level `toastStore`, which has no
+ * notion of an owning outlet, so N mounted outlets each render the full row set:
+ * a toast appears N times. Nothing in the engine can dedupe that — the outlets
+ * are legitimate, independent subscribers — so the contract is "mount exactly
+ * one" and this is what enforces it.
+ *
+ * WHY A WARNING IS WORTH ITS WEIGHT: the copies are not visually separated, so
+ * the defect does not look like duplication. Two bare outlets take identical
+ * defaults and land pixel-identical; two outlets whose `offset` differs by a
+ * point land 1px apart. Only counting the rendered rows reveals it, which is not
+ * something anyone thinks to do — the reports this guard comes from all read as
+ * "the toast looks wrong", never as "there are two of them". Stacking is on by
+ * default, so a duplicate outlet now doubles the rows INSIDE a stack.
+ *
+ * The counter is decremented on unmount, so a remount, a route change that moves
+ * the outlet, Fast Refresh and React's StrictMode double-invoke (setup, cleanup,
+ * setup) all pass through a count of 1 and stay silent. The latch keeps the
+ * warning to exactly one per module lifetime rather than one per extra outlet,
+ * and — because StrictMode replays the setups — one per app, not two.
+ *
+ * Gated on `process.env.NODE_ENV`, the same mechanism as
+ * `content-panel/nesting-context.ts`: Metro and Vite/Rolldown both fold it
+ * statically, so production keeps the counter, the branch and the message out of
+ * the bundle entirely. Deliberately NOT `__DEV__`, which is a Metro global that a
+ * plain web bundler does not define. It only ever warns — a duplicate outlet
+ * renders a redundant toast, it does not break the app, so it must never throw.
+ */
+import * as React from 'react';
+
+let mountedOutlets = 0;
+let hasWarned = false;
+
+export function useSingleOutletGuard(): void {
+  React.useEffect(() => {
+    if (process.env.NODE_ENV === 'production') {
+      return;
+    }
+
+    mountedOutlets += 1;
+    if (mountedOutlets > 1 && !hasWarned) {
+      hasWarned = true;
+      // Internal Bloom diagnostic: the consumer's tree is the only place this
+      // can be fixed, so it names the usual cause rather than just the symptom.
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[Bloom] Toaster: ${mountedOutlets} toast outlets are mounted, so every ` +
+          'toast renders once per outlet. The copies overlap almost exactly, so ' +
+          'this reads as a rendering glitch rather than as duplicate rows. Mount ' +
+          "exactly one: @oxyhq/services' OxyProvider already renders a " +
+          'ToastOutlet, so an app that uses it must not render its own.',
+      );
+    }
+
+    return () => {
+      mountedOutlets -= 1;
+    };
+  }, []);
+}
+
+/**
+ * Test-only reset: both the counter and the one-shot latch are module state that
+ * outlives a render tree, so without this the first suite to mount two outlets
+ * would latch the warning and leave every later suite asserting against a guard
+ * that can no longer fire — passing whatever the implementation did.
+ */
+export function resetSingleOutletGuardForTests(): void {
+  mountedOutlets = 0;
+  hasWarned = false;
+}