@lightningjs/blits 1.3.0 → 1.4.0

package/src/lib/eventListeners.test.js

@@ -0,0 +1,185 @@
+/*
+ * Copyright 2023 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 test from 'tape'
+import eventListener from './eventListeners.js'
+
+const resetModule = () => {
+  eventListener.removeListeners('testComponent')
+  eventListener.removeListeners('anotherComponent')
+}
+
+test('registerListener', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event = 'testEvent'
+  const cb = () => {}
+
+  t.doesNotThrow(
+    () => eventListener.registerListener(component, event, cb),
+    'Should not throw exception when registering a listener'
+  )
+
+  t.doesNotThrow(
+    () => eventListener.registerListener(component, event, cb, 1),
+    'Should not throw exception when registering a listener with priority'
+  )
+
+  t.doesNotThrow(
+    () => eventListener.registerListener('anotherComponent', event, cb),
+    'Should not throw exception when registering multiple components for the same event'
+  )
+
+  t.end()
+})
+
+test('executeListeners - no listeners', (t) => {
+  resetModule()
+
+  const result = eventListener.executeListeners('nonExistentEvent')
+  t.equal(result, true, 'Should return true when no listeners are registered')
+
+  t.end()
+})
+
+test('executeListeners - with listeners', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event = 'testEvent'
+  let callCount = 0
+  const cb1 = () => {
+    callCount++
+  }
+  const cb2 = () => {
+    callCount++
+  }
+
+  eventListener.registerListener(component, event, cb1)
+  eventListener.registerListener(component, event, cb2)
+
+  const result = eventListener.executeListeners(event)
+  t.equal(result, true, 'Should return true when all listeners execute successfully')
+  t.equal(callCount, 2, 'Should call all registered callbacks')
+
+  t.end()
+})
+
+test('executeListeners - priority order', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event = 'testEvent'
+  const order = []
+  const cb1 = () => {
+    order.push(1)
+  }
+  const cb2 = () => {
+    order.push(2)
+  }
+  const cb3 = () => {
+    order.push(3)
+  }
+
+  eventListener.registerListener(component, event, cb1, 1)
+  eventListener.registerListener(component, event, cb2, 3)
+  eventListener.registerListener(component, event, cb3, 2)
+
+  eventListener.executeListeners(event)
+  t.deepEqual(order, [2, 3, 1], 'Should execute callbacks in priority order')
+
+  t.end()
+})
+
+test('executeListeners - stop propagation', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event = 'testEvent'
+  let callCount = 0
+  const cb1 = () => {
+    callCount++
+    return false
+  }
+  const cb2 = () => {
+    callCount++
+  }
+
+  eventListener.registerListener(component, event, cb1)
+  eventListener.registerListener(component, event, cb2)
+
+  const result = eventListener.executeListeners(event)
+  t.equal(result, false, 'Should return false when propagation is stopped')
+  t.equal(callCount, 1, 'Should stop calling callbacks after one returns false')
+
+  t.end()
+})
+
+test('removeListeners', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event1 = 'testEvent1'
+  const event2 = 'testEvent2'
+  const cb = () => {}
+
+  eventListener.registerListener(component, event1, cb)
+  eventListener.registerListener(component, event2, cb)
+  eventListener.registerListener('anotherComponent', event1, cb)
+
+  eventListener.removeListeners(component)
+
+  const result1 = eventListener.executeListeners(event1)
+  t.equal(result1, true, 'Should still return true for event1 as another component is registered')
+
+  const result2 = eventListener.executeListeners(event2)
+  t.equal(result2, true, 'Should return true for event2 as no listeners remain')
+
+  t.end()
+})
+
+test('cache invalidation', (t) => {
+  resetModule()
+
+  const component = 'testComponent'
+  const event = 'testEvent'
+  let callOrder = []
+  const cb1 = () => {
+    callOrder.push(1)
+  }
+  const cb2 = () => {
+    callOrder.push(2)
+  }
+
+  eventListener.registerListener(component, event, cb1)
+  eventListener.executeListeners(event)
+
+  eventListener.registerListener(component, event, cb2, 1)
+  eventListener.executeListeners(event)
+
+  t.deepEqual(callOrder, [1, 2, 1], 'Should invalidate cache when new listener is added')
+
+  callOrder = []
+  eventListener.removeListeners(component)
+  eventListener.registerListener(component, event, cb1)
+  eventListener.executeListeners(event)
+
+  t.deepEqual(callOrder, [1], 'Should invalidate cache when listeners are removed')
+
+  t.end()
+})

package/src/lib/symbols.js

@@ -11,10 +11,10 @@ export default {
   init: Symbol('init'),
   inputEvents: Symbol('inputEvents'),
   intervals: Symbol('intervals'),
+  launched: Symbol('launched'),
   level: Symbol('level'),
   methodKeys: Symbol('methodKeys'),
   originalState: Symbol('originalState'),
-  pluginsRegistered: Symbol('pluginsRegistered'),
   propKeys: Symbol('propKeys'),
   raw: Symbol('raw'),
   ready: Symbol('ready'),

package/src/plugin.js

@@ -1,22 +1,26 @@
-export const plugins = {}
+import log from './plugins/log'
+
+export const plugins = {
+  // log plugin added by default
+  log,
+}
 
 const registerPlugin = (plugin, nameOrOptions = '', options = {}) => {
   // map name and options depending on the arguments provided
-  let name
+  let name = undefined
   if (typeof nameOrOptions === 'object') {
     options = nameOrOptions
-    name = ''
   } else {
     name = nameOrOptions
   }
 
   if (typeof plugin === 'function') {
-    if (name === '') {
+    if (name === undefined) {
       throw Error('Error registering plugin: name is required for plugin')
     }
     plugins[name] = { plugin, options }
   } else if (plugin.plugin) {
-    registerPlugin(plugin.plugin, plugin.name, options)
+    registerPlugin(plugin.plugin, name || plugin.name, options)
   }
 }
 

package/src/plugins/appstate.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2024 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 { reactive } from '../lib/reactivity/reactive'
+
+export default {
+  name: 'appState',
+  plugin(state = {}) {
+    return reactive(state)
+  },
+}

package/src/plugins/index.js

@@ -16,3 +16,5 @@
  */
 
 export { default as language } from './language.js'
+export { default as theme } from './theme.js'
+export { default as appState } from './appstate.js'

package/src/{component/base → plugins}/log.js

@@ -15,13 +15,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import log from '../../lib/log.js'
+import { default as log } from '../lib/log'
 
 export default {
-  $log: {
-    value: log('App'),
-    writable: false,
-    enumerable: true,
-    configurable: false,
+  name: 'log',
+  plugin() {
+    return log('App')
   },
 }

package/src/plugins/theme.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2024 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 { Log } from '../lib/log'
+import { reactive } from '../lib/reactivity/reactive.js'
+
+const getValueByDotNotation = (obj, base, path) => {
+  const keys = path.split('.')
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i]
+
+    if (obj !== null && key in obj === true) {
+      obj = obj[key]
+      base = base !== null && key in base === true ? base[key] : null
+    }
+    // see if the key is present in the base object
+    else if (base !== null && key in base === true) {
+      base = base[key]
+      obj = base
+    } else {
+      obj = undefined
+      break
+    }
+  }
+
+  return obj
+}
+
+export default {
+  name: 'theme',
+  plugin(config = {}) {
+    let themeMap = {}
+
+    const state = reactive({
+      current: 'default',
+    })
+
+    let themes = {}
+    let base = null
+    if ('themes' in config === true) {
+      themes = config.themes
+      state.current = config.current || 'default'
+      base = config.base || 'default'
+    } else {
+      themes = { default: config }
+    }
+
+    return {
+      get(key, fallback) {
+        // reference state.current, to trigger reactive effects for
+        // theme get function when current theme is modified
+        state.current
+        if (themeMap[key] !== undefined) return themeMap[key]
+        const value = getValueByDotNotation(themes[state.current], themes[base], key)
+        if (value !== undefined) {
+          // store the value for next time
+          themeMap[key] = value
+          return value
+        }
+        return fallback
+      },
+
+      set(theme) {
+        if (theme in themes) {
+          themeMap = {}
+          state.current = theme
+        } else {
+          Log.warn(`Theme ${theme} not found`)
+        }
+      },
+    }
+  },
+}

package/docs/components/utilities.md

@@ -1,3 +0,0 @@
-
-# Utilities
-