@lightningjs/blits 1.30.2 → 1.31.1

package/src/lib/eventListeners.js

@@ -1,123 +1,123 @@
-/*
- * 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
- */
-
-const eventsMap = new Map()
-const callbackCache = new Map()
-
-export default {
-  /**
-   * Registers a listener callback for a specific event on a component.
-   *
-   * @param {object} component - The component instance to register the listener for.
-   * @param {string} event - The name of the event to listen for.
-   * @param {Function} cb - The callback function to execute when the event is emitted.
-   * @param {number} [priority=0] - The priority of the listener (higher runs first).
-   * @returns {void}
-   */
-  registerListener(component, event, cb, priority = 0) {
-    let componentsMap = eventsMap.get(event)
-    if (componentsMap === undefined) {
-      componentsMap = new Map()
-      eventsMap.set(event, componentsMap)
-    }
-
-    let components = componentsMap.get(component)
-    if (components === undefined) {
-      components = new Set()
-      componentsMap.set(component, components)
-    }
-
-    components.add({ cb, priority })
-    callbackCache.delete(event) // Invalidate the callbackCache when a new callback is added
-  },
-
-  /**
-   * Deregisters a listener for a specific event on a component.
-   *
-   * @param {object} component - The component instance to deregister the listener for.
-   * @param {string} event - The name of the event to stop listening for.
-   * @returns {void}
-   */
-  deregisterListener(component, event) {
-    let componentsMap = eventsMap.get(event)
-    if (componentsMap === undefined) {
-      return
-    }
-
-    if (componentsMap.has(component)) {
-      componentsMap.delete(component)
-      eventsMap.set(event, componentsMap)
-      callbackCache.delete(event)
-    }
-  },
-
-  /**
-   * Executes all registered listeners for a given event, in priority order.
-   *
-   * @param {string} event - The name of the event to emit.
-   * @param {any} params - The parameters to pass to the event listeners.
-   * @returns {boolean} True if all listeners executed without stopping propagation, false if any listener returned false.
-   */
-  executeListeners(event, params) {
-    const componentsMap = eventsMap.get(event)
-    if (componentsMap === undefined || componentsMap.size === 0) {
-      return true // No listeners, so execution can be considered successful
-    }
-
-    if (callbackCache.has(event) === false) {
-      const allCallbacks = []
-      for (const [component, components] of componentsMap) {
-        for (const callbackObj of components) {
-          allCallbacks.push({ ...callbackObj, component })
-        }
-      }
-      allCallbacks.sort((a, b) => b.priority - a.priority)
-      callbackCache.set(event, allCallbacks) // callbackCache the sorted callbacks with component context
-    }
-
-    const callbacks = callbackCache.get(event)
-    for (let i = 0; i < callbacks.length; i++) {
-      const { cb, component } = callbacks[i]
-      const result = cb.call(component, params)
-      if (result === false) {
-        return false // Stop propagation if any listener returns false
-      }
-    }
-
-    return true // All listeners executed without stopping propagation
-  },
-
-  /**
-   * Removes all listeners for a given component from all events.
-   *
-   * @param {object} component - The component instance to remove listeners for.
-   * @returns {void}
-   */
-  removeListeners(component) {
-    for (const [event, componentsMap] of eventsMap) {
-      if (componentsMap.has(component)) {
-        componentsMap.delete(component)
-        callbackCache.delete(event) // Invalidate the callbackCache for this event
-
-        // If no more components for this event, remove the event entirely
-        if (componentsMap.size === 0) {
-          eventsMap.delete(event)
-        }
-      }
-    }
-  },
-}
+/*
+ * 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
+ */
+
+const eventsMap = new Map()
+const callbackCache = new Map()
+
+export default {
+  /**
+   * Registers a listener callback for a specific event on a component.
+   *
+   * @param {object} component - The component instance to register the listener for.
+   * @param {string} event - The name of the event to listen for.
+   * @param {Function} cb - The callback function to execute when the event is emitted.
+   * @param {number} [priority=0] - The priority of the listener (higher runs first).
+   * @returns {void}
+   */
+  registerListener(component, event, cb, priority = 0) {
+    let componentsMap = eventsMap.get(event)
+    if (componentsMap === undefined) {
+      componentsMap = new Map()
+      eventsMap.set(event, componentsMap)
+    }
+
+    let components = componentsMap.get(component)
+    if (components === undefined) {
+      components = new Set()
+      componentsMap.set(component, components)
+    }
+
+    components.add({ cb, priority })
+    callbackCache.delete(event) // Invalidate the callbackCache when a new callback is added
+  },
+
+  /**
+   * Deregisters a listener for a specific event on a component.
+   *
+   * @param {object} component - The component instance to deregister the listener for.
+   * @param {string} event - The name of the event to stop listening for.
+   * @returns {void}
+   */
+  deregisterListener(component, event) {
+    let componentsMap = eventsMap.get(event)
+    if (componentsMap === undefined) {
+      return
+    }
+
+    if (componentsMap.has(component)) {
+      componentsMap.delete(component)
+      eventsMap.set(event, componentsMap)
+      callbackCache.delete(event)
+    }
+  },
+
+  /**
+   * Executes all registered listeners for a given event, in priority order.
+   *
+   * @param {string} event - The name of the event to emit.
+   * @param {any} params - The parameters to pass to the event listeners.
+   * @returns {boolean} True if all listeners executed without stopping propagation, false if any listener returned false.
+   */
+  executeListeners(event, params) {
+    const componentsMap = eventsMap.get(event)
+    if (componentsMap === undefined || componentsMap.size === 0) {
+      return true // No listeners, so execution can be considered successful
+    }
+
+    if (callbackCache.has(event) === false) {
+      const allCallbacks = []
+      for (const [component, components] of componentsMap) {
+        for (const callbackObj of components) {
+          allCallbacks.push({ ...callbackObj, component })
+        }
+      }
+      allCallbacks.sort((a, b) => b.priority - a.priority)
+      callbackCache.set(event, allCallbacks) // callbackCache the sorted callbacks with component context
+    }
+
+    const callbacks = callbackCache.get(event)
+    for (let i = 0; i < callbacks.length; i++) {
+      const { cb, component } = callbacks[i]
+      const result = cb.call(component, params)
+      if (result === false) {
+        return false // Stop propagation if any listener returns false
+      }
+    }
+
+    return true // All listeners executed without stopping propagation
+  },
+
+  /**
+   * Removes all listeners for a given component from all events.
+   *
+   * @param {object} component - The component instance to remove listeners for.
+   * @returns {void}
+   */
+  removeListeners(component) {
+    for (const [event, componentsMap] of eventsMap) {
+      if (componentsMap.has(component)) {
+        componentsMap.delete(component)
+        callbackCache.delete(event) // Invalidate the callbackCache for this event
+
+        // If no more components for this event, remove the event entirely
+        if (componentsMap.size === 0) {
+          eventsMap.delete(event)
+        }
+      }
+    }
+  },
+}

package/src/lib/hooks.js

@@ -1,59 +1,59 @@
-/*
- * 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 symbols from './symbols.js'
-
-const cbs = {}
-
-/**
- * Emits a registered hook for a given identifier, calling the hook with the provided scope and data.
- *
- * @param {string|symbol} hook - The name or symbol of the hook to emit.
- * @param {string} identifier - The unique identifier for the hook set.
- * @param {object} scope - The value of `this` inside the hook function.
- * @param {Array} [data=[]] - Arguments to pass to the hook function.
- */
-export const emit = (hook, identifier, scope, data = []) => {
-  cbs[identifier] && cbs[identifier][hook] && cbs[identifier][hook].apply(scope, data)
-}
-
-/**
- * Emits a registered symbol-based hook for a given identifier, calling the hook with the provided scope.
- *
- * @param {string|symbol} hook - The name or symbol of the hook to emit (will be mapped to a symbol).
- * @param {string} identifier - The unique identifier for the hook set.
- * @param {object} scope - The value of `this` inside the hook function.
- */
-export const privateEmit = (hook, identifier, scope) => {
-  const symHook = symbols[hook]
-  cbs[identifier] && cbs[identifier][symHook] && cbs[identifier][symHook].apply(scope)
-}
-
-/**
- * Registers a set of hooks (functions) for a given identifier.
- *
- * @param {Object<string,Function>|Object<symbol,Function>} hooks - An object whose keys are hook names or symbols and values are functions.
- * @param {string} identifier - The unique identifier for the hook set.
- */
-export const registerHooks = (hooks = {}, identifier) => {
-  cbs[identifier] = {}
-  // Combines enumerable keys and symbol properties of the 'hooks' object
-  const hookKeys = [...Object.keys(hooks), ...Object.getOwnPropertySymbols(hooks)]
-  hookKeys.forEach((hook) => {
-    if (typeof hooks[hook] === 'function') cbs[identifier][hook] = hooks[hook]
-  })
-}
+/*
+ * 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 symbols from './symbols.js'
+
+const cbs = {}
+
+/**
+ * Emits a registered hook for a given identifier, calling the hook with the provided scope and data.
+ *
+ * @param {string|symbol} hook - The name or symbol of the hook to emit.
+ * @param {string} identifier - The unique identifier for the hook set.
+ * @param {object} scope - The value of `this` inside the hook function.
+ * @param {Array} [data=[]] - Arguments to pass to the hook function.
+ */
+export const emit = (hook, identifier, scope, data = []) => {
+  cbs[identifier] && cbs[identifier][hook] && cbs[identifier][hook].apply(scope, data)
+}
+
+/**
+ * Emits a registered symbol-based hook for a given identifier, calling the hook with the provided scope.
+ *
+ * @param {string|symbol} hook - The name or symbol of the hook to emit (will be mapped to a symbol).
+ * @param {string} identifier - The unique identifier for the hook set.
+ * @param {object} scope - The value of `this` inside the hook function.
+ */
+export const privateEmit = (hook, identifier, scope) => {
+  const symHook = symbols[hook]
+  cbs[identifier] && cbs[identifier][symHook] && cbs[identifier][symHook].apply(scope)
+}
+
+/**
+ * Registers a set of hooks (functions) for a given identifier.
+ *
+ * @param {Object<string,Function>|Object<symbol,Function>} hooks - An object whose keys are hook names or symbols and values are functions.
+ * @param {string} identifier - The unique identifier for the hook set.
+ */
+export const registerHooks = (hooks = {}, identifier) => {
+  cbs[identifier] = {}
+  // Combines enumerable keys and symbol properties of the 'hooks' object
+  const hookKeys = [...Object.keys(hooks), ...Object.getOwnPropertySymbols(hooks)]
+  hookKeys.forEach((hook) => {
+    if (typeof hooks[hook] === 'function') cbs[identifier][hook] = hooks[hook]
+  })
+}

package/src/lib/lifecycle.js

@@ -1,85 +1,85 @@
-/*
- * 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 './log.js'
-import { emit, privateEmit } from './hooks.js'
-import symbols from './symbols.js'
-
-/**
- * List of valid lifecycle states for a component.
- * @type {Array<string>}
- */
-const states = [
-  'init', // fired upon component instantiation
-  'ready', // fired when component instantiated, reactivity setup done and template spawned
-  'focus', // fired when receiving focus (can occur multiple times)
-  'unfocus', // fired when losing focus (can occur multiple times)
-  'destroy', // fired when component is destroyed and removed
-  'attach', // fired when entering the viewport margin and attached to the render tree
-  'detach', // fired when leaving the viewport margin and detached from the render tree
-  'enter', // fired when entering the visible viewport
-  'exit', // fired when leaving the visible viewport
-]
-
-/**
- * Lifecycle state manager for components.
- *
- * @typedef {Object} Lifecycle
- * @property {string|null} previous - The previous lifecycle state.
- * @property {string|null} current - The current lifecycle state.
- * @property {Object} [component] - The component instance this lifecycle belongs to.
- * @property {string|null} state - The current lifecycle state (getter/setter).
- */
-
-/**
- * Lifecycle state management object for components.
- * Handles state transitions and emits corresponding hooks.
- *
- * @type {Lifecycle}
- * @this {Lifecycle & {component: Object}}
- * The 'component' property is expected to be set by the component instance at runtime.
- */
-export default {
-  previous: null,
-  current: null,
-  /**
-   * Gets the current lifecycle state.
-   * @this {Lifecycle & {component: Object}}
-   * @returns {string|null}
-   */
-  get state() {
-    return this.current
-  },
-  /**
-   * Sets the lifecycle state and emits hooks if the state is valid and changed.
-   * @this {Lifecycle & {component: Object}}
-   * @param {string} v - The new lifecycle state.
-   */
-  set state(v) {
-    if (states.indexOf(v) > -1 && (v !== this.current || v === 'focus')) {
-      Log.debug(
-        `Setting lifecycle state from ${this.current} to ${v} for ${this.component.componentId}`
-      )
-      this.previous = this.current
-      this.current = v
-      // emit 'private' hook
-      privateEmit(v, this.component[symbols.identifier], this.component)
-      // emit 'public' hook
-      emit(v, this.component[symbols.identifier], this.component)
-    }
-  },
-}
+/*
+ * 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 './log.js'
+import { emit, privateEmit } from './hooks.js'
+import symbols from './symbols.js'
+
+/**
+ * List of valid lifecycle states for a component.
+ * @type {Array<string>}
+ */
+const states = [
+  'init', // fired upon component instantiation
+  'ready', // fired when component instantiated, reactivity setup done and template spawned
+  'focus', // fired when receiving focus (can occur multiple times)
+  'unfocus', // fired when losing focus (can occur multiple times)
+  'destroy', // fired when component is destroyed and removed
+  'attach', // fired when entering the viewport margin and attached to the render tree
+  'detach', // fired when leaving the viewport margin and detached from the render tree
+  'enter', // fired when entering the visible viewport
+  'exit', // fired when leaving the visible viewport
+]
+
+/**
+ * Lifecycle state manager for components.
+ *
+ * @typedef {Object} Lifecycle
+ * @property {string|null} previous - The previous lifecycle state.
+ * @property {string|null} current - The current lifecycle state.
+ * @property {Object} [component] - The component instance this lifecycle belongs to.
+ * @property {string|null} state - The current lifecycle state (getter/setter).
+ */
+
+/**
+ * Lifecycle state management object for components.
+ * Handles state transitions and emits corresponding hooks.
+ *
+ * @type {Lifecycle}
+ * @this {Lifecycle & {component: Object}}
+ * The 'component' property is expected to be set by the component instance at runtime.
+ */
+export default {
+  previous: null,
+  current: null,
+  /**
+   * Gets the current lifecycle state.
+   * @this {Lifecycle & {component: Object}}
+   * @returns {string|null}
+   */
+  get state() {
+    return this.current
+  },
+  /**
+   * Sets the lifecycle state and emits hooks if the state is valid and changed.
+   * @this {Lifecycle & {component: Object}}
+   * @param {string} v - The new lifecycle state.
+   */
+  set state(v) {
+    if (states.indexOf(v) > -1 && (v !== this.current || v === 'focus')) {
+      Log.debug(
+        `Setting lifecycle state from ${this.current} to ${v} for ${this.component.componentId}`
+      )
+      this.previous = this.current
+      this.current = v
+      // emit 'private' hook
+      privateEmit(v, this.component[symbols.identifier], this.component)
+      // emit 'public' hook
+      emit(v, this.component[symbols.identifier], this.component)
+    }
+  },
+}