@nascentdigital/funnel-apps 4.4.18

package/dist/reactnative/push/rn/PushClient.d.ts

@@ -0,0 +1,32 @@
+import * as Notifications from 'expo-notifications';
+export declare class PushClient {
+    private readonly _state$;
+    private readonly _token$;
+    private readonly _pushNotification$;
+    private readonly _pushResponse$;
+    private _onPushNotificationSubscription?;
+    private _onPushResponseSubscription?;
+    private _tokenSynced;
+    constructor(_: PushClient.Args);
+    get state$(): import("rxjs").Observable<PushClient.State>;
+    get state(): PushClient.State;
+    private set state(value);
+    get stableState(): Promise<PushClient.State>;
+    get token$(): import("rxjs").Observable<Notifications.ExpoPushToken | null | undefined>;
+    get token(): Notifications.ExpoPushToken | null | undefined;
+    private set token(value);
+    get tokenSynced(): boolean;
+    onTokenSynced(): void;
+    get pushNotification$(): import("rxjs").Observable<Notifications.Notification>;
+    get pushResponse$(): import("rxjs").Observable<Notifications.NotificationResponse>;
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendNotification(content: Notifications.NotificationContent): Promise<void>;
+    private onNotification;
+    private onNotificationSuccess;
+    private onNotificationError;
+}
+export declare namespace PushClient {
+    type Args = {};
+    type State = 'disconnected' | 'connecting' | 'connected' | 'error.config' | 'error.unsupported' | 'error.blocked' | 'error.unknown';
+}

package/dist/reactnative/push/rn/PushClient.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const expo_constants_1 = __importDefault(require("expo-constants"));
+const Device = __importStar(require("expo-device"));
+const Notifications = __importStar(require("expo-notifications"));
+const react_native_1 = require("react-native");
+const rxjs_1 = require("rxjs");
+// client
+class PushClient {
+    constructor(_) {
+        // initialize instance variables
+        this._state$ = new rxjs_1.BehaviorSubject('disconnected');
+        this._token$ = new rxjs_1.BehaviorSubject(undefined);
+        this._pushNotification$ = new rxjs_1.Subject();
+        this._pushResponse$ = new rxjs_1.Subject();
+        this._tokenSynced = false;
+    }
+    get state$() {
+        return this._state$.asObservable();
+    }
+    get state() {
+        return this._state$.getValue();
+    }
+    set state(state) {
+        // update only if changed
+        if (state !== this.state) {
+            this._state$.next(state);
+        }
+    }
+    get stableState() {
+        return (0, rxjs_1.firstValueFrom)(this._state$
+            .pipe((0, rxjs_1.filter)(state => state !== 'disconnected' && state !== 'connecting')));
+    }
+    get token$() {
+        return this._token$.asObservable();
+    }
+    get token() {
+        return this._token$.getValue();
+    }
+    set token(token) {
+        this._token$.next(token);
+    }
+    get tokenSynced() {
+        return this._tokenSynced;
+    }
+    onTokenSynced() {
+        this._tokenSynced = true;
+    }
+    get pushNotification$() {
+        return this._pushNotification$.asObservable();
+    }
+    get pushResponse$() {
+        return this._pushResponse$.asObservable();
+    }
+    async connect() {
+        var _a, _b, _c, _d, _e;
+        // skip if not uninitialized
+        if (this.state !== 'disconnected') {
+            console.warn('[PushClient/connect] attempt to initialize multiple times');
+            return;
+        }
+        // fail if on device
+        if (!Device.isDevice) {
+            console.warn('[PushClient/connect] push not supported in simulator - please deploy to device');
+            // update state
+            this.state = 'error.unsupported';
+            // mark token as unavailable
+            this.token = null;
+            // stop
+            return;
+        }
+        // or fail if we can't determine the project id
+        const projectId = (_d = (_c = (_b = (_a = expo_constants_1.default === null || expo_constants_1.default === void 0 ? void 0 : expo_constants_1.default.expoConfig) === null || _a === void 0 ? void 0 : _a.extra) === null || _b === void 0 ? void 0 : _b.eas) === null || _c === void 0 ? void 0 : _c.projectId) !== null && _d !== void 0 ? _d : (_e = expo_constants_1.default === null || expo_constants_1.default === void 0 ? void 0 : expo_constants_1.default.easConfig) === null || _e === void 0 ? void 0 : _e.projectId;
+        if (!projectId) {
+            console.warn('[PushClient/connect] Project ID cannot be resolved');
+            // update state
+            this.state = 'error.config';
+            // mark token as unavailable
+            this.token = null;
+            // stop
+            return;
+        }
+        // try to initialize/register push
+        try {
+            // mark initializing
+            this.state = 'connecting';
+            // register handler
+            Notifications.setNotificationHandler({
+                handleNotification: notification => this.onNotification(notification),
+                handleSuccess: notificationId => this.onNotificationSuccess(notificationId),
+                handleError: (notificationId, error) => this.onNotificationError(notificationId, error)
+            });
+            // TODO: allow this to be configured
+            // bind android notification channel
+            if (react_native_1.Platform.OS === 'android') {
+                await Notifications.setNotificationChannelAsync('default', {
+                    name: 'default',
+                    importance: Notifications.AndroidImportance.MAX,
+                    vibrationPattern: [0, 250, 250, 250],
+                    lightColor: '#FF231F7C'
+                });
+            }
+            // get current permissions
+            const { status: existingStatus } = await Notifications.getPermissionsAsync();
+            // try to request (again) if we don't have it
+            let finalStatus = existingStatus;
+            if (existingStatus !== 'granted') {
+                const { status } = await Notifications.requestPermissionsAsync();
+                finalStatus = status;
+            }
+            // handle blocked status (requires settings)
+            if (finalStatus !== 'granted') {
+                // update state
+                this.state = 'error.blocked';
+                this.token = null;
+            }
+            // or fetch/bind push token
+            else {
+                console.debug('[PushClient/initialize] fetching push token');
+                // fetch token
+                const token = await Notifications.getExpoPushTokenAsync({ projectId });
+                console.debug('[PushClient/initialize] retrieved token:', token.data);
+                // update state
+                this.state = 'connected';
+                // bind token
+                this.token = token;
+                // add notification listeners
+                this._onPushNotificationSubscription = Notifications.addNotificationReceivedListener(notification => {
+                    console.debug('[PushClient] received notification', notification);
+                    this._pushNotification$.next(notification);
+                });
+                this._onPushResponseSubscription = Notifications.addNotificationResponseReceivedListener(response => {
+                    console.debug('[PushClient] received response', response);
+                    this._pushResponse$.next(response);
+                });
+            }
+        }
+        // handle errors
+        catch (e) {
+            console.error('[PushClient/initialize] push registration failed', e);
+            // set state
+            this.state = 'error.unknown';
+            // mark token as unavailable
+            this.token = null;
+        }
+    }
+    disconnect() {
+        // unsubscribe
+        if (this._onPushNotificationSubscription) {
+            this._onPushNotificationSubscription.remove();
+            delete this._onPushNotificationSubscription;
+        }
+        if (this._onPushResponseSubscription) {
+            this._onPushResponseSubscription.remove();
+            delete this._onPushResponseSubscription;
+        }
+    }
+    async sendNotification(content) {
+        // fail if we're not ready
+        const state = await this.stableState;
+        if (state !== 'connected') {
+            console.warn('[PushClient/sendNotification] cannot send push in error state:', state);
+            return;
+        }
+        // fail if there's np token (shouldn't happen)
+        const { token } = this;
+        if (!token) {
+            console.warn('[PushClient/sendNotification] push token missing - unable to send');
+            return;
+        }
+        // send notification
+        try {
+            console.debug('[PushClient/sendNotification] sending token', { token, content });
+            // send to server
+            await fetch('https://exp.host/--/api/v2/push/send', {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Accept-encoding': 'gzip, deflate',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(Object.assign({ to: token }, content))
+            });
+            console.debug('[PushClient/sendNotification] sent local push', content);
+        }
+        catch (e) {
+            console.error('[PushClient/sendNotification] failed to send push', e);
+            // rethrow
+            throw new funnel_core_1.ServerError('Failed to send push notification');
+        }
+    }
+    async onNotification(notification) {
+        console.debug('[PushClient/onNotification] ', notification);
+        // TODO: evaluate message OR app state and decide
+        return {
+            shouldPlaySound: true,
+            shouldSetBadge: true,
+            shouldShowBanner: true,
+            shouldShowList: true
+        };
+    }
+    onNotificationSuccess(notificationId) {
+        console.debug('[PushClient/onNotificationSuccess] ', notificationId);
+    }
+    onNotificationError(notificationId, error) {
+        console.debug('[PushClient/onNotificationError] ', notificationId);
+    }
+}
+exports.PushClient = PushClient;

package/dist/reactnative/push/rn/PushContext.d.ts

@@ -0,0 +1,7 @@
+import { PushClient } from './PushClient';
+export declare const PushContext: import("react").Context<PushContext.Data>;
+export declare namespace PushContext {
+    type Data = {
+        pushClient?: PushClient;
+    };
+}

package/dist/reactnative/push/rn/PushContext.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushContext = void 0;
+const react_1 = require("react");
+// context
+exports.PushContext = (0, react_1.createContext)({});

package/dist/reactnative/push/rn/PushProvider.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare function PushProvider({ children }: PropsWithChildren): import("react").JSX.Element;

package/dist/reactnative/push/rn/PushProvider.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushProvider = PushProvider;
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const AppServiceClient_1 = require("../../app/rn/AppServiceClient");
+const core_1 = require("../../identity/core");
+const PushClient_1 = require("./PushClient");
+const PushContext_1 = require("./PushContext");
+// container
+function PushProvider({ children }) {
+    // bind context
+    const pushClient = (0, react_1.useMemo)(() => new PushClient_1.PushClient({}), []);
+    const context = (0, react_1.useMemo)(() => ({ pushClient }), [pushClient]);
+    const { identity } = (0, core_1.useIdentity)();
+    const touch = (0, hooks_1.useTouch)();
+    const { token } = pushClient;
+    // initialize push client on mount
+    (0, react_1.useEffect)(() => {
+        // handle connect
+        pushClient.connect()
+            .then(touch);
+        // disconnect on unmount
+        return () => pushClient.disconnect();
+    }, [pushClient, touch]);
+    // sync token
+    (0, react_1.useEffect)(() => {
+        // sync push if we have authenticated identity + a token
+        if (token && identity && identity instanceof core_1.AuthenticatedIdentity) {
+            AppServiceClient_1.AppServiceClient
+                .post({
+                apiToken: identity.apiToken,
+                id: '_nd-push',
+                method: 'subscribe.expo',
+                data: token.data
+            })
+                .then(() => console.error('[PushProvider] push token synced'))
+                .catch(e => console.error('[PushProvider] failed to sync expo push token', e));
+        }
+    }, [identity, token]);
+    // render
+    return (<PushContext_1.PushContext.Provider value={context}>
+      {children}
+    </PushContext_1.PushContext.Provider>);
+}

package/dist/reactnative/push/rn/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../domain';
+export * from './PushProvider';
+export * from './usePushClient';

package/dist/reactnative/push/rn/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../domain"), exports);
+__exportStar(require("./PushProvider"), exports);
+__exportStar(require("./usePushClient"), exports);

package/dist/reactnative/push/rn/usePushClient.d.ts

@@ -0,0 +1,3 @@
+import { PushClient } from './PushClient';
+export declare function usePossiblePushClient(): PushClient | undefined;
+export declare function usePushClient(): PushClient;

package/dist/reactnative/push/rn/usePushClient.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePossiblePushClient = usePossiblePushClient;
+exports.usePushClient = usePushClient;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const PushContext_1 = require("./PushContext");
+// hook
+function usePossiblePushClient() {
+    // bind memos + hooks
+    const { pushClient } = (0, react_1.useContext)(PushContext_1.PushContext);
+    const touch = (0, hooks_1.useTouch)();
+    // bind worker
+    (0, react_1.useEffect)(() => {
+        // skip if there's no client
+        if (!pushClient) {
+            return;
+        }
+        // bind client
+        const subscriptions = [
+            pushClient.state$.subscribe(() => touch()),
+            pushClient.token$.subscribe(() => touch()),
+        ];
+        // clear subscription on unmount
+        return () => subscriptions.forEach(subscription => subscription.unsubscribe());
+    }, [pushClient, touch]);
+    console.debug('[usePossiblePushClient] client:', pushClient);
+    // return client
+    return pushClient;
+}
+function usePushClient() {
+    // bind client (throw if not bound)
+    const client = usePossiblePushClient();
+    if (!client) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access usePushClient() outside of PushProvider scope');
+    }
+    // return client
+    return client;
+}

package/dist/reactnative/rn.d.ts

@@ -0,0 +1,7 @@
+export * from './app/rn';
+export * from './auth0/rn';
+export * from './bridge/rn';
+export * from './identity/rn';
+export * from './nav/rn';
+export * from './push/rn';
+export * from './ui/rn';

package/dist/reactnative/rn.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app/rn"), exports);
+__exportStar(require("./auth0/rn"), exports);
+__exportStar(require("./bridge/rn"), exports);
+__exportStar(require("./identity/rn"), exports);
+__exportStar(require("./nav/rn"), exports);
+__exportStar(require("./push/rn"), exports);
+__exportStar(require("./ui/rn"), exports);

package/dist/reactnative/ui/rn/Tailwind.d.ts

@@ -0,0 +1,175 @@
+import { Breakpoint, Breakpoints, PixelSize } from '@nascentdigital/funnel-core';
+import type { Config } from 'tailwindcss';
+export declare namespace Tailwind {
+    type CreateConfigArgs = {
+        content?: string[];
+        colors?: Record<string, string>;
+        safelist?: Config['safelist'];
+    };
+    function createConfig({ content, colors, safelist }: CreateConfigArgs): {
+        presets: any[];
+        content: string[];
+        safelist: import("tailwindcss/types/config").SafelistConfig[];
+        theme: {
+            screens: Record<Breakpoint, string>;
+            spacing: {
+                l1: string;
+                l2: string;
+                l3: string;
+                l4: string;
+                l5: string;
+                l6: string;
+                l7: string;
+                l8: string;
+                l9: string;
+                l10: string;
+                l11: string;
+                l12: string;
+                l13: string;
+                l14: string;
+                l15: string;
+                l16: string;
+                l17: string;
+                l18: string;
+                l19: string;
+                touchable: string;
+                icon: string;
+                "screen-md": `${number}px`;
+                "screen-sm": `${number}px`;
+                "screen-lg": `${number}px`;
+                "screen-xs": `${number}px`;
+                "screen-xl": `${number}px`;
+                initial: string;
+                revert: string;
+                unset: string;
+                '0': string;
+                px: string;
+            };
+            zIndex: {
+                tooltip: string;
+                popup: string;
+                dialogFab: string;
+                dialog: string;
+                superbackdrop: string;
+                superheader: string;
+                header: string;
+                subheader: string;
+                backdrop: string;
+                fab: string;
+                superoverlay: string;
+                overlay: string;
+                supersurface: string;
+                surface: string;
+                tint: string;
+                background: string;
+            };
+            rotate: {
+                '0': string;
+                '45': string;
+                '90': string;
+                '135': string;
+                '180': string;
+                '225': string;
+                '270': string;
+                '315': string;
+            };
+            aspectRatio: {
+                auto: string;
+                square: string;
+                camera: string;
+                cameraAlt: string;
+                video: string;
+                phone: string;
+                tv: string;
+                tvAlt: string;
+                computer: string;
+                widescreen: string;
+                cinema: string;
+                cinemascope: string;
+            };
+            colors: {
+                inherit: string;
+                current: string;
+                transparent: string;
+            };
+            opacity: {
+                l1: string;
+                l2: string;
+                l3: string;
+                l4: string;
+                l5: string;
+                hover: string;
+                focus: string;
+                press: string;
+                press_invert: string;
+                drag: string;
+                disabled: string;
+                faded: string;
+                backdrop: string;
+                none: string;
+                full: string;
+            };
+            fontFamily: {};
+            leading: {
+                none: string;
+                tight: string;
+                normal: string;
+                loose: string;
+            };
+            borderWidth: {
+                DEFAULT: string;
+                '0': string;
+                '2': string;
+                '3': string;
+                '4': string;
+                '8': string;
+            };
+            borderRadius: {
+                DEFAULT: string;
+                none: string;
+                xs: string;
+                sm: string;
+                md: string;
+                lg: string;
+                xl: string;
+                full: string;
+            };
+            boxShadow: {
+                none: string;
+                l1: string;
+                l2: string;
+                l3: string;
+                l4: string;
+                l5: string;
+                l6: string;
+                popup: string;
+                menu: string;
+                card: string;
+            };
+            extend: {
+                animation: {
+                    'spin-slow': string;
+                };
+                content: {
+                    empty: string;
+                };
+                transitionDuration: {
+                    '150': string;
+                    '250': string;
+                    '350': string;
+                    '400': string;
+                    '450': string;
+                    '500': string;
+                    '600': string;
+                    '800': string;
+                };
+            };
+        };
+        plugins: any[];
+    };
+    function toPixel(value: number): PixelSize;
+    function getScreens(breakpoints: Breakpoints): Record<Breakpoint, string>;
+    type ScreenSize = `screen-${Breakpoint}`;
+    function getScreenSizes(breakpoints: Breakpoints): Record<ScreenSize, PixelSize>;
+    function transformToRGB(colors: Record<string, string>): Record<string, string>;
+}