@lightningjs/blits 2.4.1 → 2.6.0

package/src/components/RouterView.js

@@ -23,6 +23,7 @@ import Router, {
 } from '../router/router.js'
 import symbols from '../lib/symbols.js'
 import Focus from '../focus/focus.js'
+import { platform } from '../platform.js'
 
 /** @typedef {{ $input?: (event: any) => boolean, $focus?: (event: any) => void }} RouterViewParent */
 
@@ -46,6 +47,9 @@ export default () =>
             'color',
             'src',
             'texture',
+            'image',
+            'map',
+            'frame',
             'fit',
             'rtt',
             'mount',
@@ -156,11 +160,18 @@ export default () =>
             Router.navigate.apply(this)
           }
 
-          window.addEventListener('hashchange', this.hashchangeHandler)
+          const viewport = platform.viewport
+          if (viewport !== undefined) {
+            this.hashchangeViewport = viewport
+            viewport.addEventListener('hashchange', this.hashchangeHandler)
+          }
         },
         destroy() {
           unregisterRouterView(this)
-          window.removeEventListener('hashchange', this.hashchangeHandler, false)
+          if (this.hashchangeViewport !== undefined) {
+            this.hashchangeViewport.removeEventListener('hashchange', this.hashchangeHandler, false)
+            this.hashchangeViewport = undefined
+          }
         },
         focus() {
           if (this.activeView && Focus.get() === this) {

package/src/components/index.js

@@ -17,10 +17,8 @@
 
 import Circle from './Circle.js'
 import RouterView from './RouterView.js'
-import Sprite from './Sprite.js'
 
 export default () => ({
   Circle: Circle(),
   RouterView: RouterView(),
-  Sprite: Sprite(),
 })

package/src/engines/L3/element.js

@@ -29,9 +29,14 @@ import { Log } from '../../lib/log.js'
 import symbols from '../../lib/symbols.js'
 import Settings from '../../settings.js'
 import shaders from '../../lib/shaders/shaders.js'
+import { resolveSpriteTexture } from './spriteTexture.js'
 
 const holderComponentMap = new WeakMap()
 
+/** @param {any} frame */
+const spriteFrameKey = (frame) =>
+  typeof frame === 'object' && frame !== null ? JSON.stringify(frame) : frame
+
 /**
  * Creates a padding object from a value and direction.
  * @param {number|object|string|undefined} padding - The padding value.
@@ -291,6 +296,24 @@ const propsTransformer = {
       this.props['color'] = 0xffffffff
     }
   },
+  set image(v) {
+    this.raw['image'] = v
+    if (this.element[symbols.isSprite] === true && this.element.node) {
+      this.element._scheduleNativeSpriteSync()
+    }
+  },
+  set map(v) {
+    this.raw['map'] = v
+    if (this.element[symbols.isSprite] === true && this.element.node) {
+      this.element._scheduleNativeSpriteSync()
+    }
+  },
+  set frame(v) {
+    this.raw['frame'] = v
+    if (this.element[symbols.isSprite] === true && this.element.node) {
+      this.element._scheduleNativeSpriteSync()
+    }
+  },
   set fit(v) {
     const resizeMode = {}
 
@@ -548,6 +571,7 @@ export const elementAttributes = Object.keys(propsTransformer)
 const Element = {
   /**
    * Populates the element with data
+   * @this {import('../../component.js').BlitsElement}
    * @param {import('../../component.js').BlitsElementProps} props
    */
   populate(props) {
@@ -557,6 +581,21 @@ const Element = {
       this[symbols.isSlot] = true
     }
 
+    if (props[symbols.isSprite] === true) {
+      this[symbols.isSprite] = true
+      this._spriteState = {
+        spriteTexture: null,
+        currentSrc: null,
+        _loadedCb: null,
+        _failedCb: null,
+        _syncScheduled: false,
+        lastTexture: null,
+        lastImage: null,
+        lastMap: null,
+        lastFrameKey: undefined,
+      }
+    }
+
     this.props.element = this
 
     this.props['parent'] = props['parent'] || this.config.parent
@@ -600,16 +639,20 @@ const Element = {
       holderComponentMap.set(this.node, this.component)
     }
 
-    if (props['@loaded'] !== undefined && typeof props['@loaded'] === 'function') {
-      this.node.on('loaded', (el, { type, dimensions }) => {
-        props['@loaded']({ w: dimensions.w, h: dimensions.h, type }, this)
-      })
-    }
+    if (this[symbols.isSprite] === true) {
+      this._syncNativeSprite()
+    } else {
+      if (props['@loaded'] !== undefined && typeof props['@loaded'] === 'function') {
+        this.node.on('loaded', (el, { type, dimensions }) => {
+          props['@loaded']({ w: dimensions.w, h: dimensions.h, type }, this)
+        })
+      }
 
-    if (props['@error'] !== undefined && typeof props['@error'] === 'function') {
-      this.node.on('failed', (el, error) => {
-        props['@error'](error, this)
-      })
+      if (props['@error'] !== undefined && typeof props['@error'] === 'function') {
+        this.node.on('failed', (el, error) => {
+          props['@error'](error, this)
+        })
+      }
     }
 
     if (props.__layout === true) {
@@ -657,6 +700,78 @@ const Element = {
       this.node.data = { ...this.props.props['data'] }
     }
   },
+  /**
+   * @this {import('../../component.js').BlitsElement}
+   */
+  _scheduleNativeSpriteSync() {
+    if (this[symbols.isSprite] !== true || !this.node || this.eol === true) return
+    const st = this._spriteState
+    if (st === undefined) return
+    if (st._syncScheduled === true) return
+    st._syncScheduled = true
+    queueMicrotask(() => {
+      st._syncScheduled = false
+      if (this.eol === true || !this.node) return
+      this._syncNativeSprite()
+    })
+  },
+  /**
+   * @this {import('../../component.js').BlitsElement}
+   */
+  _syncNativeSprite() {
+    if (this[symbols.isSprite] !== true || !this.node) return
+    const st = this._spriteState
+    if (st === undefined) return
+
+    const raw = this.props.raw
+    const image = raw['image']
+    const map = raw['map']
+    const frameKey = spriteFrameKey(raw['frame'])
+
+    if (
+      st.lastTexture != null &&
+      image === st.lastImage &&
+      map === st.lastMap &&
+      frameKey === st.lastFrameKey
+    ) {
+      return
+    }
+
+    const imageChanged = image !== st.lastImage
+    st.lastImage = image
+    st.lastMap = map
+    st.lastFrameKey = frameKey
+
+    const texture = resolveSpriteTexture(this, renderer, st)
+    if (texture === st.lastTexture) return
+
+    st.lastTexture = texture
+    this.set('texture', texture)
+
+    if (imageChanged !== true) return
+
+    const prevL = st._loadedCb
+    const prevF = st._failedCb
+    st._loadedCb =
+      raw['@loaded'] && typeof raw['@loaded'] === 'function'
+        ? (payload) => {
+            const d = payload?.dimensions
+            const w = payload?.w ?? payload?.width ?? d?.width ?? d?.w
+            const h = payload?.h ?? payload?.height ?? d?.height ?? d?.h
+            raw['@loaded']({ w, h }, this)
+          }
+        : null
+    st._failedCb =
+      raw['@error'] && typeof raw['@error'] === 'function'
+        ? (payload) => raw['@error'](payload, this)
+        : null
+    if (st.spriteTexture) {
+      if (prevL) st.spriteTexture.off('loaded', prevL)
+      if (prevF) st.spriteTexture.off('failed', prevF)
+      if (st._loadedCb) st.spriteTexture.on('loaded', st._loadedCb)
+      if (st._failedCb) st.spriteTexture.on('failed', st._failedCb)
+    }
+  },
   /**
    * Set an individual property on the node
    *
@@ -823,6 +938,16 @@ const Element = {
 
     Log.debug('Deleting Node', this.nodeId)
 
+    if (this[symbols.isSprite] === true && this._spriteState) {
+      const st = this._spriteState
+      if (st.spriteTexture) {
+        if (st._loadedCb) st.spriteTexture.off('loaded', st._loadedCb)
+        if (st._failedCb) st.spriteTexture.off('failed', st._failedCb)
+      }
+      if (st.subTextures) st.subTextures.clear()
+      this._spriteState = null
+    }
+
     // Clear all pending debounce timeouts
     const debounceProps = Object.keys(this.debounceTimeouts)
     for (let i = 0; i < debounceProps.length; i++) {

package/src/engines/L3/launch.js

@@ -25,6 +25,7 @@ import { SCREEN_RESOLUTIONS, RENDER_QUALITIES } from '../../constants.js'
 import colors from '../../lib/colors/colors.js'
 import fontLoader from './fontLoader.js'
 import shaderLoader from './shaderLoader.js'
+import { platform } from '../../platform.js'
 
 /** @type {RendererMain|{}} */
 export let renderer = {}
@@ -73,6 +74,11 @@ const textureMemorySettings = (settings) => {
  *
  */
 export default (App, target, settings = {}) => {
+  const screenHeight = settings.platform ? settings.platform.screenHeight : platform.screenHeight
+  const hardwareConcurrency = settings.platform
+    ? settings.platform.hardwareConcurrency
+    : platform.hardwareConcurrency
+
   renderer = new RendererMain(
     {
       ...{
@@ -84,12 +90,10 @@ export default (App, target, settings = {}) => {
         deviceLogicalPixelRatio:
           settings.pixelRatio ||
           SCREEN_RESOLUTIONS[settings.screenResolution] ||
-          SCREEN_RESOLUTIONS[window.innerHeight] ||
+          SCREEN_RESOLUTIONS[screenHeight] ||
           1,
         numImageWorkers:
-          'webWorkersLimit' in settings
-            ? settings.webWorkersLimit
-            : window.navigator.hardwareConcurrency || 2,
+          'webWorkersLimit' in settings ? settings.webWorkersLimit : hardwareConcurrency || 2,
         clearColor: (settings.canvasColor && colors.normalize(settings.canvasColor)) || 0x00000000,
         inspector: settings.inspector === true ? Inspector : undefined,
         boundsMargin: settings.viewportMargin || 0,
@@ -100,7 +104,7 @@ export default (App, target, settings = {}) => {
         textureMemory: textureMemorySettings(settings),
         createImageBitmapSupport: 'auto',
         targetFPS: 'maxFPS' in settings ? settings.maxFPS : 0,
-        platform: 'platform' in settings ? settings.platform : null,
+        platform: settings.rendererPlatform || null,
       },
       ...(settings.advanced || {}),
     },

package/src/engines/L3/spriteTexture.js

@@ -0,0 +1,71 @@
+/**
+ * Resolves a sprite sheet frame from map + frame (template Sprite element path on L3).
+ * @param {import('../../component.js').BlitsElement} element
+ * @param {object} r - renderer
+ * @param {any} state - mutated sprite cache (see L3 element _spriteState)
+ * @returns {any|null} texture for the node
+ */
+export function resolveSpriteTexture(element, r, state) {
+  const image = element.props.raw['image']
+  if (image === undefined || image === null) {
+    return null
+  }
+  if (r === null || r === undefined || r.createTexture === undefined) {
+    return null
+  }
+
+  if (
+    state.spriteTexture === undefined ||
+    state.spriteTexture === null ||
+    state.currentSrc !== image
+  ) {
+    state.spriteTexture = r.createTexture('ImageTexture', {
+      src: image,
+    })
+    state.currentSrc = image
+    state.subTextures = null
+    state.currentMap = null
+  }
+
+  const map = element.props.raw['map']
+
+  if (state.currentMap !== map) {
+    state.currentMap = map
+    state.subTextures = null
+  }
+  const frame = element.props.raw['frame']
+
+  let options = null
+  if (map != null && frame != null) {
+    if (map.frames != null && map.frames !== undefined && frame in map.frames) {
+      options = Object.assign({}, map.defaults || {}, map.frames[frame])
+    } else if (frame in map) {
+      options = map[frame]
+    }
+  }
+
+  if ((options === null || options === undefined) && typeof frame === 'object' && frame !== null) {
+    options = frame
+  }
+
+  if (options != null) {
+    const key = typeof frame === 'object' ? JSON.stringify(frame) : String(frame)
+    if (!state.subTextures) {
+      state.subTextures = new Map()
+    }
+    const cached = state.subTextures.get(key)
+    if (cached !== undefined) {
+      return cached
+    }
+    const subTexture = r.createTexture('SubTexture', {
+      texture: state.spriteTexture,
+      x: options.x,
+      y: options.y,
+      w: options.w,
+      h: options.h,
+    })
+    state.subTextures.set(key, subTexture)
+    return subTexture
+  }
+  return state.spriteTexture
+}

package/src/focus/focus.js

@@ -21,7 +21,7 @@ import Settings from '../settings.js'
 import { DEFAULT_HOLD_TIMEOUT_MS } from '../constants.js'
 import { Log } from '../lib/log.js'
 import { getAncestors } from './helpers.js'
-import InternalKeyboardEvent from '../lib/events/internalkeyboardevent.js'
+import { platform } from '../platform.js'
 
 let focusedComponent = null
 let focusChain = []
@@ -136,8 +136,11 @@ const setFocus = (component, event) => {
   focusedComponent = component
   component[symbols.lifecycle].state = 'focus'
 
-  if (event instanceof KeyboardEvent) {
-    const internalEvent = new InternalKeyboardEvent('keydown', event)
-    document.dispatchEvent(internalEvent)
+  if (platform.isKeyboardEvent && platform.isKeyboardEvent(event) && platform.dispatchEvent) {
+    const internalEvent = platform.createKeyboardEvent
+      ? platform.createKeyboardEvent('keydown', event)
+      : event
+    internalEvent[symbols.internalEvent] = true
+    platform.dispatchEvent(internalEvent)
   }
 }

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/codegenerator/generator.js

@@ -206,6 +206,10 @@ const generateElementCode = function (
     renderCode.push(`elementConfigs[${counter}][Symbol.for('isSlot')] = true`)
   }
 
+  if (templateObject[Symbol.for('componentType')] === 'Sprite') {
+    renderCode.push(`elementConfigs[${counter}][Symbol.for('isSprite')] = true`)
+  }
+
   if (options.holder) {
     renderCode.push(`elementConfigs[${counter}]['holder'] = true`)
   }
@@ -611,11 +615,16 @@ const generateForLoopCode = function (templateObject, parent) {
   if (
     templateObject[Symbol.for('componentType')] === 'Element' ||
     templateObject[Symbol.for('componentType')] === 'Slot' ||
-    templateObject[Symbol.for('componentType')] === 'Text'
+    templateObject[Symbol.for('componentType')] === 'Text' ||
+    templateObject[Symbol.for('componentType')] === 'Sprite' ||
+    templateObject[Symbol.for('componentType')] === 'Layout'
   ) {
     if (templateObject[Symbol.for('componentType')] === 'Text') {
       templateObject.__textnode = 'true'
     }
+    if (templateObject[Symbol.for('componentType')] === 'Layout') {
+      templateObject.__layout = 'true'
+    }
     generateElementCode.call(ctx, templateObject, parent, {
       key: 'scope.key',
       component: 'scope.',
@@ -788,7 +797,8 @@ const generateCode = function (templateObject, parent = false, options = {}) {
           childTemplateObject[Symbol.for('componentType')] === 'Element' ||
           childTemplateObject[Symbol.for('componentType')] === 'Slot' ||
           childTemplateObject[Symbol.for('componentType')] === 'Text' ||
-          childTemplateObject[Symbol.for('componentType')] === 'Layout'
+          childTemplateObject[Symbol.for('componentType')] === 'Layout' ||
+          childTemplateObject[Symbol.for('componentType')] === 'Sprite'
         ) {
           if (childTemplateObject[Symbol.for('componentType')] === 'Text') {
             childTemplateObject.__textnode = 'true'

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/lib/symbols.js

@@ -61,6 +61,7 @@
  * @property {symbol} components
  * @property {symbol} config
  * @property {symbol} isSlot
+ * @property {symbol} isSprite
  * @property {symbol} props
  * @property {symbol} parent
  * @property {symbol} slots
@@ -68,6 +69,7 @@
  * @property {symbol} isComponent
  * @property {symbol} effects
  * @property {symbol} removeGlobalEffects
+ * @property {symbol} tagContent
  */
 
 /**
@@ -126,6 +128,8 @@ export default {
   config: Symbol.for('config'),
   // Symbol 'isSlot' utilized within generated code
   isSlot: Symbol.for('isSlot'),
+  // Symbol 'isSprite' utilized within generated code (native Sprite on L3 element)
+  isSprite: Symbol.for('isSprite'),
   // Symbol 'props' utilized within generated code
   props: Symbol.for('props'),
   // Symbol 'slots' utilized within generated code

package/src/platform.js

@@ -0,0 +1,117 @@
+/*
+ * 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 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,
+    SpeechSynthesisUtterance:
+      globalScope.SpeechSynthesisUtterance || (windowRef && windowRef.SpeechSynthesisUtterance),
+    speechSynthesis:
+      (selfRef && selfRef.speechSynthesis) || (windowRef && windowRef.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.SpeechSynthesisUtterance =
+    platform.SpeechSynthesisUtterance || basePlatform.SpeechSynthesisUtterance
+  platform.speechSynthesis = platform.speechSynthesis || basePlatform.speechSynthesis
+  platform.now = platform.now || basePlatform.now
+
+  return platform
+}

package/src/platforms.d.ts

@@ -0,0 +1 @@
+export { WebPlatform, WebPlatformNext, WebPlatformChrome50, WebPlatformLegacy } from '@lightningjs/renderer/platforms'

package/src/platforms.js

@@ -0,0 +1,23 @@
+/*
+ * 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
+ */
+
+export {
+  WebPlatform,
+  WebPlatformNext,
+  WebPlatformChrome50,
+  WebPlatformLegacy,
+} from '@lightningjs/renderer/platforms'