@q9labsai/chalk-react-native 4.0.0

package/package.json

@@ -0,0 +1,184 @@
+{
+  "name": "@q9labsai/chalk-react-native",
+  "version": "4.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Q9Labs/chalk.git",
+    "directory": "sdks/typescript/react-native"
+  },
+  "files": [
+    "dist",
+    "src",
+    "embedded",
+    "android",
+    "ios",
+    "*.podspec"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "android": [
+        "./dist/android.d.ts"
+      ],
+      "ios": [
+        "./dist/ios.d.ts"
+      ],
+      "ios-phone": [
+        "./dist/ios-phone.d.ts"
+      ],
+      "ios-pad": [
+        "./dist/ios-pad.d.ts"
+      ],
+      "macos": [
+        "./dist/macos.d.ts"
+      ],
+      "runtime": [
+        "./dist/runtime.d.ts"
+      ],
+      "clipboard": [
+        "./dist/clipboard.d.ts"
+      ],
+      "diagnostics": [
+        "./dist/diagnostics.d.ts"
+      ],
+      "invites": [
+        "./dist/invites.d.ts"
+      ],
+      "theme": [
+        "./dist/ui/theme.d.ts"
+      ],
+      "appearance": [
+        "./dist/ui/appearance.d.ts"
+      ],
+      "client": [
+        "./dist/client.d.ts"
+      ],
+      "*": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "react-native": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.js",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./android": {
+      "types": "./dist/android.d.ts",
+      "react-native": "./dist/android.js",
+      "import": "./dist/android.js",
+      "default": "./dist/android.js"
+    },
+    "./ios": {
+      "types": "./dist/ios.d.ts",
+      "react-native": "./dist/ios.js",
+      "import": "./dist/ios.js",
+      "default": "./dist/ios.js"
+    },
+    "./ios-phone": {
+      "types": "./dist/ios-phone.d.ts",
+      "react-native": "./dist/ios-phone.js",
+      "import": "./dist/ios-phone.js",
+      "default": "./dist/ios-phone.js"
+    },
+    "./ios-pad": {
+      "types": "./dist/ios-pad.d.ts",
+      "react-native": "./dist/ios-pad.js",
+      "import": "./dist/ios-pad.js",
+      "default": "./dist/ios-pad.js"
+    },
+    "./macos": {
+      "types": "./dist/macos.d.ts",
+      "react-native": "./dist/macos.js",
+      "import": "./dist/macos.js",
+      "default": "./dist/macos.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "react-native": "./dist/runtime.js",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    },
+    "./clipboard": {
+      "types": "./dist/clipboard.d.ts",
+      "react-native": "./dist/clipboard.js",
+      "import": "./dist/clipboard.js",
+      "default": "./dist/clipboard.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "react-native": "./dist/diagnostics.js",
+      "import": "./dist/diagnostics.js",
+      "default": "./dist/diagnostics.js"
+    },
+    "./invites": {
+      "types": "./dist/invites.d.ts",
+      "react-native": "./dist/invites.js",
+      "import": "./dist/invites.js",
+      "default": "./dist/invites.js"
+    },
+    "./theme": {
+      "types": "./dist/ui/theme.d.ts",
+      "react-native": "./dist/ui/theme.js",
+      "import": "./dist/ui/theme.js",
+      "default": "./dist/ui/theme.js"
+    },
+    "./appearance": {
+      "types": "./dist/ui/appearance.d.ts",
+      "react-native": "./dist/ui/appearance.js",
+      "import": "./dist/ui/appearance.js",
+      "default": "./dist/ui/appearance.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "react-native": "./dist/client.js",
+      "import": "./dist/client.js",
+      "default": "./dist/client.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@q9labsai/chalk-client": "^4.0.0",
+    "@q9labsai/chalk-whiteboard": "^4.0.0",
+    "@q9labsai/facehash": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.0.0",
+    "react-native-webview": "13.16.1",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "@cloudflare/react-native-webrtc": "~125.0.1 || ~125.0.3",
+    "@hugeicons/core-free-icons": "^4.0.0",
+    "@hugeicons/react-native": "^1.0.13",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-native": ">=0.77",
+    "react-native-svg": "^15.15.3",
+    "react-native-webview": "^13.16.1"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsup ./src/index.ts ./src/client.ts ./src/android.ts ./src/ios.ts ./src/ios-phone.ts ./src/ios-pad.ts ./src/macos.ts ./src/runtime.ts ./src/clipboard.ts ./src/diagnostics.ts ./src/invites.ts ./src/ui/theme.ts ./src/ui/appearance.ts --format esm --out-dir ./dist --platform browser --external react --external react-native --external react-native-webview --external @q9labsai/chalk-whiteboard --external @cloudflare/react-native-webrtc && pnpm run build:types && pnpm run sync:whiteboard-assets",
+    "build:types": "rm -f tsconfig.tsbuildinfo && tsc --build tsconfig.json",
+    "dev": "tsup ./src/index.ts ./src/client.ts ./src/android.ts ./src/ios.ts ./src/ios-phone.ts ./src/ios-pad.ts ./src/macos.ts ./src/runtime.ts ./src/clipboard.ts ./src/diagnostics.ts ./src/invites.ts ./src/ui/theme.ts ./src/ui/appearance.ts --format esm --out-dir ./dist --platform browser --external react --external react-native --external react-native-webview --external @q9labsai/chalk-whiteboard --external @cloudflare/react-native-webrtc --watch",
+    "sync:whiteboard-assets": "node ./scripts/sync-whiteboard-assets.mjs",
+    "test": "pnpm exec vitest run",
+    "check-types": "tsc --project tsconfig.check-types.json --noEmit",
+    "check:tokens": "node ./scripts/check-tokenized-styles.mjs",
+    "check:client-package": "node ./scripts/check-client-package.mjs",
+    "lint": "pnpm run check:tokens && pnpm exec oxfmt --check . && tsc --project tsconfig.check-types.json --noEmit",
+    "clean": "rm -rf dist"
+  }
+}

package/src/android/connection-service.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const nativeModule = {
+  addListener: vi.fn(),
+  endCall: vi.fn(async () => true),
+  isSupported: vi.fn(async () => true),
+  registerPhoneAccount: vi.fn(async () => true),
+  removeListeners: vi.fn(),
+  setActive: vi.fn(async () => true),
+  startCall: vi.fn(async () => true),
+};
+
+const subscriptions = new Map<string, (payload: unknown) => void>();
+const platform = { OS: "android" };
+
+class MockNativeEventEmitter {
+  addListener(eventName: string, listener: (payload: unknown) => void) {
+    subscriptions.set(eventName, listener);
+    return {
+      remove: () => {
+        subscriptions.delete(eventName);
+      },
+    };
+  }
+}
+
+vi.mock("react-native", () => ({
+  NativeEventEmitter: MockNativeEventEmitter,
+  NativeModules: {
+    ChalkAndroidConnectionService: nativeModule,
+  },
+  Platform: platform,
+}));
+
+describe("android connection service bridge", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    subscriptions.clear();
+    platform.OS = "android";
+  });
+
+  it("no-ops when Android native support is unavailable", async () => {
+    platform.OS = "ios";
+
+    const { addAndroidConnectionServiceListener, ensureAndroidConnectionServiceRegistered, endAndroidConnectionServiceCall, isAndroidConnectionServiceSupported, setAndroidConnectionServiceActive, startAndroidConnectionServiceCall } = await import("./connection-service");
+
+    expect(await isAndroidConnectionServiceSupported()).toBe(false);
+    expect(await ensureAndroidConnectionServiceRegistered()).toBe(false);
+    expect(
+      await startAndroidConnectionServiceCall({
+        callId: "space-1:1",
+        displayName: "Host",
+        spaceId: "space-1",
+        spaceName: "Daily Standup",
+      }),
+    ).toBe(false);
+    expect(await setAndroidConnectionServiceActive("space-1:1")).toBe(false);
+    expect(await endAndroidConnectionServiceCall("space-1:1")).toBe(false);
+
+    const unsubscribe = addAndroidConnectionServiceListener(() => {
+      throw new Error("listener should not be called on iOS");
+    });
+    unsubscribe();
+
+    expect(nativeModule.isSupported).not.toHaveBeenCalled();
+    expect(nativeModule.registerPhoneAccount).not.toHaveBeenCalled();
+    expect(nativeModule.startCall).not.toHaveBeenCalled();
+    expect(nativeModule.setActive).not.toHaveBeenCalled();
+    expect(nativeModule.endCall).not.toHaveBeenCalled();
+  });
+
+  it("passes through Android native module calls and emits disconnect events", async () => {
+    const { addAndroidConnectionServiceListener, ensureAndroidConnectionServiceRegistered, endAndroidConnectionServiceCall, isAndroidConnectionServiceSupported, setAndroidConnectionServiceActive, startAndroidConnectionServiceCall } = await import("./connection-service");
+
+    expect(await isAndroidConnectionServiceSupported()).toBe(true);
+    expect(await ensureAndroidConnectionServiceRegistered()).toBe(true);
+    expect(
+      await startAndroidConnectionServiceCall({
+        callId: "space-1:2",
+        displayName: "Guest",
+        hasVideo: false,
+        spaceId: "space-1",
+        spaceName: "Board Review",
+      }),
+    ).toBe(true);
+    expect(await setAndroidConnectionServiceActive("space-1:2")).toBe(true);
+    expect(await endAndroidConnectionServiceCall("space-1:2", { reason: "remote", label: "Space ended" })).toBe(true);
+
+    const listener = vi.fn();
+    const unsubscribe = addAndroidConnectionServiceListener(listener);
+    const disconnectPayload = {
+      callId: "space-1:2",
+      reason: "local",
+      type: "disconnect",
+    };
+
+    subscriptions.get("ChalkAndroidConnectionServiceEvent")?.(disconnectPayload);
+    unsubscribe();
+
+    expect(nativeModule.isSupported).toHaveBeenCalledTimes(1);
+    expect(nativeModule.registerPhoneAccount).toHaveBeenCalledTimes(1);
+    expect(nativeModule.startCall).toHaveBeenCalledWith({
+      callId: "space-1:2",
+      displayName: "Guest",
+      hasVideo: false,
+      spaceId: "space-1",
+      spaceName: "Board Review",
+    });
+    expect(nativeModule.setActive).toHaveBeenCalledWith("space-1:2");
+    expect(nativeModule.endCall).toHaveBeenCalledWith("space-1:2", "remote", "Space ended");
+    expect(listener).toHaveBeenCalledWith(disconnectPayload);
+  });
+});

package/src/android/connection-service.ts

@@ -0,0 +1,106 @@
+import { NativeEventEmitter, NativeModules, Platform } from "react-native";
+
+const eventName = "ChalkAndroidConnectionServiceEvent";
+
+export type AndroidConnectionServiceDisconnectReason = "canceled" | "error" | "local" | "missed" | "rejected" | "remote";
+
+export interface AndroidConnectionServiceCall {
+  callId: string;
+  spaceId: string;
+  spaceName: string;
+  displayName: string;
+  hasVideo?: boolean;
+}
+
+export interface AndroidConnectionServiceDisconnectEvent {
+  type: "disconnect";
+  callId: string;
+  reason: AndroidConnectionServiceDisconnectReason;
+}
+
+export interface AndroidConnectionServiceEndCallOptions {
+  reason?: AndroidConnectionServiceDisconnectReason;
+  label?: string;
+}
+
+type AndroidConnectionServiceEvent = AndroidConnectionServiceDisconnectEvent;
+
+interface ChalkAndroidConnectionServiceNativeModule {
+  addListener: (event: string) => void;
+  removeListeners: (count: number) => void;
+  endCall: (callId: string, reason?: string, label?: string) => Promise<boolean>;
+  isSupported: () => Promise<boolean>;
+  registerPhoneAccount: () => Promise<boolean>;
+  setActive: (callId: string) => Promise<boolean>;
+  startCall: (call: AndroidConnectionServiceCall) => Promise<boolean>;
+}
+
+function getNativeModule(): ChalkAndroidConnectionServiceNativeModule | null {
+  if (Platform.OS !== "android") {
+    return null;
+  }
+
+  const nativeModule = NativeModules.ChalkAndroidConnectionService as ChalkAndroidConnectionServiceNativeModule | undefined;
+  return nativeModule ?? null;
+}
+
+export async function isAndroidConnectionServiceSupported(): Promise<boolean> {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return false;
+  }
+
+  return nativeModule.isSupported();
+}
+
+export async function ensureAndroidConnectionServiceRegistered(): Promise<boolean> {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return false;
+  }
+
+  return nativeModule.registerPhoneAccount();
+}
+
+export async function startAndroidConnectionServiceCall(call: AndroidConnectionServiceCall): Promise<boolean> {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return false;
+  }
+
+  return nativeModule.startCall(call);
+}
+
+export async function setAndroidConnectionServiceActive(callId: string): Promise<boolean> {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return false;
+  }
+
+  return nativeModule.setActive(callId);
+}
+
+export async function endAndroidConnectionServiceCall(callId: string, options: AndroidConnectionServiceEndCallOptions = {}): Promise<boolean> {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return false;
+  }
+
+  return nativeModule.endCall(callId, options.reason, options.label);
+}
+
+export function addAndroidConnectionServiceListener(listener: (event: AndroidConnectionServiceEvent) => void): () => void {
+  const nativeModule = getNativeModule();
+  if (!nativeModule) {
+    return () => {};
+  }
+
+  const eventEmitter = new NativeEventEmitter(nativeModule);
+  const subscription = eventEmitter.addListener(eventName, (payload: AndroidConnectionServiceEvent) => {
+    listener(payload);
+  });
+
+  return () => {
+    subscription.remove();
+  };
+}

package/src/android.ts

@@ -0,0 +1 @@
+export * from "./index";

package/src/callkit/callkit.test.ts

@@ -0,0 +1,95 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const addListener = vi.fn();
+const configure = vi.fn(async () => ({ isSupported: true }));
+const endAllCalls = vi.fn(async () => undefined);
+const endCall = vi.fn(async () => undefined);
+const reportConnected = vi.fn(async () => undefined);
+const reportIncomingCall = vi.fn(async () => ({ callUUID: "incoming-uuid" }));
+const startCall = vi.fn(async () => ({ callUUID: "outgoing-uuid" }));
+const updateCall = vi.fn(async () => undefined);
+
+const nativeModule = {
+  configure,
+  endAllCalls,
+  endCall,
+  eventName: "ChalkCallKitEvent",
+  isSupported: true,
+  reportConnected,
+  reportIncomingCall,
+  startCall,
+  updateCall,
+};
+
+const eventEmitter = {
+  addListener,
+};
+
+const platform = { OS: "ios" };
+const nativeModules = { ChalkCallKitModule: nativeModule };
+
+vi.mock("react-native", () => ({
+  NativeEventEmitter: class {
+    constructor() {
+      return eventEmitter;
+    }
+  },
+  NativeModules: nativeModules,
+  Platform: platform,
+}));
+
+describe("callKit", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    platform.OS = "ios";
+    nativeModule.isSupported = true;
+    addListener.mockReset();
+    configure.mockClear();
+    endAllCalls.mockClear();
+    endCall.mockClear();
+    reportConnected.mockClear();
+    reportIncomingCall.mockClear();
+    startCall.mockClear();
+    updateCall.mockClear();
+  });
+
+  it("uses the native event emitter when the iOS module is available", async () => {
+    const listener = vi.fn();
+    addListener.mockReturnValueOnce({ remove: vi.fn() });
+
+    const { callKit } = await import("./callkit");
+    const subscription = callKit.addListener(listener);
+
+    expect(callKit.isSupported).toBe(true);
+    expect(addListener).toHaveBeenCalledWith("ChalkCallKitEvent", listener);
+    expect(subscription.remove).toBeTypeOf("function");
+  });
+
+  it("falls back to no-op behavior on unsupported platforms", async () => {
+    platform.OS = "android";
+
+    const { callKit } = await import("./callkit");
+    const result = await callKit.startCall({
+      displayName: "Space",
+      handle: "space-123",
+    });
+
+    expect(callKit.isSupported).toBe(false);
+    expect(result).toBeNull();
+    expect(startCall).not.toHaveBeenCalled();
+  });
+
+  it("passes configuration through to the native bridge", async () => {
+    const { callKit } = await import("./callkit");
+
+    await callKit.configure({
+      appName: "Chalk",
+      includesCallsInRecents: false,
+    });
+
+    expect(configure).toHaveBeenCalledWith({
+      appName: "Chalk",
+      includesCallsInRecents: false,
+    });
+  });
+});

package/src/callkit/callkit.ts

@@ -0,0 +1,135 @@
+import type { EmitterSubscription } from "react-native";
+import { NativeEventEmitter, NativeModules, Platform } from "react-native";
+
+export type CallKitHandleType = "generic" | "emailAddress" | "phoneNumber";
+export type CallKitEndReason = "answeredElsewhere" | "declinedElsewhere" | "failed" | "missed" | "remoteEnded" | "unanswered";
+
+export interface CallKitConfiguration {
+  appName?: string;
+  iconTemplateImageName?: string;
+  includesCallsInRecents?: boolean;
+  maximumCallGroups?: number;
+  maximumCallsPerCallGroup?: number;
+  ringtoneSound?: string;
+}
+
+export interface CallKitCallOptions {
+  callUUID?: string;
+  displayName?: string;
+  handle?: string;
+  handleType?: CallKitHandleType;
+  hasVideo?: boolean;
+  supportsDTMF?: boolean;
+  supportsGrouping?: boolean;
+  supportsHolding?: boolean;
+  supportsUngrouping?: boolean;
+}
+
+export interface CallKitEndCallOptions {
+  callUUID?: string;
+  reason?: CallKitEndReason;
+}
+
+export type CallKitEvent = { callUUID: string; type: "answerCallAction" } | { callUUID: string; muted: boolean; type: "setMutedCallAction" } | { callUUID: string; type: "endCallAction" } | { type: "audioSessionActivated" } | { type: "audioSessionDeactivated" } | { type: "providerReset" };
+
+type NativeChalkCallKitModule = {
+  addListener?: (eventName: string) => void;
+  configure: (options: CallKitConfiguration) => Promise<{ isSupported: boolean }>;
+  endAllCalls: () => Promise<void>;
+  endCall: (options: CallKitEndCallOptions) => Promise<void>;
+  eventName?: string;
+  isSupported?: boolean;
+  removeListeners?: (count: number) => void;
+  reportConnected: (options: Pick<CallKitCallOptions, "callUUID">) => Promise<void>;
+  reportIncomingCall: (options: CallKitCallOptions) => Promise<{ callUUID: string }>;
+  startCall: (options: CallKitCallOptions) => Promise<{ callUUID: string }>;
+  updateCall: (options: CallKitCallOptions) => Promise<void>;
+};
+
+const moduleName = "ChalkCallKitModule";
+const nativeModule = NativeModules[moduleName] as NativeChalkCallKitModule | undefined;
+const nativeEventName = nativeModule?.eventName ?? "ChalkCallKitEvent";
+const nativeEmitter = nativeModule ? new NativeEventEmitter(nativeModule as ConstructorParameters<typeof NativeEventEmitter>[0]) : null;
+
+function getNativeCallKitModule(): NativeChalkCallKitModule | null {
+  if (Platform.OS !== "ios" || nativeModule?.isSupported !== true) {
+    return null;
+  }
+
+  return nativeModule;
+}
+
+function createNoopSubscription(): EmitterSubscription {
+  return {
+    remove() {
+      return undefined;
+    },
+  } as EmitterSubscription;
+}
+
+export const callKit = {
+  addListener(listener: (event: CallKitEvent) => void): EmitterSubscription {
+    if (!nativeEmitter) {
+      return createNoopSubscription();
+    }
+
+    return nativeEmitter.addListener(nativeEventName, listener);
+  },
+  async configure(options: CallKitConfiguration): Promise<{ isSupported: boolean }> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return { isSupported: false };
+    }
+
+    return module.configure(options);
+  },
+  async endAllCalls(): Promise<void> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return;
+    }
+
+    await module.endAllCalls();
+  },
+  async endCall(options: CallKitEndCallOptions): Promise<void> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return;
+    }
+
+    await module.endCall(options);
+  },
+  isSupported: getNativeCallKitModule() !== null,
+  async reportConnected(options: Pick<CallKitCallOptions, "callUUID">): Promise<void> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return;
+    }
+
+    await module.reportConnected(options);
+  },
+  async reportIncomingCall(options: CallKitCallOptions): Promise<{ callUUID: string } | null> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return null;
+    }
+
+    return module.reportIncomingCall(options);
+  },
+  async startCall(options: CallKitCallOptions): Promise<{ callUUID: string } | null> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return null;
+    }
+
+    return module.startCall(options);
+  },
+  async updateCall(options: CallKitCallOptions): Promise<void> {
+    const module = getNativeCallKitModule();
+    if (!module) {
+      return;
+    }
+
+    await module.updateCall(options);
+  },
+};