@lightningjs/blits 2.5.0 → 2.7.0

package/src/launch.js

@@ -19,6 +19,7 @@ import Settings from './settings.js'
 import { initLog, Log } from './lib/log.js'
 import engine from './engine.js'
 import blitsPackageInfo from '../package.json' with { type: 'json' }
+import { configurePlatform } from './platform.js'
 
 /**
  * @typedef {Object} Font
@@ -86,10 +87,12 @@ async function rendererVersion() {
  * @property {number} [holdTimeout] - Time after which a key press is considered a hold
  * @property {HTMLCanvasElement} [canvas] - Custom canvas object used to render the App
  * @property {number} [textureProcessingTimeLimit] - Max time renderer can process textures in a frame
+ * @property {import('@lightningjs/renderer').RendererMainSettings['platform']} [rendererPlatform] - Custom platform used by the renderer
  * @property {Partial<import('@lightningjs/renderer').RendererMainSettings>} [advanced] - Advanced renderer settings
  * @property {boolean} [announcer] - Whether or not the announcer should be activated on initialization
  * @property {boolean} [enableMouse] - Enable mouse support (hover and click-to-focus). Defaults to false.
  * @property {number} [maxFPS] - Maximum FPS
+ * @property {function} [platform] - Platform factory for non-browser environments
  */
 
 /**
@@ -109,10 +112,30 @@ async function rendererVersion() {
  * @returns {void}
  */
 export default (App, target, settings) => {
+  let warnLegacyRendererPlatform = false
+
+  if (settings !== undefined && 'platform' in settings) {
+    if (typeof settings.platform === 'function') {
+      settings.platform = configurePlatform(settings.platform)
+    } else {
+      if ('rendererPlatform' in settings === false) {
+        settings.rendererPlatform = settings.platform
+      }
+      delete settings.platform
+      warnLegacyRendererPlatform = true
+    }
+  }
+
   Settings.set(settings)
 
   initLog()
 
+  if (warnLegacyRendererPlatform === true) {
+    Log.warn(
+      'Passing a renderer platform via settings.platform is deprecated. Use settings.rendererPlatform instead.'
+    )
+  }
+
   rendererVersion().then((v) => {
     Log.info('Blits Version ', blitsPackageInfo.version)
     Log.info('Renderer Version ', v)

package/src/lib/reactivityguard/computedprops.js

@@ -200,8 +200,12 @@ const processComputedBlock = (configObject) => {
         currentPos = skipNonCode(computedObj, currentPos)
         if (currentPos >= computedObj.length - 1) break
 
-        // Find the next function name (computed properties are `name() { ... }`)
-        const functionNameMatch = /^(\w+)\s*\(\)\s*/.exec(computedObj.substring(currentPos))
+        // Find the next function name (computed properties are `name() { ... }`
+        // or long-form `name: function() { ... }`)
+        const functionNameMatch = /^(\w+)\s*(?:\(\)|:\s*function\s*\([^)]*\))\s*/.exec(
+          computedObj.substring(currentPos)
+        )
+
         if (!functionNameMatch) {
           const nextPos = skipComputedMember(computedObj, currentPos)
           if (nextPos === -1) break

package/src/platform.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2026 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 speechSynthesis from './announcer/speechSynthesis.js'
+
+const globalScope = globalThis
+
+const createKeyboardEventFactory = (KeyboardEventConstructor) => {
+  if (KeyboardEventConstructor === undefined) return undefined
+
+  return (type, init = {}) => {
+    const event = new KeyboardEventConstructor(type, init)
+    if ('keyCode' in init && event.keyCode !== init.keyCode) {
+      Object.defineProperty(event, 'keyCode', {
+        get: () => init.keyCode,
+      })
+    }
+    return event
+  }
+}
+
+const browserPlatform = () => {
+  const windowRef = globalScope.window
+  const documentRef = globalScope.document || (windowRef && windowRef.document)
+  const selfRef = globalScope.self || windowRef || globalScope
+  const navigatorRef =
+    globalScope.navigator || (windowRef && windowRef.navigator) || (selfRef && selfRef.navigator)
+  const KeyboardEventConstructor =
+    globalScope.KeyboardEvent || (windowRef && windowRef.KeyboardEvent)
+  let localStorage
+
+  try {
+    localStorage = (windowRef && windowRef.localStorage) || globalScope.localStorage
+  } catch {
+    localStorage = undefined
+  }
+
+  const createKeyboardEvent = createKeyboardEventFactory(KeyboardEventConstructor)
+
+  return {
+    input: documentRef,
+    viewport: windowRef,
+    dispatchEvent:
+      documentRef && documentRef.dispatchEvent
+        ? documentRef.dispatchEvent.bind(documentRef)
+        : undefined,
+    localStorage,
+    getCookie: () => (documentRef && documentRef.cookie) || '',
+    setCookie: (value) => {
+      if (documentRef !== undefined) documentRef.cookie = value
+    },
+    historyBack: () => {
+      if (windowRef && windowRef.history && windowRef.history.back) windowRef.history.back()
+    },
+    screenHeight: windowRef && windowRef.innerHeight,
+    hardwareConcurrency: navigatorRef && navigatorRef.hardwareConcurrency,
+    userAgent: navigatorRef && navigatorRef.userAgent,
+    KeyboardEvent: KeyboardEventConstructor,
+    isKeyboardEvent:
+      KeyboardEventConstructor !== undefined
+        ? (event) => event instanceof KeyboardEventConstructor
+        : undefined,
+    createKeyboardEvent,
+    announcer: speechSynthesis,
+    now:
+      globalScope.performance && globalScope.performance.now !== undefined
+        ? globalScope.performance.now.bind(globalScope.performance)
+        : Date.now,
+  }
+}
+
+export let platform = browserPlatform()
+
+export const configurePlatform = (customPlatform) => {
+  const basePlatform = browserPlatform()
+  const resolvedCustomPlatform = customPlatform(basePlatform) || {}
+
+  platform = {
+    ...basePlatform,
+    ...resolvedCustomPlatform,
+  }
+
+  platform.KeyboardEvent = platform.KeyboardEvent || basePlatform.KeyboardEvent
+  platform.isKeyboardEvent =
+    resolvedCustomPlatform.isKeyboardEvent ||
+    (platform.KeyboardEvent !== undefined
+      ? (event) => event instanceof platform.KeyboardEvent
+      : basePlatform.isKeyboardEvent)
+  platform.createKeyboardEvent =
+    resolvedCustomPlatform.createKeyboardEvent ||
+    createKeyboardEventFactory(platform.KeyboardEvent) ||
+    basePlatform.createKeyboardEvent
+  platform.getCookie = platform.getCookie || basePlatform.getCookie
+  platform.setCookie = platform.setCookie || basePlatform.setCookie
+  platform.historyBack = platform.historyBack || basePlatform.historyBack
+  platform.announcer = platform.announcer || basePlatform.announcer
+  platform.now = platform.now || basePlatform.now
+
+  return platform
+}

package/src/platforms/webOS/announcer.d.ts

@@ -0,0 +1,39 @@
+import type { AnnouncerDriver } from '@lightningjs/blits'
+
+export interface WebOSRequestOptions {
+  method: 'speak'
+  parameters: {
+    text: string
+    clear: boolean
+  }
+  onFailure(error: any): void
+}
+
+export type WebOSRequest = (uri: string, options: WebOSRequestOptions) => any
+
+export interface WebOSAnnouncerOptions {
+  /**
+   * webOS service request function. Defaults to `webOS.service.request` when available.
+   */
+  request?: WebOSRequest
+  /**
+   * webOS TTS service URI.
+   *
+   * @default 'luna://com.webos.service.tts'
+   */
+  uri?: string
+  /**
+   * Whether the platform TTS queue should be cleared before speaking.
+   *
+   * @default true
+   */
+  clear?: boolean
+  /**
+   * Optional failure callback for the webOS TTS request.
+   */
+  onFailure?: (error: any) => void
+}
+
+declare function createAnnouncer(options?: WebOSAnnouncerOptions): AnnouncerDriver
+
+export default createAnnouncer

package/src/platforms/webOS/announcer.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2026 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 globalScope = globalThis
+const defaultUri = 'luna://com.webos.service.tts'
+
+const getDefaultRequest = () => {
+  const windowRef = globalScope.window
+  const webOS = globalScope.webOS || (windowRef && windowRef.webOS)
+
+  if (webOS && webOS.service && typeof webOS.service.request === 'function') {
+    return webOS.service.request.bind(webOS.service)
+  }
+}
+
+const createAnnouncer = (options = {}) => {
+  const request = options.request || getDefaultRequest()
+  const uri = options.uri || defaultUri
+  const clear = options.clear !== false
+
+  let currentRequest
+
+  return {
+    speak(announcement) {
+      if (request === undefined) {
+        return Promise.reject({ error: 'unavailable' })
+      }
+
+      if (!announcement || announcement.message === undefined || announcement.message === null) {
+        return Promise.reject({ error: 'Missing message' })
+      }
+
+      try {
+        currentRequest = request(uri, {
+          method: 'speak',
+          parameters: {
+            text: String(announcement.message),
+            clear,
+          },
+          onFailure(error) {
+            currentRequest = undefined
+            if (options.onFailure) {
+              options.onFailure(error)
+            }
+          },
+        })
+      } catch (error) {
+        currentRequest = undefined
+        return Promise.reject(error)
+      }
+
+      return Promise.resolve()
+    },
+    cancel() {
+      if (currentRequest && typeof currentRequest.cancel === 'function') {
+        currentRequest.cancel()
+      }
+      currentRequest = undefined
+    },
+  }
+}
+
+export default createAnnouncer

package/src/plugins/storage/localCookie.js

@@ -15,6 +15,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { platform } from '../../platform.js'
+
 // LocalStorage and Cookie storage library
 class localCookie {
   constructor(options) {
@@ -41,7 +43,8 @@ class localCookie {
 
   // Checks if local storage is available and works
   _checkIfLocalStorageWorks() {
-    if (typeof localStorage !== 'undefined') {
+    const localStorage = platform.localStorage
+    if (localStorage !== undefined) {
       try {
         localStorage.setItem('feature_test', 'yes')
         if (localStorage.getItem('feature_test') === 'yes') {
@@ -66,23 +69,23 @@ class localCookie {
    * Local Storage APIs
    */
   _getItemLocalStorage(key) {
-    return window.localStorage.getItem(key)
+    return platform.localStorage.getItem(key)
   }
 
   _setItemLocalStorage(key, value) {
-    return window.localStorage.setItem(key, value)
+    return platform.localStorage.setItem(key, value)
   }
 
   _removeItemLocalStorage(key) {
-    return window.localStorage.removeItem(key)
+    return platform.localStorage.removeItem(key)
   }
 
   _clearLocalStorage() {
-    return window.localStorage.clear()
+    return platform.localStorage.clear()
   }
 
   _getLocalStorageKeys() {
-    return Object.keys(window.localStorage)
+    return Object.keys(platform.localStorage)
   }
 
   /*
@@ -91,7 +94,7 @@ class localCookie {
   _getItemCookie(key) {
     /* eslint-disable */
 		function escape(s) { return s.replace(/([.*+?\^${}()|\[\]\/\\])/g, '\\$1'); };
-		var match = document.cookie.match(RegExp('(?:^|;\\s*)' + escape(key) + '=([^;]*)'));
+		var match = platform.getCookie().match(RegExp('(?:^|;\\s*)' + escape(key) + '=([^;]*)'));
 
 		//if value in key of the entire cookie is empty, its deleted
 		if (match && match[1] === '')
@@ -103,13 +106,13 @@ class localCookie {
 	_setItemCookie(key, value) {
 		var now = new Date()
 		var expires = new Date(now.getTime() +1000*60*60*24*365*5) // 5 years!
-		document.cookie = `${key}=${value}; expires=${expires.toUTCString()};`
+		platform.setCookie(`${key}=${value}; expires=${expires.toUTCString()};`)
 		return //return undefined just like localStorage
 	}
 
 	_removeItemCookie(key) {
 		// to delete an k/v set the key to empty
-		document.cookie = `${key}=;Max-Age=-99999999;`
+		platform.setCookie(`${key}=;Max-Age=-99999999;`)
 		return //return undefined just like localStorage
 	}
 
@@ -117,14 +120,14 @@ class localCookie {
 		// empty all key/values in cookies
 		// What about cookies we got from the server? ¯\_(ツ)_/¯
 		// They should have the HttpOnly flag, so we shouldn't be able to delete them
-		document.cookie.split(";").forEach( (c) => {
-			document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=;Max-Age=-99999999");
+		platform.getCookie().split(";").forEach( (c) => {
+			platform.setCookie(c.replace(/^ +/, "").replace(/=.*/, "=;expires=;Max-Age=-99999999"));
 		});
 
 		return //return undefined
 	}
 	_getCookieKeys() {
-		return document.cookie.split(";").map((item)=>item.trim().split("=")[0])
+		return platform.getCookie().split(";").map((item)=>item.trim().split("=")[0])
 	}
 }
 

package/src/router/router.js

@@ -24,6 +24,7 @@ import { stage } from '../launch.js'
 import Focus from '../focus/focus.js'
 import Announcer from '../announcer/announcer.js'
 import Settings from '../settings.js'
+import { platform } from '../platform.js'
 
 /**
  * @typedef {import('../component.js').BlitsComponentFactory} BlitsComponentFactory - The component of the route
@@ -417,7 +418,8 @@ const executeBeforeHook = async function (
       this.currentRoute = previousRoute
       if (this.history.length > 0) {
         preventHashChangeNavigation = true
-        window.history.back()
+        platform.historyBack()
+
         navigatingBack = false
         state.navigating = false
       }
@@ -434,7 +436,7 @@ const executeBeforeHook = async function (
       this.currentRoute = previousRoute
       if (this.history.length > 0) {
         preventHashChangeNavigation = true
-        window.history.back()
+        platform.historyBack()
         navigatingBack = false
         state.navigating = false
       }

package/src/testing/index.d.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 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 type { ComponentFactory, Settings } from '@lightningjs/blits'
+
+export interface SnapshotNode {
+  type: string
+  attributes: Record<string, any>
+  children: Array<SnapshotNode | ComponentSnapshotNode>
+}
+
+export interface ComponentSnapshotNode {
+  type: 'Component'
+  name: string
+  hasFocus: boolean
+  isHovered: boolean
+  attributes: Record<string, any>
+  props: Record<string, any>
+  state: Record<string, any>
+  tree: SnapshotNode | null
+}
+
+export interface RenderComponentOptions {
+  props?: Record<string, any>
+  settings?: Settings
+}
+
+export interface RenderComponentFixture {
+  component: any
+  root: any
+  snapshot(): SnapshotNode | ComponentSnapshotNode
+  findByData(key: string, value: any): SnapshotNode | ComponentSnapshotNode | null
+  findAllByData(key: string, value: any): Array<SnapshotNode | ComponentSnapshotNode>
+  setProps(props: Record<string, any>): void
+  setState(state: Record<string, any>): void
+  focus(event?: KeyboardEvent): Promise<any>
+  unfocus(): any
+  createKeyboardEvent(key: string, init?: KeyboardEventInit): KeyboardEvent
+  input(key: string, event?: KeyboardEvent): boolean
+  destroy(): void
+}
+
+export function renderComponent(
+  Component: ComponentFactory,
+  options?: RenderComponentOptions
+): RenderComponentFixture

package/src/testing/index.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2026 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 renderComponent from './renderComponent.js'
+
+export { renderComponent }

package/src/testing/nodePlatform.js

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2026 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
+ */
+
+class TestKeyboardEvent {
+  constructor(type, init = {}) {
+    this.type = type
+    this.key = init.key
+    this.code = init.code
+    this.keyCode = init.keyCode || 0
+    this.bubbles = init.bubbles === true
+    this.cancelable = init.cancelable === true
+    this.composed = init.composed === true
+    this.timeStamp = init.timeStamp || Date.now()
+  }
+}
+
+const createEventTarget = () => {
+  const listeners = {}
+
+  return {
+    addEventListener(type, handler) {
+      listeners[type] = listeners[type] || []
+      listeners[type].push(handler)
+    },
+    removeEventListener(type, handler) {
+      const handlers = listeners[type]
+      if (handlers === undefined) return
+      const index = handlers.indexOf(handler)
+      if (index > -1) handlers.splice(index, 1)
+    },
+    dispatchEvent(event) {
+      const handlers = listeners[event.type] || []
+      for (let i = 0; i < handlers.length; i++) {
+        handlers[i](event)
+      }
+      return true
+    },
+  }
+}
+
+const createStorage = () => {
+  const store = {}
+
+  return {
+    getItem(key) {
+      return store[key] !== undefined ? store[key] : null
+    },
+    setItem(key, value) {
+      store[key] = String(value)
+    },
+    removeItem(key) {
+      delete store[key]
+    },
+    clear() {
+      const keys = Object.keys(store)
+      for (let i = 0; i < keys.length; i++) {
+        delete store[keys[i]]
+      }
+    },
+  }
+}
+
+const nodePlatform = () => {
+  const input = createEventTarget()
+  const viewport = createEventTarget()
+  let cookie = ''
+
+  return {
+    input,
+    viewport,
+    dispatchEvent: input.dispatchEvent.bind(input),
+    localStorage: createStorage(),
+    getCookie: () => cookie,
+    setCookie: (value) => {
+      cookie = value
+    },
+    historyBack() {},
+    screenHeight: 1080,
+    hardwareConcurrency: 1,
+    userAgent: 'node',
+    KeyboardEvent: TestKeyboardEvent,
+    isKeyboardEvent: (event) => event instanceof TestKeyboardEvent,
+    createKeyboardEvent: (type, init = {}) => new TestKeyboardEvent(type, init),
+    announcer: {
+      speak() {
+        return Promise.resolve()
+      },
+      cancel() {},
+    },
+    now: Date.now,
+  }
+}
+
+export default nodePlatform