@rownd/react-native 0.1.1

package/src/index.tsx.bak

@@ -0,0 +1,26 @@
+import {
+  requireNativeComponent,
+  UIManager,
+  Platform,
+  ViewStyle,
+} from 'react-native';
+
+const LINKING_ERROR =
+  `The package '@rownd/react-native' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo managed workflow\n';
+
+type ReactNativeProps = {
+  color: string;
+  style: ViewStyle;
+};
+
+const ComponentName = 'ReactNativeView';
+
+export const ReactNativeView =
+  UIManager.getViewManagerConfig(ComponentName) != null
+    ? requireNativeComponent<ReactNativeProps>(ComponentName)
+    : () => {
+        throw new Error(LINKING_ERROR);
+      };

package/src/types.ts

@@ -0,0 +1,27 @@
+export type TRowndContext = {
+    requestSignIn: Function;
+    signOut: Function;
+    getAccessToken: Function;
+    is_authenticated: boolean;
+    is_initializing: boolean;
+    access_token: string | null;
+    auth: AuthContext;
+    user: UserContext;
+};
+
+type AuthContext = {
+    access_token: string | null;
+    app_id?: string;
+    is_authenticated: boolean;
+    is_verified_user?: boolean;
+};
+
+type UserContext = {
+    data: {
+        id?: string;
+        email?: string | null;
+        phone?: string | null;
+        [key: string]: any;
+    };
+    redacted_fields: string[];
+};

package/src/utils/config.ts

@@ -0,0 +1,36 @@
+import pickBy from 'lodash-es/pickBy';
+
+export interface IConfig {
+  baseUrl: string;
+  apiUrl: string;
+  pdcBaseUrl: string;
+  appKey: string;
+  postLoginUrl: null | string;
+  postRegistrationUrl: null | string;
+  locationHash: null | string;
+  postAuthenticationApi: null | PostAuthApiSpec;
+}
+
+const config: IConfig = {
+  baseUrl: 'https://hub.rownd.io',
+  apiUrl: 'https://api.rownd.io',
+  pdcBaseUrl: 'https://mydata.rownd.io',
+  appKey: '',
+  postLoginUrl: null,
+  postRegistrationUrl: null,
+  locationHash: null,
+  postAuthenticationApi: null,
+};
+
+export type PostAuthApiSpec = {
+  method: 'post' | 'put';
+  url: string;
+  extra_headers: { [key: string]: string };
+};
+
+export function createConfig(opts: Partial<IConfig>): IConfig {
+  return {
+    ...config,
+    ...pickBy(opts),
+  };
+}

package/src/utils/events.ts

@@ -0,0 +1,54 @@
+import EventEmitter from 'eventemitter3';
+const bus = new EventEmitter();
+
+export enum EventType {
+  AUTH = 'auth',
+  SIGN_OUT = 'sign_out',
+  USER_DATA = 'user_data',
+  USER_DATA_SAVED = 'user_data_saved',
+}
+
+export type TAuthEvent = {
+  access_token: string;
+  user_id: string;
+  app_id: string;
+};
+
+type EventListenerOptions = {
+  once?: boolean;
+};
+
+export const events = {
+  addEventListener: (
+    type: string,
+    callback: (...args: any[]) => void | null,
+    options?: boolean | EventListenerOptions | undefined
+  ): void => {
+    if (!Object.values<string>(EventType).includes(type)) {
+      console.warn(`Unknown event type: ${type}`);
+      return;
+    }
+
+    let busFn = bus.on;
+    if (options === true || (options as EventListenerOptions)?.once) {
+      busFn = bus.once;
+    }
+
+    busFn.apply(bus, [type, callback, options]);
+  },
+  removeEventListener: bus.removeListener,
+  dispatchEvent: (event: CustomEvent): boolean => {
+    if (!Object.values<string>(EventType).includes(event.type)) {
+      throw new Error(`Unknown event type: ${event.type}`);
+    }
+
+    return bus.emit(event.type, event.detail);
+  },
+  dispatch(type: EventType, data: any): boolean {
+    if (!Object.values<string>(EventType).includes(type)) {
+      throw new Error(`Unknown event type: ${type}`);
+    }
+
+    return bus.emit(type, data);
+  },
+};

package/src/utils/form.tsx

@@ -0,0 +1,64 @@
+import { Text, TextInput } from 'react-native';
+import { Picker } from '@react-native-picker/picker';
+import React from 'react';
+
+type FormFieldProps = {
+  id?: string;
+  name: string;
+  value?: string;
+  type?: string;
+  label?: string;
+  placeholder?: string;
+  options?:
+    | [
+        {
+          value: string;
+          label: string;
+        }
+      ]
+    | null;
+  onChange?: (value: string) => void;
+};
+
+export function renderField({
+  id,
+  label = '',
+  name,
+  type = 'input',
+  value,
+  placeholder,
+  options = null,
+  onChange,
+}: FormFieldProps) {
+  if (!id) {
+    id = `rph-input-${name}`;
+  }
+
+  return (
+    <>
+      {label && <Text>{label}</Text>}
+
+      {type === 'select' && (
+        <Picker
+          onValueChange={onChange}
+          selectedValue={value || options?.[0]?.value}
+        >
+          {options?.map((opt) => (
+            <Picker.Item value={opt.value} key={opt.value}>
+              {' '}
+              {opt.label}{' '}
+            </Picker.Item>
+          ))}
+        </Picker>
+      )}
+
+      {type === 'input' && (
+        <TextInput
+          value={value}
+          placeholder={placeholder}
+          onChangeText={onChange}
+        />
+      )}
+    </>
+  );
+}

package/src/utils/queue.ts

@@ -0,0 +1,75 @@
+// import { logger } from "./utils/log";
+
+let count = 0;
+
+type QueueItem = {
+  action: () => Promise<any>;
+  resolve: (value?: any) => void;
+  reject: (reason?: any) => void;
+  count: number;
+};
+
+class Queue {
+  #_items: any[];
+  constructor() {
+    this.#_items = [];
+  }
+  enqueue(item: QueueItem | (() => Promise<any>)) {
+    this.#_items.push(item);
+  }
+  dequeue(): any {
+    return this.#_items.shift();
+  }
+  get size() {
+    return this.#_items.length;
+  }
+}
+
+class AutoQueue<T> extends Queue {
+  _cache: Record<string, unknown>;
+  #_pendingPromise: boolean;
+  constructor() {
+    super();
+    this.#_pendingPromise = false;
+    this._cache = {};
+  }
+
+  enqueue(action: () => Promise<any>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      super.enqueue({ action, resolve, reject, count: count++ });
+      // logger.log('queued', count);
+      this.dequeue();
+    });
+  }
+
+  async dequeue() {
+    if (this.#_pendingPromise) return false;
+
+    const item = super.dequeue();
+
+    if (!item) {
+      this._cache = {};
+      return false;
+    }
+
+    // logger.log('dequeued', item.count);
+
+    try {
+      this.#_pendingPromise = true;
+
+      const payload = await item.action(this);
+
+      this.#_pendingPromise = false;
+      item.resolve(payload);
+    } catch (e) {
+      this.#_pendingPromise = false;
+      item.reject(e);
+    } finally {
+      this.dequeue();
+    }
+
+    return true;
+  }
+}
+
+export default AutoQueue;

package/src/utils/storage.ts

@@ -0,0 +1,7 @@
+import { MMKV } from 'react-native-mmkv';
+
+const storage = new MMKV({
+  id: 'rownd-storage',
+});
+
+export default storage;

package/src/utils/tailwind.ts

@@ -0,0 +1,6 @@
+import { create } from 'twrnc';
+import twConfig from '../../tailwind.config.js';
+
+const tw = create(twConfig);
+
+export default tw;

package/src/utils/tokens.ts

@@ -0,0 +1,26 @@
+import jwt_decode from 'jwt-decode';
+
+type TokenInput = Record<string, any> | string;
+
+// Make sure token is always in a decoded form
+function normalizeToken(token: TokenInput): Record<string, any> {
+  if (typeof token === 'string') {
+    return jwt_decode(token);
+  }
+
+  return token;
+}
+
+export function getAppId(token: TokenInput) {
+  token = normalizeToken(token);
+
+  return token?.aud
+    ?.find((aud: string) => aud.startsWith('app:'))
+    ?.substring(4);
+}
+
+export function getUserId(token: TokenInput) {
+  token = normalizeToken(token);
+
+  return token?.sub;
+}

package/src/utils/user-data.ts

@@ -0,0 +1,15 @@
+export function redactUserDataWithAcls(
+  userData: Record<string, any> | undefined | null,
+  acls: Record<string, { shared: boolean }> | undefined | null
+): Record<string, any> {
+  if (!userData) {
+    return {};
+  }
+  return Object.entries(userData).reduce(
+    (acc: Record<string, any>, [key, value]) => {
+      acc[key] = !acls?.[key] || acls?.[key]?.shared ? value : 'ROWND_REDACTED';
+      return acc;
+    },
+    {}
+  );
+}