airbridge-react-native-sdk-restricted 2.8.9 → 4.1.0

package/source/module/WebInterface.ts

@@ -0,0 +1,55 @@
+import { NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+
+export const createDependency = () => {}
+
+type WebInterfaceInteractor = {
+    createWebInterfaceScript(webToken: string, postMessageScript: string): Promise<string>
+    handleWebInterfaceCommand(command: string): void
+}
+
+createDependency.WebInterfaceModule = () => ({
+    interactor: createInteractor<WebInterfaceInteractor>(NativeModules.WebInterfaceInteractor),
+})
+
+export type WebInterfaceModule = ReturnType<typeof createWebInterfaceModule>
+
+export const createWebInterfaceModule= () => {
+    // create dependency
+    const { interactor } = createDependency.WebInterfaceModule()
+
+    // define method
+    const createWebInterfaceScript = async (
+        webToken: string,
+        postMessageScript: string,
+    ) => {
+        if (!check.string(webToken)) {
+            log.unmatchedType('webToken', 'string')
+            return undefined
+        }
+        if (!check.string(postMessageScript)) {
+            log.unmatchedType('postMessageScript', 'string')
+            return undefined
+        }
+
+        return await interactor.createWebInterfaceScript(webToken, postMessageScript)
+    }
+    
+    const handleWebInterfaceCommand = (command: string) => {
+        if (!check.string(command)) {
+            log.unmatchedType('command', 'string')
+            return undefined
+        }
+
+        interactor.handleWebInterfaceCommand(command)
+    }
+
+    // create object
+    return {
+        createWebInterfaceScript,
+        handleWebInterfaceCommand,
+    }
+}

package/source/module.ts

@@ -0,0 +1,3 @@
+export { Airbridge } from './Airbridge'
+export * from './constant/AirbridgeAttribute'
+export * from './constant/AirbridgeCategory'

package/source/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "target": "ES2015",
+        "lib": ["ES2015"],
+        "types": ["react-native"],
+        "outDir": "../build/source",
+        "declaration": true,
+        "sourceMap": true,
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "moduleResolution": "node",
+        "esModuleInterop": true
+    }
+}

package/source/utility/check.ts

@@ -0,0 +1,46 @@
+export const check = {
+    defined: <Value> (value: Value): value is Exclude<Value, undefined> => (
+        value !== undefined
+    ),
+
+    undefined: (value: unknown): value is undefined => (
+        value === undefined
+    ),
+
+    null: (value: unknown): value is null => (
+        value === null
+    ),
+
+    object: (value: unknown): value is Record<string, unknown> => (
+        value !== null
+        && (typeof value === 'object' || value instanceof Object)
+    ),
+
+    array: (value: unknown): value is Array<unknown> => (
+        Array.isArray(value)
+    ),
+
+    string: (value: unknown): value is string => (
+        typeof value === 'string' || value instanceof String
+    ),
+
+    number: (value: unknown): value is number => (
+        typeof value === 'number' || value instanceof Number
+    ),
+
+    function: (value: unknown): value is Function => (
+        typeof value === 'function' || value instanceof Function
+    ),
+
+    promise: (value: unknown): value is Promise<unknown> => (
+        value instanceof Promise
+    ),
+
+    actual: <Actual> (value: unknown, actual: Actual): value is Actual => (
+        value === actual
+    ),
+
+    boolean: (value: unknown): value is boolean => (
+        typeof value === 'boolean' || value instanceof Boolean
+    ),
+}

package/source/utility/compute.ts

@@ -0,0 +1,9 @@
+import { check } from './check'
+
+export const compute = {
+    defined: <Value, Result> (
+        value: Value, block: (value: Exclude<Value, undefined>) => Result
+    ): Result | undefined => (
+        check.defined(value) ? block(value) : undefined
+    )
+}

package/source/utility/create.ts

@@ -0,0 +1,12 @@
+export const create = {
+    object: {
+        fromEntries: <Value> (array: [string, Value][]): Record<string, Value> => {
+            const object: Record<string, Value> = {}
+            array.forEach(([key, value]) => {
+                object[key] = value
+            })
+    
+            return object
+        },
+    },
+}

package/source/utility/extract.ts

@@ -0,0 +1,5 @@
+export const extract = {
+    entries: <Value> (object: Record<string, Value> | Value[]): [string, Value][] => (
+        Object.keys(object).map(key => [key, (object as Record<string, Value>)[key]!])
+    ),
+}

package/source/utility/json.ts

@@ -0,0 +1,180 @@
+import { check } from './check'
+import { compute } from './compute'
+import { create } from './create'
+import { extract } from './extract'
+
+export type JSONObject = {
+    [key: string]: JSONElement
+}
+
+export type JSONArray = JSONElement[]
+
+export type JSONElement = JSONObject | JSONArray | string | number | boolean | null
+
+export const createJSONObject = (object: unknown): JSONObject | undefined => {
+    if (!check.object(object)) {
+        return undefined
+    }
+
+    return create.object.fromEntries(extract.entries(object).map(([key, value]): [string, JSONElement] | undefined => {
+        if (!check.string(key)) {
+            return undefined
+        }
+
+        if (
+            !check.string(value)
+            && !check.number(value)
+            && !check.boolean(value)
+            && !check.array(value)
+            && !check.object(value)
+            && !check.null(value)
+        ) {
+            return undefined
+        }
+
+        if (check.array(value)) {
+            return compute.defined(createJSONArray(value), array => {
+                return [key, array]
+            })
+        }
+        if (check.object(value)) {
+            return compute.defined(createJSONObject(value), object => {
+                return [key, object]
+            })
+        }
+
+        return [key, value]
+    }).filter(value => check.defined(value)))
+}
+
+export const createJSONArray = (array: unknown): JSONArray | undefined => {
+    if (!check.array(array)) {
+        return undefined
+    }
+
+    return array.map((value): JSONElement | undefined => {
+        if (
+            !check.string(value)
+            && !check.number(value)
+            && !check.boolean(value)
+            && !check.array(value)
+            && !check.object(value)
+            && !check.null(value)
+        ) {
+            return undefined
+        }
+
+        if (check.array(value)) {
+            return createJSONArray(value)
+        }
+        if (check.object(value)) {
+            return createJSONObject(value)
+        }
+
+        return value
+    }).filter(value => check.defined(value))
+}
+
+export const createJSONElement = (element: unknown): JSONElement | undefined => {
+    if (
+        !check.string(element)
+        && !check.number(element)
+        && !check.boolean(element)
+        && !check.array(element)
+        && !check.object(element)
+        && !check.null(element)
+    ) {
+        return undefined
+    }
+
+    if (check.array(element)) {
+        return createJSONArray(element)
+    }
+    if (check.object(element)) {
+        return createJSONObject(element)
+    }
+
+    return element
+}
+
+export const checkJSONObject = (object: unknown): object is JSONObject => {
+    if (!check.object(object)) {
+        return false
+    }
+
+    for (const [key, value] of extract.entries(object)) {
+        if (!check.string(key)) {
+            return false
+        }
+
+        if (
+            !check.string(value)
+            && !check.number(value)
+            && !check.boolean(value)
+            && !check.array(value)
+            && !check.object(value)
+            && !check.null(value)
+        ) {
+            return false
+        }
+
+        if (check.array(value) && !checkJSONArray(value)) {
+            return false
+        }
+        if (check.object(value) && !checkJSONObject(value)) {
+            return false
+        }
+    }
+
+    return true
+}
+
+export const checkJSONArray = (array: unknown): array is JSONArray => {
+    if (!check.array(array)) {
+        return false
+    }
+
+    for (const value of array) {
+        if (
+            !check.string(value)
+            && !check.number(value)
+            && !check.boolean(value)
+            && !check.array(value)
+            && !check.object(value)
+            && !check.null(value)
+        ) {
+            return false
+        }
+
+        if (check.array(value) && !checkJSONArray(value)) {
+            return false
+        }
+        if (check.object(value) && !checkJSONObject(value)) {
+            return false
+        }
+    }
+
+    return true
+}
+
+export const checkJSONElement = (element: unknown): element is JSONElement => {
+    if (
+        !check.string(element)
+        && !check.number(element)
+        && !check.boolean(element)
+        && !check.array(element)
+        && !check.object(element)
+        && !check.null(element)
+    ) {
+        return false
+    }
+
+    if (check.array(element) && !checkJSONArray(element)) {
+        return false
+    }
+    if (check.object(element) && !checkJSONObject(element)) {
+        return false
+    }
+
+    return true
+}

package/source/utility/log.ts

@@ -0,0 +1,14 @@
+export const log = {
+    unmatchedType: (
+        name: string, 
+        type: 'string' | 'object' | 'object?' | 'function' | 'function?',
+    ) => {
+        console.warn(`Unmatched type: ${name} is not ${type}.`)
+    },
+
+    nonJSONValue: (
+        name: string,
+    ) => {
+        console.warn(`Non-json value: ${name} includes non-json value which is ignored by Airbridge.`)
+    },
+}

package/test/jest.json

@@ -0,0 +1,13 @@
+{
+    "rootDir": "..",
+    "preset": "react-native",
+    "transform": {
+        "\\.(ts|js)$": ["babel-jest", {
+            "presets": ["module:@react-native/babel-preset"]
+        }]
+    },
+    "testEnvironment": "node",
+    "testMatch": [
+        "<rootDir>/test/**/*.test.ts"
+    ]
+}

package/test/mock.ts

@@ -0,0 +1,112 @@
+type ArrowFunction<Return = any, Parameters extends any[] = any[]> = (...args: Parameters) => Return
+
+type And<Condition0 extends boolean, Condition1 extends boolean> = Condition0 extends true ? (Condition1 extends true ? true : false) : false
+type Not<Condition extends boolean> = Condition extends true ? false : true
+
+type IsAny<Type> = (any extends Type ? true : false) extends true ? true : false
+type Is<Type, Expect> = Not<IsAny<Type>> extends true ? (Type extends Expect ? true : false) : false
+
+type Opt<Type, Condition extends boolean> = Condition extends true ? Type : never
+type Cast<Type, Condition> = Type extends Condition ? Type : never
+
+type PropertyValue<Type> = {
+    [Key in keyof Type as Opt<Key, Not<Is<Type[Key], object | ArrowFunction>>>]: Type[Key]
+}
+type PropertyObject<Type> = {
+    [Key in keyof Type as Opt<Key, And<Is<Type[Key], object>, Not<Is<Type[Key], ArrowFunction>>>>]: Type[Key]
+}
+type Interface<Type> = {
+    [Key in keyof Type as Opt<Key, Is<Type[Key], ArrowFunction>>]: Cast<Type[Key], ArrowFunction>
+}
+
+type MockPropertyValue<Type> = PropertyValue<Type> & {
+    readonly [Key in 'getMock' as Opt<Key, Is<keyof PropertyValue<Type>, string>>]: {
+        readonly [Key in keyof PropertyValue<Type>]: jest.Mock<PropertyValue<Type>[Key], []>
+    }
+} & {
+    readonly [Key in 'setMock' as Opt<Key, Is<keyof PropertyValue<Type>, string>>]: {
+        readonly [Key in keyof PropertyValue<Type>]: jest.Mock<void, [PropertyValue<Type>[Key]]>
+    }
+}
+type MockPropertyObject<Type> = {
+    readonly [Key in keyof PropertyObject<Type>]: Mock<PropertyObject<Type>[Key]>
+}
+type MockInterface<Type> = {
+    readonly [Key in keyof Interface<Type>]: jest.Mock<ReturnType<Interface<Type>[Key]>, Parameters<Interface<Type>[Key]>>
+}
+
+export type Mock<Type> = MockPropertyValue<Type> & MockPropertyObject<Type> & MockInterface<Type>
+
+export const createMock = <Type>(): Mock<Type> => {
+    const values: Record<string, any> = {}
+    const mocks: Record<string, any> = {}
+
+    const prepareValue = (name: string) => {
+        if (!(name in values)) {
+            values[name] = {
+                value: undefined,
+                getMock: jest.fn(() => {
+                    return values[name].value
+                }),
+                setMock: jest.fn((value) => {
+                    values[name].value = value
+                }),
+            }
+        }
+    }
+
+    const getMock = new Proxy({}, {
+        get: (_, name: string) => {
+            prepareValue(name)
+            return values[name].getMock
+        },
+        set: () => {
+            return false
+        },
+    })
+
+    const setMock = new Proxy({}, {
+        get: (_, name: string) => {
+            prepareValue(name)
+            return values[name].setMock
+        },
+        set: () => {
+            return false
+        },
+    })
+
+    return new Proxy(jest.fn(), {
+        apply: (call: any, _, argument) => {
+            return call(...argument)
+        },
+        get: (call: any, name: string) => {
+            if (name in call || name === 'calls') {
+                return call[name]
+            }
+
+            if (name in values) {
+                return values[name].getMock()
+            }
+
+            if (name === 'getMock') {
+                return getMock
+            }
+
+            if (name === 'setMock') {
+                return setMock
+            }
+
+            if (!(name in mocks)) {
+                mocks[name] = createMock()
+            }
+
+            return mocks[name]
+        },
+        set: (_, name: string, value: any) => {
+            prepareValue(name)
+            values[name].setMock(value)
+
+            return true
+        },
+    }) as any as Mock<Type>
+}

package/test/module/Deeplink.test.ts

@@ -0,0 +1,29 @@
+import { DeeplinkModule, DeeplinkModuleDependency, createDeeplinkModule, createDependency } from '../../source/module/Deeplink'
+import { createMock, Mock } from '../mock'
+
+describe('Deeplink', () => {
+    test('offer last deeplink received before javascript initialization', async () => {
+        deeplink = createDeeplinkModule()
+
+        const emit = dependency.emitter.addListener.mock.calls[0][1]
+        emit('1')
+        emit('2')
+        emit('3')
+
+        const first = await new Promise((resolve) => {
+            deeplink.setOnDeeplinkReceived((deeplink) => {
+                resolve(deeplink)
+            })
+        })
+
+        expect(first).toBe('3')
+    })
+
+    let deeplink: DeeplinkModule
+    let dependency: Mock<DeeplinkModuleDependency>
+
+    beforeEach(() => {
+        dependency = createMock()
+        createDependency.DeeplinkModule = () => dependency
+    })
+})

package/test/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "types": ["react-native", "jest"],
+        "moduleResolution": "node",
+        "esModuleInterop": true
+    }
+}

package/.eslintrc.json

@@ -1,44 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "es6": true
-    },
-    "extends": "airbnb",
-    "parser": "babel-eslint",
-    "globals": {
-        "Atomics": "readonly",
-        "SharedArrayBuffer": "readonly"
-    },
-    "parserOptions": {
-        "ecmaFeatures": {
-            "jsx": true
-        },
-        "ecmaVersion": 2018,
-        "sourceType": "module"
-    },
-    "plugins": [
-        "react"
-    ],
-    "rules": {
-        "indent": [
-            "off"
-            // ,
-            // "error",
-            // "tab",
-        ],
-        "no-console": "off",
-        "no-tabs": "off",
-        "class-methods-use-this": "off",
-        "import/no-extraneous-dependencies": [
-            "error",
-            {
-                "devDependencies": true
-            }
-        ],
-        "no-underscore-dangle": "off",
-        "no-param-reassign": "off",
-        "no-useless-constructor": "off",
-        "no-empty-function": "off",
-        "padded-blocks": "off"
-    }
-}

package/.gitattributes

@@ -1 +0,0 @@
-*.pbxproj -text

package/.github/actions/add-github-check/action.yml

@@ -1,78 +0,0 @@
-name: 'Add GitHub check'
-description: Add GitHub check
-
-inputs:
-  owner:
-    description: Owner of repository
-    type: string
-    default: ${context.repo.owner}
-    required: false
-  repository:
-    description: Repository of release
-    type: string
-    default: ${context.repo.repo}
-    required: false
-  name:
-    description: Name of check
-    type: string
-    default: ${{ github.workflow }}
-    required: false
-  pull-request-number:
-    description: Pull request of check
-    type: string
-    default: ${context.issue.number}
-    required: false
-  detail-url:
-    description: Detail URL of check
-    type: string
-    default: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-    required: false
-  conclusion:
-    description: Conclusion of check if status is completed (success, failure)
-    type: string
-    default: 'success'
-    required: false
-  token:
-    description: GitHub Token
-    type: string
-    required: false
-  status:
-    description: Status of check (queued, in_progress, completed)
-    type: string
-    required: true
-
-outputs:
-  check-id:
-    description: ID of added check
-    value: ${{ steps.add-check.outputs.result }}
-runs:
-  using: 'composite'
-  steps:
-    - name: Add check
-      id: add-check
-      uses: actions/github-script@v7
-      with:
-        script: |
-          const { data: { id: id } } = await github.rest.checks.create({
-            owner: `${{ inputs.owner }}`,
-            repo: `${{ inputs.repository }}`,
-            name: `${{ inputs.name }}`,
-            head_sha: await (async () => {
-              const { data: { head: { sha: sha } } } = await github.rest.pulls.get({
-                owner: `${{ inputs.owner }}`,
-                repo: `${{ inputs.repository }}`,
-                pull_number: `${{ inputs.pull-request-number }}`,
-              })
-              return sha
-            })(),
-            details_url: `${{ inputs.detail-url }}`,
-            status: `${{ inputs.status }}`,
-            conclusion: (() => {
-              if (`${{ inputs.status }}` !== 'completed') {
-                return undefined
-              }
-              return `${{ inputs.conclusion }}`
-            })(),
-          })
-          return id
-        github-token: ${{ inputs.token || env.GITHUB_TOKEN || github.token }}

package/.github/actions/add-github-comment/action.yml

@@ -1,48 +0,0 @@
-name: 'Add GitHub comment'
-description: Add GitHub comment
-
-inputs:
-  issue-number:
-    description: Issue to comment
-    type: string
-    default: ${context.issue.number}
-    required: false
-  owner:
-    description: Owner of repository
-    type: string
-    default: ${context.repo.owner}
-    required: false
-  repository:
-    description: Repository of release
-    type: string
-    default: ${context.repo.repo}
-    required: false
-  token:
-    description: GitHub Token
-    type: string
-    required: false
-  comment:
-    description: Comment
-    type: string
-    required: true
-
-outputs:
-  comment-id:
-    description: ID of added comment
-    value: ${{ steps.add-comment.outputs.result }}
-runs:
-  using: 'composite'
-  steps:
-    - name: Add comment
-      id: add-comment
-      uses: actions/github-script@v7
-      with:
-        script: |
-          const { data: { id: id } } = await github.rest.issues.createComment({
-            issue_number: `${{ inputs.issue-number }}`,
-            owner: `${{ inputs.owner }}`,
-            repo: `${{ inputs.repository }}`,
-            body: `${{ inputs.comment }}`,
-          })
-          return id
-        github-token: ${{ inputs.token || env.GITHUB_TOKEN || github.token }}