entangled-worlds-orbiters-shared 4.2.0 → 5.0.0

package/src/shortcuts/catalogue.ts

@@ -0,0 +1,172 @@
+// The shortcut catalogue as the apps read it: every app's sections of actions, their default keys and
+// names, as the backend serves them (from its config, so a key or a name changes without a library
+// release). This file only reads what was served; it holds no actions of its own.
+
+import type { ShortcutAction, ShortcutNames } from './match.js'
+
+/** Something with a name: English `label`, other languages in `names`. */
+export interface ShortcutNamed {
+  readonly id: string
+  readonly label: string
+  readonly names?: ShortcutNames
+}
+
+/** A row of a keys sheet (`?`): one line for one or more actions whose keys show together. */
+export interface ShortcutSheetRow extends ShortcutNamed {
+  readonly actions: readonly string[]
+}
+
+export interface ShortcutSheetColumn extends ShortcutNamed {
+  readonly rows: readonly ShortcutSheetRow[]
+}
+
+/** One surface's keys (`orbiters-play`, `ew-studio`, `site`). Two actions clash only inside a section. */
+export interface ShortcutSection {
+  readonly id: string
+  /** The app it belongs to (`orbiters`) and that app's name. */
+  readonly app: string
+  readonly appLabel: string
+  readonly appNames?: ShortcutNames
+  readonly label: string
+  readonly names?: ShortcutNames
+  /** Its name inside the app (`Play`, `Studio`); none when the app has only this section. */
+  readonly part?: string
+  readonly partNames?: ShortcutNames
+  /** How a command menu groups the actions, in its order. */
+  readonly groups: readonly ShortcutNamed[]
+  /** The keys sheet, where the app shows one in columns. */
+  readonly sheet?: readonly ShortcutSheetColumn[]
+  readonly actions: readonly ShortcutAction[]
+  /**
+   * Letters a surface of this section plays while it is open (`event.key`, lower-case; the Orbiters
+   * on-screen keyboard): a shortcut on one of them waits until it closes.
+   */
+  readonly heldKeys?: readonly string[]
+}
+
+export interface ShortcutCatalogue {
+  /** Changes whenever the catalogue is edited. */
+  readonly version: string
+  readonly sections: readonly ShortcutSection[]
+}
+
+/** Before the catalogue is read: no sections, so no key does anything yet. */
+export const EMPTY_CATALOGUE: ShortcutCatalogue = Object.freeze({ version: '', sections: Object.freeze([]) })
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === 'object' && !Array.isArray(value)
+const isString = (value: unknown): value is string => typeof value === 'string' && value.length > 0
+
+function names(value: unknown): ShortcutNames | undefined {
+  if (!isRecord(value)) return undefined
+  const out: Record<string, string> = {}
+  for (const [locale, name] of Object.entries(value)) if (isString(name)) out[locale] = name
+  return Object.freeze(out)
+}
+
+function named(value: unknown): ShortcutNamed | null {
+  if (!isRecord(value) || !isString(value.id) || !isString(value.label)) return null
+  return { id: value.id, label: value.label, names: names(value.names) }
+}
+
+function action(value: unknown): ShortcutAction | null {
+  const base = named(value)
+  if (!base || !isRecord(value) || !isString(value.scope) || !Array.isArray(value.defaultKeys)) return null
+  return Object.freeze({
+    ...base,
+    defaultKeys: Object.freeze(value.defaultKeys.filter(isString)),
+    scope: value.scope,
+    ...(isString(value.group) ? { group: value.group } : {}),
+    ...(value.command === false ? { command: false } : {}),
+    ...(isString(value.href) ? { href: value.href } : {}),
+    ...(value.signedIn === true ? { signedIn: true } : {}),
+  })
+}
+
+const list = <T>(value: unknown, read: (item: unknown) => T | null): readonly T[] =>
+  Object.freeze(Array.isArray(value) ? value.map(read).filter((item): item is T => item !== null) : [])
+
+function section(value: unknown): ShortcutSection | null {
+  const base = named(value)
+  if (!base || !isRecord(value) || !isString(value.app) || !isString(value.appLabel)) return null
+  return Object.freeze({
+    ...base,
+    app: value.app,
+    appLabel: value.appLabel,
+    appNames: names(value.appNames),
+    ...(isString(value.part) ? { part: value.part, partNames: names(value.partNames) } : {}),
+    groups: list(value.groups, named),
+    ...(Array.isArray(value.sheet)
+      ? {
+          sheet: list(value.sheet, (column) => {
+            const head = named(column)
+            if (!head || !isRecord(column)) return null
+            return Object.freeze({
+              ...head,
+              rows: list(column.rows, (row) => {
+                const line = named(row)
+                return line && isRecord(row) ? Object.freeze({ ...line, actions: list(row.actions, (id) => (isString(id) ? id : null)) }) : null
+              }),
+            })
+          }),
+        }
+      : {}),
+    actions: list(value.actions, action),
+    ...(Array.isArray(value.heldKeys) ? { heldKeys: list(value.heldKeys, (key) => (isString(key) ? key : null)) } : {}),
+  })
+}
+
+/**
+ * The catalogue a response holds (`{ version, sections }`), or `null` when it holds none. A malformed
+ * section or action is left out rather than failing the whole read.
+ */
+export function parseCatalogue(value: unknown): ShortcutCatalogue | null {
+  if (!isRecord(value) || !Array.isArray(value.sections)) return null
+  return Object.freeze({ version: typeof value.version === 'string' ? value.version : '', sections: list(value.sections, section) })
+}
+
+/** A name in a language (`es`, `es-AR`), the English when there is none in it. */
+export function localName(item: { readonly label: string; readonly names?: ShortcutNames }, locale?: string): string {
+  return item.names?.[(locale ?? '').slice(0, 2).toLowerCase()] ?? item.label
+}
+
+/** A section's app name in a language. */
+export function localAppName(section: Pick<ShortcutSection, 'appLabel' | 'appNames'>, locale?: string): string {
+  return localName({ label: section.appLabel, names: section.appNames }, locale)
+}
+
+/** A section's part name (`Play`, `Studio`) in a language; `undefined` when it has none. */
+export function localPartName(section: Pick<ShortcutSection, 'part' | 'partNames'>, locale?: string): string | undefined {
+  return section.part === undefined ? undefined : localName({ label: section.part, names: section.partNames }, locale)
+}
+
+/** The apps the catalogue has, in its order. */
+export function shortcutApps(catalogue: ShortcutCatalogue): ReadonlyArray<{ id: string; label: string; names?: ShortcutNames }> {
+  const seen = new Map<string, { id: string; label: string; names?: ShortcutNames }>()
+  for (const s of catalogue.sections) if (!seen.has(s.app)) seen.set(s.app, { id: s.app, label: s.appLabel, names: s.appNames })
+  return [...seen.values()]
+}
+
+const actionLists = new WeakMap<ShortcutCatalogue, Map<string, readonly ShortcutAction[]>>()
+
+/**
+ * The actions of these sections, in the order named: where two sections hold one key, the first
+ * named wins (the Orbiter Studio lies over play). The same list object for as long as the catalogue
+ * is the same, so a cache keyed by it holds.
+ */
+export function sectionActions(catalogue: ShortcutCatalogue, ...sectionIds: string[]): readonly ShortcutAction[] {
+  let lists = actionLists.get(catalogue)
+  if (!lists) actionLists.set(catalogue, (lists = new Map()))
+  const key = sectionIds.join('\n')
+  let found = lists.get(key)
+  if (!found) {
+    found = Object.freeze(sectionIds.flatMap((id) => catalogue.sections.find((s) => s.id === id)?.actions ?? []))
+    lists.set(key, found)
+  }
+  return found
+}
+
+/** One section, if the catalogue has it. */
+export function findSection(catalogue: ShortcutCatalogue, sectionId: string): ShortcutSection | undefined {
+  return catalogue.sections.find((s) => s.id === sectionId)
+}

package/src/shortcuts/index.ts

@@ -1,7 +1,7 @@
-// Keyboard shortcuts, one system for every app: each app's catalogue of actions (id, section, label,
-// default keys, scope) and one matcher that says which action a key press is. Keys are named by
-// their place on the keyboard (`KeyboardEvent.code`). Framework-free: no React, no DOM beyond reading
-// a key event.
+// Keyboard shortcuts, one system for every app: the reader of the shortcut catalogue (every app's
+// actions and default keys, served by the backend) and of a person's own keys, and one matcher that
+// says which action a key press is. Keys are named by their place on the keyboard
+// (`KeyboardEvent.code`). Framework-free: no React, no DOM beyond reading a key event.
 
 export {
   parseChord,
@@ -24,21 +24,11 @@ export {
   isKeyClaimed,
   isTypingTarget,
   type ShortcutAction,
+  type ShortcutNames,
   type ShortcutBindings,
   type ShortcutOverrides,
   type ShortcutEvent,
 } from './match.js'
-export {
-  ORBITERS_PLAY_SHORTCUTS,
-  ORBITERS_STUDIO_SHORTCUTS,
-  ORBITERS_PLAY_SECTION,
-  ORBITERS_STUDIO_SECTION,
-  ORBITERS_KEYBOARD_SURFACE_KEYS,
-  ORBITERS_COMMAND_GROUPS,
-  ORBITERS_PLAY_SHEET,
-  type OrbitersShortcut,
-  type OrbitersShortcutScope,
-} from './orbiters.js'
 export {
   shortcutPlatform,
   keyLabel,
@@ -50,20 +40,28 @@ export {
   type ShortcutPlatform,
   type KeyLayout,
 } from './format.js'
-export { SHORTCUT_SECTIONS, SHORTCUT_APPS, type ShortcutSection, type ShortcutAppId } from './sections.js'
-export { SITE_SHORTCUTS, SITE_SECTION, type SiteShortcut } from './site.js'
 export {
-  EW_STUDIO_SHORTCUTS,
-  EW_PLAYER_SHORTCUTS,
-  EW_STUDIO_SECTION,
-  EW_PLAYER_SECTION,
-  EW_STUDIO_COMMAND_GROUPS,
-  type EntangledWorldsShortcut,
-} from './entangledWorlds.js'
-export { shortcutLabel, shortcutSectionLabel, shortcutName } from './labels.js'
+  EMPTY_CATALOGUE,
+  parseCatalogue,
+  localName,
+  localAppName,
+  localPartName,
+  shortcutApps,
+  sectionActions,
+  findSection,
+  type ShortcutCatalogue,
+  type ShortcutSection,
+  type ShortcutNamed,
+  type ShortcutSheetColumn,
+  type ShortcutSheetRow,
+} from './catalogue.js'
 export {
-  createShortcutOverridesSource,
+  createShortcutSource,
+  localShortcutCatalogueStore,
+  CATALOGUE_STORAGE_KEY,
   parseOverrides,
-  type ShortcutOverridesSource,
+  type ShortcutCatalogueStore,
+  type ShortcutSource,
   type ReadAccountSettings,
-} from './overrides.js'
+  type ReadShortcutCatalogue,
+} from './source.js'

package/src/shortcuts/match.ts

@@ -4,14 +4,14 @@
 
 import { chordMatches, isCommandChord, isModifierCode, keysOverlap, parseChord, parseKeys, type Chord, type ModifierState } from './chord.js'
 
-/** One thing a key can do, as an app's catalogue declares it. */
+/** One thing a key can do, as the shortcut catalogue (served by the backend) lists it. */
 export interface ShortcutAction<Scope extends string = string> {
   /** `<app>.<area>.<action>`, e.g. `orbiters.play.panel.jamming`: the key a person's override is stored under. */
   readonly id: string
-  /** The group it is shown in, one per app surface (`orbiters-play`). Keys clash only inside a section. */
-  readonly section: string
-  /** What it does, in sentence case. */
+  /** What it does, in sentence case, in English. */
   readonly label: string
+  /** Its name in other languages, by locale (`{ es: '…' }`); see `localName`. */
+  readonly names?: ShortcutNames
   /** The keys it has until the person changes them (chord strings, see `chord.ts`). */
   readonly defaultKeys: readonly string[]
   /** What it acts on, in the app's own terms (Orbiters: one deck, or this machine). */
@@ -20,14 +20,21 @@ export interface ShortcutAction<Scope extends string = string> {
   readonly group?: string
   /** `false`: a key only, never a command to pick from a list (a key held down, the menu itself). */
   readonly command?: boolean
+  /** A site action: the page it opens (`{username}` stands for the signed-in person's). */
+  readonly href?: string
+  /** It needs someone signed in. */
+  readonly signedIn?: boolean
 }
 
+/** A name in other languages than English, by locale (`es`). */
+export type ShortcutNames = Readonly<Record<string, string>>
+
 /** The keys of each action, in the order they are tried: the first action a press matches is the one. */
 export type ShortcutBindings = Iterable<readonly [actionId: string, keys: readonly string[]]>
 
 /**
  * A person's changes, as their settings store them: an action's own keys (`[]` = no key). An action
- * left out keeps its defaults, so a default changed in code reaches everyone who never touched it.
+ * left out keeps its defaults, so a default changed in the catalogue reaches everyone who never touched it.
  */
 export type ShortcutOverrides = ReadonlyArray<{ readonly id: string; readonly keys: readonly string[] }>
 

package/src/shortcuts/source.ts

@@ -0,0 +1,204 @@
+// Where an app's keys come from, read the same way by every app: the catalogue (every action and its
+// default keys, from the backend) and the person's own changes (their account's settings; someone
+// signed out has the defaults). Both are read at start and again whenever the page comes back to the
+// front, so a key changed in the catalogue or on the settings page applies on return, without a reload.
+//
+// Framework-free: the app hands in how it reads each (its own API client) and gets the catalogue, the
+// overrides, and each list of actions' resolved keys back, kept until either changes.
+
+import { EMPTY_CATALOGUE, parseCatalogue, sectionActions, type ShortcutCatalogue } from './catalogue.js'
+import { resolveBindings, type ShortcutAction, type ShortcutOverrides } from './match.js'
+
+/** The overrides in a stored value, or `null` when it is not a list of `{ id, keys }`. */
+export function parseOverrides(value: unknown): ShortcutOverrides | null {
+  if (!Array.isArray(value)) return null
+  return value.filter(
+    (entry): entry is { id: string; keys: string[] } =>
+      !!entry && typeof entry.id === 'string' && Array.isArray(entry.keys) && entry.keys.every((k: unknown) => typeof k === 'string'),
+  )
+}
+
+/**
+ * How the app reads the signed-in person's settings: `null` when no one is signed in (the
+ * default keys); `undefined` when the read failed (the overrides in force are kept: a blip must not
+ * swap someone's keys for the defaults).
+ */
+export type ReadAccountSettings = (options: { fresh: boolean }) => Promise<{ shortcuts?: unknown } | null | undefined>
+
+/**
+ * How the app reads the catalogue (`{ version, sections }`); `undefined` or a throw when the read
+ * failed (the catalogue in force is kept). There is no copy in the app: until the first read
+ * answers, no key does anything.
+ */
+export type ReadShortcutCatalogue = (options: { fresh: boolean }) => Promise<unknown>
+
+export interface ShortcutSource {
+  /** The catalogue in force (empty until it is read). */
+  catalogue(): ShortcutCatalogue
+  /** The actions of these sections, the first named winning a shared key; the same list until the catalogue changes. */
+  actions(...sectionIds: string[]): readonly ShortcutAction[]
+  /** The person's overrides in force. */
+  overrides(): ShortcutOverrides
+  /** A list of actions with their keys now (kept until the catalogue or the overrides change). */
+  bindings(actions: readonly ShortcutAction[]): Map<string, readonly string[]>
+  /** Called whenever the catalogue or the overrides change; returns the unsubscribe. */
+  subscribe(listener: () => void): () => void
+  /** Read both again (`fresh`: past the app's own cached read). The newest read of each wins, whatever order they end in. */
+  refresh(options?: { fresh?: boolean }): Promise<void>
+  /** Read now, and again whenever the page comes back to the front; once per source. */
+  bind(): void
+  /** For tests: set the overrides directly. */
+  setOverrides(overrides: ShortcutOverrides): void
+  /** For tests: set the catalogue directly. */
+  setCatalogue(catalogue: ShortcutCatalogue): void
+}
+
+/**
+ * Where a device keeps the last catalogue it read: offline (the desktop app with no connection) the
+ * keys are the ones it last had, and on every start they answer before the read comes back. A copy of
+ * what was served, never a list of its own.
+ */
+export interface ShortcutCatalogueStore {
+  load(): unknown
+  save(value: unknown): void
+}
+
+export const CATALOGUE_STORAGE_KEY = 'ps.shortcutCatalogue'
+
+/** This browser's localStorage, when there is one and it may be used; otherwise nothing is kept. */
+export function localShortcutCatalogueStore(): ShortcutCatalogueStore | null {
+  const storage = (globalThis as { localStorage?: Storage }).localStorage
+  if (!storage) return null
+  return {
+    load() {
+      try {
+        const raw = storage.getItem(CATALOGUE_STORAGE_KEY)
+        return raw ? JSON.parse(raw) : undefined
+      } catch {
+        return undefined
+      }
+    },
+    save(value) {
+      try {
+        storage.setItem(CATALOGUE_STORAGE_KEY, JSON.stringify(value))
+      } catch {
+        // Full or refused (a private window): the next start reads the backend first, as without a store.
+      }
+    },
+  }
+}
+
+/** Coming back to the front twice in a row (visible, then focus) reads once. */
+const REFRESH_GAP_MS = 2000
+
+/** Keeps the answer of the newest read that answered: an older one ending later says nothing new. */
+function newestRead<T>(read: (fresh: boolean) => Promise<T | undefined>, apply: (value: T) => void) {
+  let latest = 0
+  let applied = 0
+  return async (fresh: boolean) => {
+    const ticket = ++latest
+    let value: T | undefined
+    try {
+      value = await read(fresh)
+    } catch {
+      value = undefined
+    }
+    if (value === undefined || ticket < applied) return
+    applied = ticket
+    apply(value)
+  }
+}
+
+export function createShortcutSource({
+  readCatalogue,
+  readAccount,
+  store = localShortcutCatalogueStore(),
+}: {
+  readCatalogue: ReadShortcutCatalogue
+  readAccount: ReadAccountSettings
+  /** Where the last catalogue read is kept (this browser's localStorage by default; `null`: nowhere). */
+  store?: ShortcutCatalogueStore | null
+}): ShortcutSource {
+  let catalogue: ShortcutCatalogue = (store && parseCatalogue(store.load())) || EMPTY_CATALOGUE
+  let overrides: ShortcutOverrides = []
+  let resolved = new WeakMap<readonly ShortcutAction[], Map<string, readonly string[]>>()
+  let lastRefreshAt = -Infinity
+  let bound = false
+  const listeners = new Set<() => void>()
+
+  const changed = () => {
+    resolved = new WeakMap()
+    listeners.forEach((listener) => listener())
+  }
+  const applyOverrides = (next: ShortcutOverrides) => {
+    if (JSON.stringify(next) === JSON.stringify(overrides)) return
+    overrides = next
+    changed()
+  }
+  const applyCatalogue = (next: ShortcutCatalogue) => {
+    if (next === catalogue || (next.version && next.version === catalogue.version && next.sections.length === catalogue.sections.length)) return
+    catalogue = next
+    changed()
+  }
+
+  const refreshCatalogue = newestRead(
+    async (fresh) => {
+      const value = await readCatalogue({ fresh })
+      const read = value === undefined ? null : parseCatalogue(value)
+      if (!read) return undefined
+      if (read.version !== catalogue.version) store?.save(value)
+      return read
+    },
+    applyCatalogue,
+  )
+  const refreshAccount = newestRead(
+    async (fresh) => {
+      const settings = await readAccount({ fresh })
+      return settings === undefined ? undefined : settings === null ? [] : (parseOverrides(settings.shortcuts) ?? [])
+    },
+    applyOverrides,
+  )
+
+  const refresh = async ({ fresh = false }: { fresh?: boolean } = {}) => {
+    lastRefreshAt = Date.now()
+    await Promise.all([refreshCatalogue(fresh), refreshAccount(fresh)])
+  }
+
+  return {
+    catalogue: () => catalogue,
+    actions: (...sectionIds) => sectionActions(catalogue, ...sectionIds),
+    overrides: () => overrides,
+    bindings(actions) {
+      let map = resolved.get(actions)
+      if (!map) {
+        map = resolveBindings(actions, overrides)
+        resolved.set(actions, map)
+      }
+      return map
+    },
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    refresh,
+    bind() {
+      const win = globalThis as unknown as {
+        addEventListener?: (type: string, fn: () => void) => void
+        document?: { visibilityState?: string; addEventListener?: (type: string, fn: () => void) => void }
+      }
+      if (bound || typeof win.addEventListener !== 'function' || !win.document?.addEventListener) return
+      bound = true
+      void refresh()
+      const onFront = () => {
+        if (win.document?.visibilityState !== 'visible' || Date.now() - lastRefreshAt < REFRESH_GAP_MS) return
+        void refresh({ fresh: true })
+      }
+      win.document.addEventListener('visibilitychange', onFront)
+      win.addEventListener('focus', onFront)
+    },
+    setOverrides: applyOverrides,
+    setCatalogue: applyCatalogue,
+  }
+}

package/dist/shortcuts/entangledWorlds.d.ts

@@ -1,21 +0,0 @@
-import type { ShortcutAction } from './match.js';
-export declare const EW_STUDIO_SECTION = "ew-studio";
-export declare const EW_PLAYER_SECTION = "ew-player";
-/** The studio's actions all act on what is open in it; the player has no other scope. */
-export type EntangledWorldsShortcut = ShortcutAction<'studio' | 'player'>;
-/** How the studio's command menu groups its actions, in its order. */
-export declare const EW_STUDIO_COMMAND_GROUPS: readonly [{
-    readonly id: "edit";
-    readonly label: "Edit";
-}, {
-    readonly id: "playback";
-    readonly label: "Playback";
-}, {
-    readonly id: "steps";
-    readonly label: "Steps";
-}, {
-    readonly id: "help";
-    readonly label: "Help";
-}];
-export declare const EW_STUDIO_SHORTCUTS: readonly EntangledWorldsShortcut[];
-export declare const EW_PLAYER_SHORTCUTS: readonly EntangledWorldsShortcut[];

package/dist/shortcuts/entangledWorlds.js

@@ -1,40 +0,0 @@
-// The Entangled Worlds catalogues: the studio (where a world's clip is made) and the full-window
-// player. Escape and Enter inside dialogs stay with the dialogs and are not listed here.
-export const EW_STUDIO_SECTION = 'ew-studio';
-export const EW_PLAYER_SECTION = 'ew-player';
-const studio = (id, label, defaultKeys, group, command) => Object.freeze({
-    id: `ew.studio.${id}`, section: EW_STUDIO_SECTION, label, defaultKeys: Object.freeze([...defaultKeys]), scope: 'studio',
-    group, ...(command === false ? { command } : {}),
-});
-/** How the studio's command menu groups its actions, in its order. */
-export const EW_STUDIO_COMMAND_GROUPS = Object.freeze([
-    { id: 'edit', label: 'Edit' },
-    { id: 'playback', label: 'Playback' },
-    { id: 'steps', label: 'Steps' },
-    { id: 'help', label: 'Help' },
-]);
-export const EW_STUDIO_SHORTCUTS = Object.freeze([
-    studio('undo', 'Undo', ['Mod+KeyZ'], 'edit'),
-    studio('redo', 'Redo', ['Mod+Shift+KeyZ'], 'edit'),
-    studio('duplicate', 'Duplicate the selection', ['Mod+KeyD'], 'edit'),
-    studio('copy', 'Copy the selection', ['Mod+KeyC'], 'edit'),
-    studio('paste', 'Paste', ['Mod+KeyV'], 'edit'),
-    studio('playPause', 'Play or pause', ['Shift?+Space'], 'playback'),
-    studio('remove', 'Remove the selection', ['Shift?+Delete', 'Shift?+Backspace'], 'edit'),
-    studio('step.audio', 'Audio step', ['Digit1', 'Numpad1'], 'steps'),
-    studio('step.animations', 'Animations step', ['Digit2', 'Numpad2'], 'steps'),
-    studio('step.third', 'Export step (Release where there is no export)', ['Digit3', 'Numpad3'], 'steps'),
-    studio('step.release', 'Release step', ['Digit4', 'Numpad4'], 'steps'),
-    studio('help', 'Keyboard shortcuts', ['Shift?+Slash'], 'help'),
-    // Opens the menu itself, so the menu does not list it.
-    studio('commands', 'Commands', ['Mod+KeyK'], 'help', false),
-]);
-export const EW_PLAYER_SHORTCUTS = Object.freeze([
-    Object.freeze({
-        id: 'ew.player.playPause',
-        section: EW_PLAYER_SECTION,
-        label: 'Play or pause',
-        defaultKeys: Object.freeze(['Shift?+Alt?+Ctrl?+Meta?+Space']),
-        scope: 'player',
-    }),
-]);

package/dist/shortcuts/labels.d.ts

@@ -1,10 +0,0 @@
-import type { ShortcutAction } from './match.js';
-/** An action's name in a language (`es`, `es-AR`), falling back to the catalogue's English. */
-export declare function shortcutLabel(action: Pick<ShortcutAction, 'id' | 'label'>, locale?: string): string;
-/** A section's name in a language, falling back to the English. */
-export declare function shortcutSectionLabel(section: {
-    id: string;
-    label: string;
-}, locale?: string): string;
-/** Any other named thing of the shortcuts (a command group `group:<id>`, a sheet row `row:<id>`). */
-export declare function shortcutName(key: string, english: string, locale?: string): string;