@firebolt-js/core-client 1.0.0-next.5

package/dist/lib/Prop/Router.mjs

@@ -0,0 +1,25 @@
+export default function (params, callbackOrValue, contextParameterCount) {
+  const numArgs = params ? Object.values(params).length : 0
+
+  if (numArgs === contextParameterCount && callbackOrValue === undefined) {
+    // getter
+    return 'getter'
+  } else if (
+    numArgs === contextParameterCount &&
+    typeof callbackOrValue === 'function'
+  ) {
+    // subscribe
+    return 'subscriber'
+  } else if (numArgs === 0 && typeof callbackOrValue === 'function') {
+    // subscribe
+    return 'subscriber'
+  } else if (
+    numArgs === contextParameterCount &&
+    callbackOrValue !== undefined
+  ) {
+    // setter
+    return 'setter'
+  }
+
+  return null
+}

package/dist/lib/Prop/index.mjs

@@ -0,0 +1,60 @@
+import Gateway from '../Gateway/index.mjs'
+import Events from '../Events/index.mjs'
+import router from './Router.mjs'
+
+function prop(
+  moduleName,
+  key,
+  params,
+  callbackOrValue = undefined,
+  immutable,
+  readonly,
+  contextParameterCount,
+) {
+  const numArgs = Object.values(params).length
+  const type = router(params, callbackOrValue, contextParameterCount)
+
+  if (type === 'getter') {
+    return Gateway.request(moduleName + '.' + key, params)
+  } else if (type === 'subscriber') {
+    // subscriber
+    if (immutable) {
+      throw new Error('Cannot subscribe to an immutable property')
+    }
+    const subscriber =
+      'on' + key[0].toUpperCase() + key.substring(1) + 'Changed'
+    return Events.listen(
+      moduleName,
+      subscriber,
+      ...Object.values(params),
+      callbackOrValue,
+    )
+  } else if (type === 'setter') {
+    // setter
+    if (immutable) {
+      throw new Error('Cannot set a value to an immutable property')
+    }
+    if (readonly) {
+      throw new Error('Cannot set a value to a readonly property')
+    }
+    return Gateway.request(
+      moduleName + '.set' + key[0].toUpperCase() + key.substring(1),
+      Object.assign(
+        {
+          value: callbackOrValue,
+        },
+        params,
+      ),
+    )
+  } else if (numArgs < contextParameterCount) {
+    throw new Error(
+      'Cannot get a value without all required context parameters.',
+    )
+  } else {
+    throw new Error('Property accessed with unexpected number of parameters.')
+  }
+}
+
+export default {
+  prop: prop,
+}

package/dist/lib/Settings/index.mjs

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2021 Comcast Cable Communications Management, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const settings = { platform: {} }
+const subscribers = {}
+
+export const initSettings = (appSettings, platformSettings) => {
+  settings['app'] = appSettings
+  settings['platform'] = {
+    logLevel: 'WARN',
+    ...platformSettings,
+  }
+  settings['user'] = {}
+}
+
+const publish = (key, value) => {
+  subscribers[key] &&
+    subscribers[key].forEach((subscriber) => subscriber(value))
+}
+
+const dotGrab = (obj = {}, key) => {
+  const keys = key.split('.')
+  for (let i = 0; i < keys.length; i++) {
+    obj = obj[keys[i]] = obj[keys[i]] !== undefined ? obj[keys[i]] : {}
+  }
+  return typeof obj === 'object'
+    ? Object.keys(obj).length
+      ? obj
+      : undefined
+    : obj
+}
+
+export default {
+  get(type, key, fallback = undefined) {
+    const val = dotGrab(settings[type], key)
+    return val !== undefined ? val : fallback
+  },
+  has(type, key) {
+    return !!this.get(type, key)
+  },
+  set(key, value) {
+    settings['user'][key] = value
+    publish(key, value)
+  },
+  subscribe(key, callback) {
+    subscribers[key] = subscribers[key] || []
+    subscribers[key].push(callback)
+  },
+  unsubscribe(key, callback) {
+    if (callback) {
+      const index =
+        subscribers[key] && subscribers[key].findIndex((cb) => cb === callback)
+      index > -1 && subscribers[key].splice(index, 1)
+    } else {
+      if (key in subscribers) {
+        subscribers[key] = []
+      }
+    }
+  },
+  clearSubscribers() {
+    for (const key of Object.getOwnPropertyNames(subscribers)) {
+      delete subscribers[key]
+    }
+  },
+  setLogLevel(logLevel) {
+    settings.platform.logLevel = logLevel
+  },
+  getLogLevel() {
+    return settings.platform.logLevel
+  },
+}

package/dist/lib/Transport/MockTransport.mjs

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2021 Comcast Cable Communications Management, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import Gateway from '../Gateway/index.mjs'
+
+const win = typeof window !== 'undefined' ? window : {}
+
+let listener
+export const setMockListener = (func) => {
+  listener = func
+}
+
+let mock
+const pending = []
+
+let callback
+let testHarness
+
+if (win.__firebolt && win.__firebolt.testHarness) {
+  testHarness = win.__firebolt.testHarness
+}
+
+function send(message) {
+  const json = JSON.parse(message)
+  // handle bulk sends
+  if (Array.isArray(json)) {
+    json.forEach((json) => send(JSON.stringify(json)))
+    return
+  }
+
+  //let [module, method] = json.method.split('.')
+
+  if (testHarness && testHarness.send) {
+    testHarness.send(message)
+  }
+
+  if (json.method) {
+    if (mock) handle(json)
+    else pending.push(json)
+  } else if (json.id !== undefined && requests[json.id]) {
+    const promise = requests[json.id]
+    if (json.error !== undefined) {
+      promise.reject(json.error)
+    } else {
+      promise.resolve(json.result)
+    }
+
+    delete requests[json.id]
+  }
+}
+
+function handle(json) {
+  let result
+  try {
+    result = getResult(json.method, json.params)
+    setTimeout(() =>
+      callback(
+        JSON.stringify({
+          jsonrpc: '2.0',
+          result: result,
+          id: json.id,
+        }),
+      ),
+    )
+  } catch (error) {
+    setTimeout(() =>
+      callback(
+        JSON.stringify({
+          jsonrpc: '2.0',
+          error: {
+            code: -32602,
+            message:
+              'Invalid params (this is a mock error from the mock transport layer)',
+          },
+          id: json.id,
+        }),
+      ),
+    )
+  }
+}
+
+function receive(_callback) {
+  callback = _callback
+
+  if (testHarness && typeof testHarness.initialize === 'function') {
+    testHarness.initialize({
+      emit: (module, method, value) => {
+        Gateway.simulate(`${module}.${method}`, value)
+      },
+      listen: function (...args) {
+        listener(...args)
+      },
+    })
+  }
+}
+
+function event(module, event, data) {
+  callback(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      method: `${module}.${event}`,
+      params: {
+        value: data,
+      },
+    }),
+  )
+}
+
+function receiveMessage(message) {
+  callback(message)
+}
+
+let id = 0
+const requests = []
+
+function request(method, params) {
+  const requestId = id++
+  const promise = new Promise((resolve, reject) => {
+    requests[requestId] = { resolve, reject }
+  })
+  callback(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      id: requestId,
+      method: `${method}`,
+      params: params,
+    }),
+  )
+
+  return promise
+}
+
+function dotGrab(obj = {}, key) {
+  const keys = key.split('.')
+  let ref = obj
+  for (let i = 0; i < keys.length; i++) {
+    ref = (Object.entries(ref).find(
+      ([k, v]) => k.toLowerCase() === keys[i].toLowerCase(),
+    ) || [null, {}])[1]
+  }
+  return ref
+}
+
+function getResult(method, params) {
+  let api = dotGrab(mock, method)
+
+  if (method.match(/^[a-zA-Z]+\.on[A-Za-z]+$/)) {
+    api = {
+      event: method,
+      listening: true,
+    }
+  }
+
+  if (typeof api === 'function') {
+    let result = params == null ? api() : api(params)
+    if (result === undefined) {
+      result = null
+    }
+    return result
+  } else return api
+}
+
+export function setMockResponses(m) {
+  mock = m
+
+  pending.forEach((json) => handle(json))
+  pending.length = 0
+}
+
+export default {
+  send: send,
+  receiveMessage: receiveMessage,
+  handle: handle,
+  event: event,
+  receive: receive,
+}

package/dist/lib/Transport/WebsocketTransport.mjs

@@ -0,0 +1,55 @@
+const MAX_QUEUED_MESSAGES = 100
+
+export default class WebsocketTransport {
+  constructor(endpoint) {
+    this._endpoint = endpoint
+    this._ws = null
+    this._connected = false
+    this._queue = []
+    this._callbacks = []
+  }
+
+  send(msg) {
+    this._connect()
+
+    if (this._connected) {
+      this._ws.send(msg)
+    } else {
+      if (this._queue.length < MAX_QUEUED_MESSAGES) {
+        this._queue.push(msg)
+      }
+    }
+  }
+
+  receive(callback) {
+    if (!callback) return
+    this._connect()
+    this._callbacks.push(callback)
+  }
+
+  _notifyCallbacks(message) {
+    for (let i = 0; i < this._callbacks.length; i++) {
+      setTimeout(() => this._callbacks[i](message), 1)
+    }
+  }
+
+  _connect() {
+    if (this._ws) return
+    this._ws = new WebSocket(this._endpoint, ['jsonrpc'])
+    this._ws.addEventListener('message', (message) => {
+      this._notifyCallbacks(message.data)
+    })
+    this._ws.addEventListener('error', (message) => {})
+    this._ws.addEventListener('close', (message) => {
+      this._ws = null
+      this._connected = false
+    })
+    this._ws.addEventListener('open', (message) => {
+      this._connected = true
+      for (let i = 0; i < this._queue.length; i++) {
+        this._ws.send(this._queue[i])
+      }
+      this._queue = []
+    })
+  }
+}

package/dist/lib/Transport/index.mjs

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2021 Comcast Cable Communications Management, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import MockTransport from './MockTransport.mjs'
+import Settings, { initSettings } from '../Settings/index.mjs'
+import WebsocketTransport from './WebsocketTransport.mjs'
+
+const win = typeof window !== 'undefined' ? window : {}
+win.__firebolt = win.__firebolt || {}
+
+initSettings({}, { log: true })
+
+let implementation
+let _callback
+
+export function send(json) {
+  implementation = getImplementation()
+
+  if (Settings.getLogLevel() === 'DEBUG') {
+    console.debug(
+      'Sending message to transport: \n' +
+        JSON.stringify(json, { indent: '\t' }),
+    )
+  }
+
+  implementation.send(JSON.stringify(json))
+}
+
+export function receive(callback) {
+  if (implementation) {
+    implementation.receive(callback)
+  } else {
+    _callback = callback
+  }
+}
+
+function getImplementation() {
+  if (implementation) {
+    return implementation
+  }
+
+  if (win.__firebolt.transport) {
+    implementation = win.__firebolt.transport
+  } else if (win.__firebolt.endpoint) {
+    // Only adds RPCv2=true query parameter when using bidirectional SDK.
+    // This parameter will not be present when using unidirectional SDK.
+    // Unidirectional endpoint is handled in Gateway/Unidirectional.mjs
+    const endpoint = win.__firebolt.endpoint
+    const url = endpoint + (endpoint.includes('?') ? '&' : '?') + 'RPCv2=true'
+    implementation = new WebsocketTransport(url)
+  } else {
+    implementation = MockTransport
+  }
+
+  win.__firebolt.transport = implementation
+  implementation.receive(_callback)
+
+  _callback = undefined
+
+  return implementation
+}
+
+export default {
+  send,
+  receive,
+}