Add LTC support and enhancements on Windows

.gitignore

@@ -8,6 +8,7 @@ node_modules
 assets.json
 dist
 bin
+build
 
 # temporary files
 data

CHANGELOG.md

@@ -5,9 +5,21 @@
 - Support for named urls when sharing links to workspaces
 - Ability to convert items to other types by right-clicking
 - Ancestor items in context menus now stay tinted when their child menus are opened
+- A shortcut to open preferences (CMD/CTRL+,)
+- Support for lists in settings
+- Support for custom ids in select inputs in settings
+- Support for LTC timecode and triggers
+- A state evaluation API
+- Granular type inheritance
+- Default names to types
+### Changed
+- Some features have moved to the footer of the app window
+- Context menus now follow the color theme
+- Windows builds now use a custom window header
 ### Fixed
 - An issue where the inspector started to scroll horisontally on overflow
 - Closing electron windows may cause a loop preventing user defaults from being saved
+- An issue where settings didn't render after reload
 
 ## 1.0.0-beta.8
 ### Fixed

README.md

@@ -44,6 +44,7 @@ The roadmap is available on Notion
 - OSC API and triggers
 - HTTP triggers
 - CasparCG library, playout and templates
+- LTC timecode triggers
 
 ## Community plugins  
 - [CRON - triggers based on the time of day](https://github.com/axelboberg/bridge-plugin-cron)

api/events.js

@@ -202,7 +202,9 @@ class Events {
    * @param { EventHandler } handler A handler to remove
    */
   off (event, handler) {
-    if (!this.localHandlers.has(event)) return
+    if (!this.localHandlers.has(event)) {
+      return
+    }
 
     const handlers = this.localHandlers.get(event)
     const index = handlers.findIndex(({ handler: _handler }) => _handler === handler)

api/index.js

@@ -18,6 +18,7 @@ require('./system')
 require('./state')
 require('./types')
 require('./items')
+require('./time')
 require('./ui')
 
 class API {
@@ -36,6 +37,7 @@ class API {
     this.state = props.State
     this.types = props.Types
     this.items = props.Items
+    this.time = props.Time
     this.ui = props.UI
   }
 }
@@ -55,6 +57,7 @@ DIController.main.register('API', API, [
   'State',
   'Types',
   'Items',
+  'Time',
   'UI'
 ])
 

api/settings.js

@@ -12,6 +12,9 @@
 
 const DIController = require('../shared/DIController')
 
+const MissingArgumentError = require('./error/MissingArgumentError')
+const InvalidArgumentError = require('./error/InvalidArgumentError')
+
 class Settings {
   #props
 
@@ -23,11 +26,31 @@ class Settings {
    * Register a setting
    * by its specification
    * @param { SettingSpecification } specification A setting specification
-   * @returns { Promise.<Boolean> }
+   * @returns { Promise.<string> }
    */
   registerSetting (specification) {
     return this.#props.Commands.executeCommand('settings.registerSetting', specification)
   }
+
+  /**
+   * Apply changes to a registered
+   * setting in the state
+   *
+   * @param { String } id The id of a setting to update
+   * @param { SettingSpecification } set A setting object to apply
+   * @returns { Promise.<boolean> }
+   */
+  async applySetting (id, set = {}) {
+    if (typeof id !== 'string') {
+      throw new MissingArgumentError('Invalid value for item id, must be a string')
+    }
+
+    if (typeof set !== 'object' || Array.isArray(set)) {
+      throw new InvalidArgumentError('Argument \'set\' must be a valid object that\'s not an array')
+    }
+
+    return this.#props.Commands.executeCommand('settings.applySetting', id, set)
+  }
 }
 
 DIController.main.register('Settings', Settings, [

api/state.js

@@ -7,8 +7,53 @@ const merge = require('../shared/merge')
 const Cache = require('./classes/Cache')
 const DIController = require('../shared/DIController')
 
+const objectPath = require('object-path')
+
 const CACHE_MAX_ENTRIES = 10
 
+function mapObject (obj, map) {
+  if (typeof map !== 'object' || typeof obj !== 'object') {
+    return obj
+  }
+
+  const out = {}
+  for (const [key, path] of Object.entries(map)) {
+    if (typeof path !== 'string') {
+      continue
+    }
+    out[key] = obj[path]
+  }
+  return out
+}
+
+const EVALUATION_OPERATIONS = {
+  arrayFromObject: (opts, data) => {
+    if (typeof opts?.path !== 'string') {
+      return
+    }
+
+    const obj = objectPath.get(data, opts.path)
+    if (!obj) {
+      return
+    }
+
+    return Object.entries(obj)
+      .map(([, value]) => {
+        let _value = value
+        if (typeof value !== 'object') {
+          _value = { value }
+        }
+        return mapObject(_value, opts?.map)
+      })
+  },
+  concatArrays: (opts, data) => {
+    if (!Array.isArray(opts?.a) || !Array.isArray(opts?.b)) {
+      return opts?.a
+    }
+    return [...opts.a, ...opts.b]
+  }
+}
+
 class State {
   #props
 
@@ -117,24 +162,98 @@ class State {
     }
   }
 
+  /**
+   * Create a new object by expanding the path
+   * and set the provided value
+   * @param { string } path
+   * @param { any } value
+   * @param { string | undefined } delimiter
+   * @returns { any }
+   */
+  #expandObjectPath (path, value, delimiter = '.') {
+    const parts = path.split(delimiter)
+
+    const out = {}
+    let pointer = out
+
+    for (let i = 0; i < parts.length; i++) {
+      const key = parts[i]
+      if (i === parts.length - 1) {
+        pointer[key] = value
+      } else {
+        pointer[key] = {}
+        pointer = pointer[key]
+      }
+    }
+
+    return out
+  }
+
   /**
    * Apply some data to the state,
    * most often this function shouldn't
    * be called directly - there's probably
    * a command for what you want to do
-   * @param { Object } set Data to apply to the state
+   * @param { object } set Data to apply to the state
    *//**
    * Apply some data to the state,
    * most often this function shouldn't
    * be called directly - there's probably
    * a command for what you want to do
-   * @param { Object[] } set An array of data objects to
+   * @param { object[] } set An array of data objects to
    *                         apply to the state in order
+   *//**
+   * Apply some data to the state,
+   * most often this function shouldn't
+   * be called directly - there's probably
+   * a command for what you want to do
+   * @param { string } path A dot-path to which the value will be applied
+   * @param { object } set A value to apply
    */
-  apply (set) {
+  apply (arg0, arg1) {
+    let set = arg0
+
+    /*
+    If the function received a path and a value,
+    expand create an object that can be set directly
+    */
+    if (typeof arg0 === 'string' && arg1) {
+      set = this.#expandObjectPath(arg0, arg1)
+    }
+
     this.#props.Commands.executeRawCommand('state.apply', set)
   }
 
+  #evaluateProperty (propertyFieldEvaluation, dataDict = {}) {
+    const op = propertyFieldEvaluation?.op
+    if (!op || !EVALUATION_OPERATIONS[op]) {
+      return
+    }
+    return EVALUATION_OPERATIONS[op](propertyFieldEvaluation, dataDict)
+  }
+
+  async evaluate (obj, data) {
+    if (typeof obj !== 'object' || !obj) {
+      return obj
+    }
+
+    let _data = data
+    if (!_data) {
+      _data = this.getLocalState() || await this.get()
+    }
+
+    for (const key of Object.keys(obj)) {
+      obj[key] = await this.evaluate(obj[key], _data)
+    }
+
+    if (obj?.$eval) {
+      const newObj = this.#evaluateProperty(obj.$eval, _data)
+      return this.evaluate(newObj, _data)
+    }
+
+    return obj
+  }
+
   /**
    * Get the full current state
    * @returns { Promise.<State> }

api/time.js

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2026 Axel Boberg
+//
+// SPDX-License-Identifier: MIT
+
+const DIController = require('../shared/DIController')
+
+class Time {
+  #props
+
+  constructor (props) {
+    this.#props = props
+  }
+
+  getAllClocks () {
+    return this.#props.Commands.executeCommand('time.getAllClocks')
+  }
+
+  registerClock (spec) {
+    return this.#props.Commands.executeCommand('time.registerClock', spec)
+  }
+
+  removeClock (id) {
+    return this.#props.Commands.executeCommand('time.removeClock', id)
+  }
+
+  applyClock (id, set) {
+    return this.#props.Commands.executeCommand('time.applyClock', id, set)
+  }
+
+  submitFrame (id, frame) {
+    return this.#props.Commands.executeRawCommand('time.submitFrame', id, frame)
+  }
+}
+
+DIController.main.register('Time', Time, [
+  'State',
+  'Events',
+  'Commands'
+])

api/types.js

@@ -5,21 +5,50 @@
 const Cache = require('./classes/Cache')
 const DIController = require('../shared/DIController')
 
+const utils = require('./utils')
+
 const CACHE_MAX_ENTRIES = 100
 
+function shallowMergeObjects (a, b) {
+  if (typeof a !== 'object' || typeof b !== 'object') {
+    return b
+  }
+
+  return {
+    ...a,
+    ...b
+  }
+}
+
+/*
+Export for testing only
+*/
+exports.shallowMergeObjects = shallowMergeObjects
+
 /**
- * Perform a deep clone
- * of an object
- * @param { any } obj An object to clone
+ * Merge all properties two level deep
+ * from two types
+ * @param { any } a
+ * @param { any } b
  * @returns { any }
  */
-function deepClone (obj) {
-  if (typeof window !== 'undefined' && window.structuredClone) {
-    return window.structuredClone(obj)
+function mergeProperties (a, b) {
+  const out = { ...a }
+  for (const key of Object.keys(b)) {
+    if (Object.prototype.hasOwnProperty.call(out, key)) {
+      out[key] = shallowMergeObjects(a[key], b[key])
+    } else {
+      out[key] = b[key]
+    }
   }
-  return JSON.parse(JSON.stringify(obj))
+  return out
 }
 
+/*
+Export for testing only
+*/
+exports.mergeProperties = mergeProperties
+
 class Types {
   #props
 
@@ -43,7 +72,8 @@ class Types {
   renderType (id, typesDict = {}) {
     if (!typesDict[id]) return undefined
 
-    const type = deepClone(typesDict[id])
+    const type = utils.deepClone(typesDict[id])
+    type.ancestors = []
 
     /*
     Render the ancestor if this
@@ -52,10 +82,12 @@ class Types {
     if (type.inherits) {
       const ancestor = this.renderType(type.inherits, typesDict)
 
-      type.properties = {
-        ...ancestor?.properties || {},
-        ...type.properties || {}
-      }
+      type.ancestors = [...(ancestor?.ancestors || []), type.inherits]
+      type.category = type.category || ancestor?.category
+      type.properties = mergeProperties(
+        (ancestor?.properties || {}),
+        (type?.properties || {})
+      )
     }
 
     return type