Skip to content

zidane-ui/extensions/testing

import { … } from 'zidane-ui/extensions/testing'ui/src/extensions/testing/index.ts

Functions#

createFixtureExtensionsHostFunction#

Creates an ExtensionsHost held in memory.

TypeScript
function createFixtureExtensionsHost(
  options?: FixtureExtensionsOptions,
): FixtureExtensionsHost
Parameters
NameTypeDefaultDescription
options?FixtureExtensionsOptions{}

What it holds and which members it offers.

ui/src/extensions/headless/fixture-host.ts:138

fixtureItemFunction#

Builds an item for a fixture: key defaults to <token>:<extension>:<n>.

TypeScript
function fixtureItem<N extends keyof ExtensionWireMap>(
  token: N,
  extension: string,
  item: ExtensionWireMap[N],
  key?: string,
): ExtensionItem<N>
Type parameters
NameTypeDescription
Nextends keyof ExtensionWireMap
Parameters
NameTypeDescription
tokenN

The token.

extensionstring

The contributing extension.

itemExtensionWireMap[N]

The wire form.

key?string

The item's key.

ui/src/extensions/headless/fixture-host.ts:374

storeKeyFunction#

The key of a store in FixtureExtensionsOptions.stores.

TypeScript
function storeKey(ref: ExtensionStoreRef): string
Parameters
NameTypeDescription
refExtensionStoreRef

The store.

string

ui/src/extensions/headless/fixture-host.ts:120

Interfaces#

FixtureExtensionsControlInterface#

Drives a fixture host from outside, as the extensions behind it would.

TypeScript
interface FixtureExtensionsControl
FixtureExtensionsControl properties
NameTypeDescription
dialog(request: DialogRequest, ctx: DialogQueueShowContext) => Promise<unknown>

Asks this client for a dialog; resolves with the answer.

effect(effect: ExtensionUiEffect) => Promise<ExtensionUiEffectResult>

Routes a ctx.ui / ctx.composer call to this client; resolves with what the app settled.

invoked() => readonly { args: unknown; id: keyof ExtensionCallbacks }[]

The callbacks invoked so far.

links() => readonly ExtensionLinkRequest[]

The links offered to the link handlers so far.

panelChanged(change: ExtensionPanelChange) => void

A live panel would load something new (its subscribe emitted): panelChanged listeners hear it.

ran() => readonly { args?: string; id: string; sessionId?: string }[]

The commands run so far.

readStore(ref: ExtensionStoreRef) => unknown

A store's value now.

remove(key: string) => void

Withdraws an item.

setScope(next: ExtensionAccessScope | null) => void

Changes the token's scope (with scope given).

setSettings(next: ExtensionSettingsWire) => void

Replaces the settings.

upsert(entry: ExtensionItem) => void

Adds or replaces an item (by key).

writeStore(ref: ExtensionStoreRef, value: unknown) => void

Another client wrote a store.

ui/src/extensions/headless/fixture-host.ts:85

FixtureExtensionsOptionsInterface#

Options of createFixtureExtensionsHost.

TypeScript
interface FixtureExtensionsOptions
FixtureExtensionsOptions properties
NameTypeDescription
callbacks?{ 'badge.menu'?: FixtureCallback<'badge.menu'>; 'badge.run'?: FixtureCallback<'badge.run'>; 'panel.action'?: FixtureCallback<'panel.action'>; 'panel.load'?: FixtureCallback<'panel.load'>; 'reference.resolve'?: FixtureCallback<'reference.resolve'>; 'setting.action'?: FixtureCallback<'setting.action'>; 'setting.status'?: FixtureCallback<'setting.status'> }

Scripted callbacks. One left out answers unavailable.

capabilities?readonly FixtureExtensionsCapability[]

Offer only these optional members. Default: all of them.

commands?readonly ExtensionCommandWire[]

The commands. Default: none.

goodKey?string

The API key connect accepts; any other is refused. Default 'good-key'.

integrations?readonly ExtensionIntegrationWire[]

The integrations. Default: none.

items?readonly ExtensionItem<keyof ExtensionWireMap>[]

The items there at the start.

openLink?(request: ExtensionLinkRequest) => boolean | Promise<boolean>

The link handlers: whether one opens a link. Absent: no openLink (links open the app's way).

rpc?Readonly<Record<string, Readonly<Record<string, FixtureRpcMethod>>>>

Scripted RPC methods, by contract then method.

scope?ExtensionAccessScope | null

The scope the client's token grants. Absent: no scope (never limited).

settings?ExtensionSettingsWire

The settings. Default: none.

settingsReadOnly?boolean

Make settings read-only (no settings.set).

stores?Readonly<Record<string, unknown>>

Stored values, by storeKey.

ui/src/extensions/headless/fixture-host.ts:57

FixtureRpcErrorInterface#

An RPC error a scripted method throws: answered as { code: 'rpc', … }.

TypeScript
interface FixtureRpcError
FixtureRpcError properties
NameTypeDescription
data?unknown

Extra detail for the caller.

messagestring

What went wrong, for a person.

typestring

The error's type, as the caller reads it.

ui/src/extensions/headless/fixture-host.ts:40

Types#

FixtureCallbackType#

A scripted callback: answers like the extension would, or throws.

TypeScript
type FixtureCallback<K extends ExtensionCallbackId> = (args: ExtensionCallbacks[K]['args']) => ExtensionCallbacks[K]['result'] | Promise<ExtensionCallbacks[K]['result']>
FixtureCallback type parameters
NameTypeDescription
Kextends ExtensionCallbackId

ui/src/extensions/headless/fixture-host.ts:35

FixtureExtensionsCapabilityType#

The optional members a fixture host can leave out.

TypeScript
type FixtureExtensionsCapability =
  | 'invoke'
  | 'dialogs'
  | 'effects'
  | 'rpc'
  | 'storage'
  | 'settings'
  | 'integrations'
  | 'commands'
  | 'panelChanged'

ui/src/extensions/headless/fixture-host.ts:53

FixtureExtensionsHostType#

An in-memory ExtensionsHost and its control.

TypeScript
type FixtureExtensionsHost = ExtensionsHost & { control: FixtureExtensionsControl }

ui/src/extensions/headless/fixture-host.ts:113

FixtureRpcMethodType#

A scripted RPC method. Throw a FixtureRpcError to answer an error.

TypeScript
type FixtureRpcMethod = (input: unknown, ctx: { extensionId?: string }) => unknown

ui/src/extensions/headless/fixture-host.ts:50