@zellio/chat-react-native 0.0.0-stage → 1.0.0

package/lib/index.js

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_TIMEOUT_MS = exports.VERSION = void 0;
+exports.configure = configure;
+exports.identify = identify;
+exports.logout = logout;
+exports.present = present;
+exports.presentConversation = presentConversation;
+exports.dismiss = dismiss;
+exports.setContext = setContext;
+exports.getUnreadCount = getUnreadCount;
+exports.addUnreadListener = addUnreadListener;
+exports.addEventListener = addEventListener;
+exports.setPushToken = setPushToken;
+exports.isZellioPush = isZellioPush;
+exports.handlePush = handlePush;
+exports.handleNotificationTap = handleNotificationTap;
+const NativeZellioChat_1 = __importDefault(require("./NativeZellioChat"));
+const version_1 = require("./version");
+var version_2 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_2.VERSION; } });
+/** Native asks for a token at most this long before it gives up. */
+exports.TOKEN_TIMEOUT_MS = 15000;
+let tokenProvider = null;
+let tokenSubscription = null;
+function reportMisuse(call, error) {
+    // Only the call name and the error kind. Never the arguments: they can hold a token.
+    const kind = error instanceof Error ? error.name : 'unknown';
+    console.warn(`[ZellioChat] ${call} failed (${kind})`);
+}
+function guard(call, run) {
+    try {
+        run();
+    }
+    catch (error) {
+        reportMisuse(call, error);
+    }
+}
+/** Call once at app start. Cheap: no network on the calling thread, no UI. */
+function configure(config) {
+    guard('configure', () => {
+        const { appKey, theme, ...rest } = config;
+        NativeZellioChat_1.default.configure(appKey, withoutUndefined({
+            ...rest,
+            themeMode: theme?.mode,
+            primaryColor: theme?.primaryColor,
+            customerMessageColor: theme?.customerMessageColor,
+            surfaceColor: theme?.surfaceColor,
+            wrapper: version_1.WRAPPER,
+        }));
+    });
+}
+/** The bridge turns `undefined` into null. Native code reads "missing" more simply than "null". */
+function withoutUndefined(values) {
+    const out = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+async function answerTokenRequest(requestId) {
+    const provider = tokenProvider;
+    if (provider === null) {
+        NativeZellioChat_1.default.resolveToken(requestId, null, 'no_provider');
+        return;
+    }
+    let timer;
+    try {
+        const token = await Promise.race([
+            provider(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error('timeout')), exports.TOKEN_TIMEOUT_MS);
+            }),
+        ]);
+        if (typeof token === 'string' && token.length > 0) {
+            NativeZellioChat_1.default.resolveToken(requestId, token, null);
+        }
+        else {
+            NativeZellioChat_1.default.resolveToken(requestId, null, 'no_token');
+        }
+    }
+    catch (error) {
+        const timedOut = error instanceof Error && error.message === 'timeout';
+        NativeZellioChat_1.default.resolveToken(requestId, null, timedOut ? 'timeout' : 'provider_error');
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+/**
+ * Marks a signed-in customer. `tokenProvider` returns a JWT from your server. The SDK calls it when it needs a
+ * session and again if the server rejects the token. The token is never logged. Calling `identify` again
+ * replaces the provider.
+ */
+function identify(provider) {
+    guard('identify', () => {
+        tokenProvider = provider;
+        if (tokenSubscription === null) {
+            tokenSubscription = NativeZellioChat_1.default.onTokenRequest((request) => {
+                void answerTokenRequest(request.requestId);
+            });
+        }
+        NativeZellioChat_1.default.identify();
+    });
+}
+/** Ends the session, deletes all local chat data and removes the push token from the server. */
+function logout() {
+    guard('logout', () => {
+        tokenProvider = null;
+        NativeZellioChat_1.default.logout();
+    });
+}
+/** Shows chat on top of the app. */
+function present() {
+    guard('present', () => NativeZellioChat_1.default.present());
+}
+/** Opens one conversation, or a new one when `conversationId` is omitted. */
+function presentConversation(conversationId) {
+    guard('presentConversation', () => NativeZellioChat_1.default.presentConversation(conversationId ?? null));
+}
+/** Closes chat. */
+function dismiss() {
+    guard('dismiss', () => NativeZellioChat_1.default.dismiss());
+}
+/** Tells agents what the customer looks at. It is sent with the next messages. `null` clears it. */
+function setContext(context) {
+    guard('setContext', () => {
+        NativeZellioChat_1.default.setContext(context === null ? null : withoutUndefined({ ...context }));
+    });
+}
+/** The number of unread agent messages, across all conversations. Resolves 0 if the SDK is not ready. */
+async function getUnreadCount() {
+    try {
+        return await NativeZellioChat_1.default.getUnreadCount();
+    }
+    catch (error) {
+        reportMisuse('getUnreadCount', error);
+        return 0;
+    }
+}
+/** Calls back now with the current count and on every change. Call `remove()` to stop. */
+function addUnreadListener(callback) {
+    let active = true;
+    const native = NativeZellioChat_1.default.onUnread((event) => {
+        if (active)
+            callback(event.count);
+    });
+    void getUnreadCount().then((count) => {
+        if (active)
+            callback(count);
+    });
+    return {
+        remove() {
+            if (!active)
+                return;
+            active = false;
+            native.remove();
+        },
+    };
+}
+/** Chat events for your own analytics. Call `remove()` to stop. */
+function addEventListener(callback) {
+    const native = NativeZellioChat_1.default.onEvent((event) => {
+        switch (event.name) {
+            case 'chatOpened':
+            case 'chatClosed':
+            case 'messageSent':
+            case 'messageReceived':
+                callback({ type: event.name });
+                break;
+            case 'error':
+                callback({ type: 'error', code: event.code ?? 'unknown' });
+                break;
+            default:
+                break;
+        }
+    });
+    return {
+        remove() {
+            native.remove();
+        },
+    };
+}
+/** Gives the SDK the push token: the APNs token as a hex string on iOS, the FCM token on Android. */
+function setPushToken(token, environment) {
+    guard('setPushToken', () => NativeZellioChat_1.default.setPushToken(token, environment ?? null));
+}
+function toJson(payload) {
+    if (payload === null || payload === undefined)
+        return null;
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        return null;
+    }
+}
+/** True only if the payload has the `zellio` key. */
+function isZellioPush(payload) {
+    const json = toJson(payload);
+    if (json === null)
+        return false;
+    try {
+        return NativeZellioChat_1.default.isZellioPush(json);
+    }
+    catch (error) {
+        reportMisuse('isZellioPush', error);
+        return false;
+    }
+}
+/** Refreshes the unread state. Resolves true if the push was ours. */
+async function handlePush(payload) {
+    const json = toJson(payload);
+    if (json === null)
+        return false;
+    try {
+        return await NativeZellioChat_1.default.handlePush(json);
+    }
+    catch (error) {
+        reportMisuse('handlePush', error);
+        return false;
+    }
+}
+/** Opens the conversation that the push names. Resolves true if the push was ours. */
+async function handleNotificationTap(payload) {
+    const json = toJson(payload);
+    if (json === null)
+        return false;
+    try {
+        return await NativeZellioChat_1.default.handleNotificationTap(json);
+    }
+    catch (error) {
+        reportMisuse('handleNotificationTap', error);
+        return false;
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,54 @@
+export type ZellioLocale = 'auto' | 'ar' | 'en';
+export type ZellioThemeMode = 'auto' | 'light' | 'dark';
+export type ZellioLogLevel = 'none' | 'error' | 'warn' | 'info' | 'debug';
+/** Colors are `#RRGGBB`. A color that would make text hard to read is adjusted by the native SDK. */
+export interface ZellioTheme {
+    mode?: ZellioThemeMode;
+    primaryColor?: string;
+    customerMessageColor?: string;
+    surfaceColor?: string;
+}
+export interface ZellioChatConfig {
+    /** The app key from Zellio Studio. */
+    appKey: string;
+    /** Default: https://app.zellio.ai */
+    baseUrl?: string;
+    /** Default: `auto` (the Studio language policy, then the device language). */
+    locale?: ZellioLocale;
+    theme?: ZellioTheme;
+    /** Default: `error` on iOS and `warn` on Android. Chat text and tokens are never logged. */
+    logLevel?: ZellioLogLevel;
+    /** The small banner for a new message while chat is closed. Default: true. */
+    showsInAppBanner?: boolean;
+    /** false: the banner says "New message" and never shows the text. Default: true. */
+    bannerShowsPreview?: boolean;
+}
+/** What the customer is looking at. Agents see it. `url` must be https. */
+export interface ZellioContext {
+    screen?: string;
+    itemType?: string;
+    itemId?: string;
+    itemTitle?: string;
+    url?: string;
+}
+/** Events for your own analytics. They never carry message text. */
+export type ZellioChatEvent = {
+    type: 'chatOpened';
+} | {
+    type: 'chatClosed';
+} | {
+    type: 'messageSent';
+} | {
+    type: 'messageReceived';
+} | {
+    type: 'error';
+    code: string;
+};
+/** Returns the identity JWT from your server, or null when nobody is signed in. */
+export type ZellioTokenProvider = () => Promise<string | null>;
+export interface ZellioSubscription {
+    remove(): void;
+}
+export type ZellioPushEnvironment = 'sandbox' | 'production';
+/** The data of a push message, as your push library gives it to you. */
+export type ZellioPushPayload = Record<string, unknown>;

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/version.d.ts

@@ -0,0 +1,4 @@
+/** Kept equal to package.json by `npm run check:version` (runs before every pack). */
+export declare const VERSION = "1.0.0";
+/** Sent to the native SDK as `wrapper`, so the x-zee-sdk-wrapper header names this package. */
+export declare const WRAPPER = "react-native/1.0.0";

package/lib/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRAPPER = exports.VERSION = void 0;
+/** Kept equal to package.json by `npm run check:version` (runs before every pack). */
+exports.VERSION = '1.0.0';
+/** Sent to the native SDK as `wrapper`, so the x-zee-sdk-wrapper header names this package. */
+exports.WRAPPER = `react-native/${exports.VERSION}`;

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@zellio/chat-react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "ZeeChat for React Native: a thin wrapper over the native Zellio chat SDKs for iOS and Android.",
+  "license": "Apache-2.0",
+  "homepage": "https://zellio.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zellio-ai/zellio-chat-sdk.git",
+    "directory": "react-native"
+  },
+  "bugs": {
+    "url": "https://github.com/zellio-ai/zellio-chat-sdk/issues"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "lib",
+    "src",
+    "android",
+    "ios",
+    "plugin/build",
+    "app.plugin.js",
+    "ZellioChatReactNative.podspec",
+    "README.md",
+    "LICENSE",
+    "!**/__tests__",
+    "!android/build",
+    "!android/.gradle",
+    "!ios/build"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc -p plugin/tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p plugin/tsconfig.json",
+    "test": "vitest run",
+    "vendor:ios": "node scripts/vendor-ios.mjs",
+    "check:version": "node scripts/check-version.mjs",
+    "prepack": "node scripts/check-version.mjs && node scripts/vendor-ios.mjs && npm run build",
+    "ci": "bash scripts/ci-check.sh"
+  },
+  "codegenConfig": {
+    "name": "RNZellioChatSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "ai.zellio.chat.reactnative"
+    }
+  },
+  "peerDependencies": {
+    "expo": ">=58",
+    "react": ">=19.1",
+    "react-native": ">=0.82"
+  },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "~19.3.0",
+    "expo": "~58.0.22",
+    "react": "19.3.0",
+    "react-native": "0.88.1",
+    "typescript": "~6.0.2",
+    "vitest": "^4.1.11"
+  },
+  "overrides": {
+    "glob": "^14.0.2",
+    "minimatch": "^11.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin/build/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PHOTO_TEXT = exports.DEFAULT_CAMERA_TEXT = void 0;
+exports.applyInfoPlist = applyInfoPlist;
+exports.applyEntitlements = applyEntitlements;
+exports.applyMavenRepository = applyMavenRepository;
+const config_plugins_1 = require("expo/config-plugins");
+exports.DEFAULT_CAMERA_TEXT = 'Allow $(PRODUCT_NAME) to use the camera so you can send photos in chat.';
+exports.DEFAULT_PHOTO_TEXT = 'Allow $(PRODUCT_NAME) to access your photos so you can send them in chat.';
+/** Adds the usage texts. A key that the app already sets is never replaced. */
+function applyInfoPlist(plist, props) {
+    const out = { ...plist };
+    if (props.cameraPermission !== false && out.NSCameraUsageDescription === undefined) {
+        out.NSCameraUsageDescription = props.cameraPermission ?? exports.DEFAULT_CAMERA_TEXT;
+    }
+    if (props.photoLibraryPermission !== false && out.NSPhotoLibraryUsageDescription === undefined) {
+        out.NSPhotoLibraryUsageDescription = props.photoLibraryPermission ?? exports.DEFAULT_PHOTO_TEXT;
+    }
+    if (props.enableIosPush === true) {
+        const modes = Array.isArray(out.UIBackgroundModes) ? [...out.UIBackgroundModes] : [];
+        if (!modes.includes('remote-notification'))
+            modes.push('remote-notification');
+        out.UIBackgroundModes = modes;
+    }
+    return out;
+}
+/** Push entitlement. Only when asked. */
+function applyEntitlements(entitlements, props) {
+    if (props.enableIosPush !== true)
+        return entitlements;
+    if (entitlements['aps-environment'] !== undefined)
+        return entitlements;
+    return { ...entitlements, 'aps-environment': props.apsEnvironment ?? 'development' };
+}
+const MARKER = '// @zellio/chat-react-native';
+/** Adds a Maven repository to `allprojects.repositories`. Safe to run twice. */
+function applyMavenRepository(gradle, url) {
+    if (gradle.includes(MARKER))
+        return gradle;
+    const pattern = /allprojects\s*\{\s*repositories\s*\{/;
+    if (!pattern.test(gradle)) {
+        throw new Error('@zellio/chat-react-native: could not find allprojects { repositories { in android/build.gradle. ' +
+            `Add maven { url '${url}' } by hand.`);
+    }
+    const safe = url.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    return gradle.replace(pattern, (match) => `${match}\n        maven { url '${safe}' } ${MARKER}`);
+}
+const withZellioChat = (config, props) => {
+    const options = props ?? {};
+    config = (0, config_plugins_1.withInfoPlist)(config, (mod) => {
+        mod.modResults = applyInfoPlist(mod.modResults, options);
+        return mod;
+    });
+    if (options.enableIosPush === true) {
+        config = (0, config_plugins_1.withEntitlementsPlist)(config, (mod) => {
+            mod.modResults = applyEntitlements(mod.modResults, options);
+            return mod;
+        });
+    }
+    if (options.androidMavenRepository) {
+        const url = options.androidMavenRepository;
+        config = (0, config_plugins_1.withProjectBuildGradle)(config, (mod) => {
+            if (mod.modResults.language !== 'groovy') {
+                throw new Error('@zellio/chat-react-native: androidMavenRepository needs a Groovy android/build.gradle.');
+            }
+            mod.modResults.contents = applyMavenRepository(mod.modResults.contents, url);
+            return mod;
+        });
+    }
+    return config;
+};
+const pkg = require('../../package.json');
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withZellioChat, pkg.name, pkg.version);

package/src/NativeZellioChat.ts

@@ -0,0 +1,30 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Codegen spec. Do not import this file from app code: use the typed API in `index.ts`.
+ * Options travel as plain objects so the generated native code stays small; `index.ts` types them.
+ */
+export interface Spec extends TurboModule {
+  configure(appKey: string, options: CodegenTypes.UnsafeObject): void;
+  /** Registers the token provider on the native side. Native then asks JS through `onTokenRequest`. */
+  identify(): void;
+  /** Answers one `onTokenRequest`. Exactly one of `token` and `errorCode` is set. */
+  resolveToken(requestId: string, token: string | null, errorCode: string | null): void;
+  logout(): void;
+  present(): void;
+  presentConversation(conversationId: string | null): void;
+  dismiss(): void;
+  setContext(context: CodegenTypes.UnsafeObject | null): void;
+  getUnreadCount(): Promise<number>;
+  setPushToken(token: string, environment: string | null): void;
+  isZellioPush(payloadJson: string): boolean;
+  handlePush(payloadJson: string): Promise<boolean>;
+  handleNotificationTap(payloadJson: string): Promise<boolean>;
+
+  readonly onUnread: CodegenTypes.EventEmitter<{ count: number }>;
+  readonly onEvent: CodegenTypes.EventEmitter<{ name: string; code?: string }>;
+  readonly onTokenRequest: CodegenTypes.EventEmitter<{ requestId: string }>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNZellioChat');