@oxyhq/bloom 0.67.0 → 0.69.0

package/src/__tests__/color-scope-nativewind.test.ts

@@ -0,0 +1,135 @@
+import * as ReactNative from 'react-native';
+
+/**
+ * THE OPTIONAL-PEER BOUNDARY for `nativewind`.
+ *
+ * `BloomColorScope` publishes a preset's CSS vars into the subtree through the
+ * CONSUMER's nativewind — its version decides which mechanism exists
+ * (`VariableContextProvider` under NativeWind 5, `vars()` before it), so the
+ * module has to be loaded from the app, not from Bloom's own react-native-css.
+ * Loaded through a variable specifier it was never loaded at all under Metro,
+ * and a scope that does not scope is invisible: the subtree keeps rendering,
+ * just in the app-wide palette.
+ *
+ * `optional-peer-imports.test.ts` guards the static shape (literal specifier,
+ * inside a try). This runs it: the module is used when present, the scope
+ * degrades rather than crashes when absent, and it says so once.
+ */
+
+const NATIVEWIND = 'nativewind';
+
+type StyleBuilder = typeof import('../theme/color-scope/style-builder');
+
+/**
+ * Load `style-builder` against a given nativewind factory.
+ *
+ * `{ virtual: true }` IS correct here, unlike in the netinfo suite: nativewind
+ * is not installed in this repo at all, so without it `doMock` throws while
+ * resolving the name it is being asked to stand in for. The trade is that a
+ * virtual mock is keyed by the bare specifier — which is exactly what the
+ * loader requires, so the two agree.
+ */
+function loadStyleBuilder(factory?: () => unknown): StyleBuilder {
+  let mod: StyleBuilder | undefined;
+
+  jest.isolateModules(() => {
+    if (factory) jest.doMock(NATIVEWIND, factory, { virtual: true });
+    // A second copy of react-native carries a second `Platform`, so the OS each
+    // case sets would land on an object the module under test never reads.
+    jest.doMock('react-native', () => ReactNative);
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    mod = require('../theme/color-scope/style-builder') as StyleBuilder;
+  });
+
+  if (!mod) throw new Error('module isolation did not run');
+  return mod;
+}
+
+const originalOS = ReactNative.Platform.OS;
+
+describe('BloomColorScope nativewind loading', () => {
+  let warn: jest.SpyInstance<void, Parameters<typeof console.warn>>;
+
+  beforeEach(() => {
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    ReactNative.Platform.OS = 'ios';
+  });
+
+  afterEach(() => {
+    ReactNative.Platform.OS = originalOS;
+    warn.mockRestore();
+    jest.resetModules();
+    jest.dontMock(NATIVEWIND);
+  });
+
+  it('uses the consumer’s VariableContextProvider when nativewind provides one', () => {
+    const VariableContextProvider = () => null;
+    const vars = jest.fn(() => ({ marker: true }));
+    const builder = loadStyleBuilder(() => ({ vars, VariableContextProvider }));
+
+    expect(builder.getVariableContextProvider()).toBe(VariableContextProvider);
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('passes the resolved scope vars through the consumer’s vars()', () => {
+    const vars = jest.fn((_record: Record<string, string>) => ({ marker: true }));
+    const builder = loadStyleBuilder(() => ({ vars }));
+
+    expect(builder.buildNativePresetStyle('blue', 'dark')).toEqual({ marker: true });
+    // Not just "called": the record it forwards must be the canonical tokens
+    // plus the Tailwind `--color-*` aliases, which is the whole payload of a
+    // scope. A `vars({})` would otherwise read as a working scope.
+    const [record] = vars.mock.calls[0] ?? [{}];
+    expect(record['--primary']).toMatch(/^rgb/);
+    expect(record['--color-primary']).toBe(record['--primary']);
+  });
+
+  it('degrades to no scope, and says so once, when the peer is absent', () => {
+    const builder = loadStyleBuilder(() => {
+      throw new Error(`Cannot find module '${NATIVEWIND}'`);
+    });
+
+    expect(builder.getVariableContextProvider()).toBeNull();
+    expect(builder.buildNativePresetStyle('blue', 'light')).toBeUndefined();
+
+    expect(warn).toHaveBeenCalledTimes(1);
+    const [message] = warn.mock.calls[0] as [string];
+    expect(message).toContain('BloomColorScope');
+    expect(message).toContain(NATIVEWIND);
+    expect(message).toContain('expo install');
+    expect(message).toContain('Cannot find module');
+  });
+
+  it('names the NativeWind 5 API when nativewind resolves without it', () => {
+    const builder = loadStyleBuilder(() => ({ vars: jest.fn(() => ({})) }));
+
+    expect(builder.getVariableContextProvider()).toBeNull();
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect((warn.mock.calls[0] as [string])[0]).toContain('VariableContextProvider');
+  });
+
+  it('never loads nativewind on web, where the vars go on documentElement', () => {
+    ReactNative.Platform.OS = 'web';
+    const vars = jest.fn(() => ({ marker: true }));
+    const builder = loadStyleBuilder(() => ({ vars, VariableContextProvider: () => null }));
+
+    expect(builder.getVariableContextProvider()).toBeNull();
+    expect(builder.buildNativePresetStyle('blue', 'light')).toBeUndefined();
+    expect(vars).not.toHaveBeenCalled();
+    // A warning here would fire on every web app rendering a scoped subtree.
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('builds the same token map on every platform', () => {
+    // `buildScopeVars` is the pure half — it must not depend on nativewind at
+    // all, since web consumes it directly as an inline style object.
+    const builder = loadStyleBuilder(() => {
+      throw new Error('absent');
+    });
+    const scope = builder.buildScopeVars('green', 'light');
+
+    expect(scope['--primary']).toMatch(/^rgb/);
+    expect(scope['--color-primary']).toBe(scope['--primary']);
+  });
+});

package/src/__tests__/connection-status-netinfo.test.tsx

@@ -0,0 +1,203 @@
+import React from 'react';
+import { render } from '@testing-library/react-native';
+import type NetInfo from '@react-native-community/netinfo';
+
+import type { NetInfoLike } from '../connection-status/netinfo';
+
+/**
+ * THE OPTIONAL-PEER BOUNDARY for `@react-native-community/netinfo`.
+ *
+ * The defect: netinfo was declared an optional peer AND imported statically, so
+ * an app that never installed it did not lose the outage toast — its native
+ * bundle failed to build, pointing at a package it never mentions. The fix
+ * (`try { require('<literal>') } catch`) has to hold two properties at once, and
+ * both are asserted here: the real module is still used when it IS installed,
+ * and the component degrades to inert — not to a crash, and not silently —
+ * when it is not.
+ *
+ * `optional-peer-imports.test.ts` guards the static shape of the same contract.
+ * This one runs it.
+ *
+ * Every case goes through `jest.isolateModules` + `jest.doMock` because the
+ * loader caches its result in module state: without a fresh registry the first
+ * case to resolve netinfo would leave every later case asserting against a cache
+ * it can no longer influence, passing whatever the implementation did.
+ */
+
+const NETINFO = '@react-native-community/netinfo';
+const reactModule: unknown = jest.requireActual('react');
+
+/** A netinfo state object with only the two fields the component reads. */
+function state(isConnected: boolean, isInternetReachable: boolean | null = true) {
+  return { isConnected, isInternetReachable };
+}
+
+/**
+ * Compile-time half of the contract: the real netinfo surface must remain
+ * assignable to Bloom's hand-written `NetInfoLike`. The interface is written by
+ * hand so netinfo's types never reach Bloom's emitted `.d.ts` (a consumer that
+ * skips the optional peer must not inherit a TS7016 from Bloom), which leaves
+ * this as the only place a shape change in netinfo can be caught.
+ *
+ * It is enforced by `bun run typescript`, NOT by jest: ts-jest transpiles
+ * without typechecking here, so a drifted type is green under `bunx jest` and
+ * red under `tsc` (verified by mutation — widening the unsubscribe to
+ * `Promise<void>` produces `TS2322: Type 'true' is not assignable to type
+ * 'never'` on the line below).
+ */
+type RealNetInfoIsCompatible = typeof NetInfo extends NetInfoLike ? true : never;
+const NETINFO_TYPES_STILL_MATCH: RealNetInfoIsCompatible = true;
+
+type Harness = {
+  ConnectionStatusToasts: React.ComponentType<Record<string, never>>;
+  toast: { error: jest.Mock; warning: jest.Mock; success: jest.Mock };
+};
+
+/**
+ * Load `connection-status` against a given netinfo module factory. Passing a
+ * factory that THROWS is how the absent-peer case is expressed: that is exactly
+ * what the `catch` sees when Metro stubs an unresolved optional dependency.
+ */
+function loadWithNetInfo(factory: () => unknown): Harness {
+  let harness: Harness | undefined;
+
+  jest.isolateModules(() => {
+    const toast = { error: jest.fn(), warning: jest.fn(), success: jest.fn() };
+    // NOT `{ virtual: true }`: netinfo is a real devDependency here, and a
+    // virtual mock is keyed by the bare name while the component's `require`
+    // resolves to the installed path — the mock would never be consulted and
+    // every case would quietly run against the real module.
+    jest.doMock(NETINFO, factory);
+    jest.doMock('../toast', () => ({ toast }));
+    // An isolated registry would otherwise build the component against a SECOND
+    // copy of React, whose dispatcher is null under the outer renderer — every
+    // case would fail on `useState` before reaching what it asserts. Pinning
+    // react to the outer instance keeps one hook dispatcher for the whole tree.
+    jest.doMock('react', () => reactModule);
+
+    // A plain `require`, NOT `jest.requireActual`: the latter bypasses the mock
+    // registry for the whole dependency subtree, so the doMocks above would be
+    // ignored and the suite would silently exercise the REAL netinfo.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { ConnectionStatusToasts } = require('../connection-status') as typeof import('../connection-status');
+
+    harness = { ConnectionStatusToasts, toast };
+  });
+
+  if (!harness) throw new Error('module isolation did not run');
+  return harness;
+}
+
+describe('ConnectionStatusToasts netinfo loading', () => {
+  let warn: jest.SpyInstance<void, Parameters<typeof console.warn>>;
+
+  beforeEach(() => {
+    // `__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();
+    jest.resetModules();
+    jest.dontMock(NETINFO);
+    jest.dontMock('../toast');
+  });
+
+  it('keeps its own types in step with the real netinfo surface', () => {
+    // The real assertion is the type annotation above, checked by `tsc`. This
+    // only keeps the constant referenced so it cannot be dropped as unused.
+    expect(NETINFO_TYPES_STILL_MATCH).toBe(true);
+  });
+
+  it('subscribes through the named export when the peer is installed', () => {
+    const unsubscribe = jest.fn();
+    const addEventListener = jest.fn().mockReturnValue(unsubscribe);
+    const { ConnectionStatusToasts, toast } = loadWithNetInfo(() => ({ addEventListener }));
+
+    const view = render(<ConnectionStatusToasts />);
+    expect(addEventListener).toHaveBeenCalledTimes(1);
+    expect(warn).not.toHaveBeenCalled();
+
+    const emit = addEventListener.mock.calls[0][0] as (s: ReturnType<typeof state>) => void;
+    view.rerender(<ConnectionStatusToasts />);
+    emit(state(false));
+    view.rerender(<ConnectionStatusToasts />);
+
+    expect(toast.error).toHaveBeenCalledWith('No internet connection', expect.anything());
+
+    view.unmount();
+    expect(unsubscribe).toHaveBeenCalledTimes(1);
+  });
+
+  it('subscribes through the default export too', () => {
+    // Which shape comes back depends on whether the bundler resolved netinfo's
+    // CommonJS build or its ESM/source entry; both are live in the fleet.
+    const addEventListener = jest.fn().mockReturnValue(jest.fn());
+    const { ConnectionStatusToasts } = loadWithNetInfo(() => ({
+      __esModule: true,
+      default: { addEventListener },
+    }));
+
+    render(<ConnectionStatusToasts />);
+    expect(addEventListener).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders inert instead of throwing when the peer is absent', () => {
+    const { ConnectionStatusToasts, toast } = loadWithNetInfo(() => {
+      throw new Error(`Cannot find module '${NETINFO}'`);
+    });
+
+    const view = render(<ConnectionStatusToasts />);
+    expect(view.toJSON()).toBeNull();
+    expect(toast.error).not.toHaveBeenCalled();
+    expect(toast.warning).not.toHaveBeenCalled();
+    expect(toast.success).not.toHaveBeenCalled();
+    expect(() => view.unmount()).not.toThrow();
+  });
+
+  it('names the missing package once, not once per mount', () => {
+    const { ConnectionStatusToasts } = loadWithNetInfo(() => {
+      throw new Error(`Cannot find module '${NETINFO}'`);
+    });
+
+    render(<ConnectionStatusToasts />).unmount();
+    render(<ConnectionStatusToasts />).unmount();
+
+    expect(warn).toHaveBeenCalledTimes(1);
+    const [message] = warn.mock.calls[0] as [string];
+    // An actionable warning has to carry all three: what broke, which package,
+    // and how to fix it. A bare "netinfo missing" sends the reader to Bloom.
+    expect(message).toContain(NETINFO);
+    expect(message).toContain('inert');
+    expect(message).toContain('expo install');
+    // …and the underlying resolution error, so a shape/version failure is not
+    // reported as if the package were simply not installed.
+    expect(message).toContain('Cannot find module');
+  });
+
+  it('warns when the peer resolves but has no addEventListener', () => {
+    const { ConnectionStatusToasts } = loadWithNetInfo(() => ({ fetch: jest.fn() }));
+
+    render(<ConnectionStatusToasts />);
+
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect((warn.mock.calls[0] as [string])[0]).toContain('without an `addEventListener` export');
+  });
+
+  it('stays silent in production', () => {
+    const previous = process.env.NODE_ENV;
+    // Metro and Vite fold this branch away entirely; jest cannot, so the guard
+    // is asserted at runtime instead.
+    process.env.NODE_ENV = 'production';
+    try {
+      const { ConnectionStatusToasts } = loadWithNetInfo(() => {
+        throw new Error(`Cannot find module '${NETINFO}'`);
+      });
+      render(<ConnectionStatusToasts />);
+      expect(warn).not.toHaveBeenCalled();
+    } finally {
+      process.env.NODE_ENV = previous;
+    }
+  });
+});

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([]);
+  });
+});