@oxyhq/bloom 0.68.0 → 0.69.1

package/lib/typescript/module/loading/SpinnerIcon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpinnerIcon.d.ts","sourceRoot":"","sources":["../../../../src/loading/SpinnerIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AACzC,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAqBjE,UAAU,gBAAgB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAwED;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAqBlD,CAAC"}
+{"version":3,"file":"SpinnerIcon.d.ts","sourceRoot":"","sources":["../../../../src/loading/SpinnerIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AACzC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAU9C,UAAU,gBAAgB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAwDlD,CAAC"}

package/lib/typescript/module/theme/adaptive-colors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adaptive-colors.d.ts","sourceRoot":"","sources":["../../../../src/theme/adaptive-colors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAgG3C,wBAAgB,iBAAiB,IAAI,WAAW,GAAG,IAAI,CAItD"}
+{"version":3,"file":"adaptive-colors.d.ts","sourceRoot":"","sources":["../../../../src/theme/adaptive-colors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAgH3C,wBAAgB,iBAAiB,IAAI,WAAW,GAAG,IAAI,CAItD"}

package/lib/typescript/module/theme/color-scope/style-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"style-builder.d.ts","sourceRoot":"","sources":["../../../../../src/theme/color-scope/style-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAY,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD;;;;;GAKG;AACH,MAAM,MAAM,gCAAgC,GAAG,KAAK,CAAC,aAAa,CAAC;IACjE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC,CAAC;AASH;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,YAAY,EACzB,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,IAAI,gCAAgC,GAAG,IAAI,CAKpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,YAAY,EACzB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,SAAS,CAAC,SAAS,CAAC,CAKtB"}
+{"version":3,"file":"style-builder.d.ts","sourceRoot":"","sources":["../../../../../src/theme/color-scope/style-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAY,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAGxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA6CtD;;;;;GAKG;AACH,MAAM,MAAM,gCAAgC,GAAG,KAAK,CAAC,aAAa,CAAC;IACjE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC,CAAC;AAkEH;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,YAAY,EACzB,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,IAAI,gCAAgC,GAAG,IAAI,CAepF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,YAAY,EACzB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,SAAS,CAAC,SAAS,CAAC,CAQtB"}

package/lib/typescript/module/theme/init-css-interop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-css-interop.d.ts","sourceRoot":"","sources":["../../../../src/theme/init-css-interop.ts"],"names":[],"mappings":"AAuHA;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}
+{"version":3,"file":"init-css-interop.d.ts","sourceRoot":"","sources":["../../../../src/theme/init-css-interop.ts"],"names":[],"mappings":"AAyHA;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "0.68.0",
+  "version": "0.69.1",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -1490,6 +1490,7 @@
     "@react-native-community/netinfo": "^12.0.1"
   },
   "peerDependencies": {
+    "@react-native-community/netinfo": ">=11.1.0",
     "expo": "*",
     "expo-blur": "*",
     "expo-font": "*",
@@ -1498,18 +1499,21 @@
     "expo-image": "*",
     "expo-router": ">=3.0.0",
     "expo-symbols": ">=0.4.5",
+    "nativewind": ">=5.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
     "react-native": ">=0.73.0",
     "react-native-gesture-handler": ">=2.16.1",
+    "react-native-keyboard-controller": ">=1.11.4",
     "react-native-reanimated": ">=3.13.0",
     "react-native-safe-area-context": ">=5.0.0",
     "react-native-screens": ">=3.16.0",
-    "react-native-svg": ">=13.0.0",
-    "nativewind": ">=5.0.0",
-    "@react-native-community/netinfo": ""
+    "react-native-svg": ">=13.0.0"
   },
   "peerDependenciesMeta": {
+    "@react-native-community/netinfo": {
+      "optional": true
+    },
     "expo": {
       "optional": true
     },
@@ -1522,13 +1526,13 @@
     "expo-router": {
       "optional": true
     },
-    "react-dom": {
+    "nativewind": {
       "optional": true
     },
-    "nativewind": {
+    "react-dom": {
       "optional": true
     },
-    "@react-native-community/netinfo": {
+    "react-native-keyboard-controller": {
       "optional": true
     }
   },

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