ir

type Binding ¶

type Binding struct {
	Name      string
	Clauses   []*BindingClause
	Otherwise *TextTemplate
	Span      diag.SourceSpan
}

Binding is a named, ordered, total decision from state to one text value. The first matching clause wins; Otherwise is always present.

type BindingClause ¶

type BindingClause struct {
	Polarity  GuardPolarity
	Predicate *Predicate
	Template  *TextTemplate
	Span      diag.SourceSpan
}

BindingClause is one guarded arm of a binding.

type Channel ¶

type Channel struct {
	Name        string
	Direction   Direction
	Token       Token
	LegendLabel *Label
	Span        diag.SourceSpan
}

Channel is a named kind of traffic an edge can carry.

type Comparison ¶

type Comparison string

Comparison is a numeric bound's operator.

const (
	ComparisonAtLeast Comparison = "atLeast"
	ComparisonAtMost  Comparison = "atMost"
)

type Control ¶

type Control struct {
	Name         string
	CaptionLabel *Label
	Trigger      Trigger
	Event        *EventDeclaration
	PressedWhen  *Predicate
	Span         diag.SourceSpan
}

Control turns one DOM interaction into one declared event.

type Direction ¶

type Direction string

Direction is a channel's travel direction. A channel is never bidirectional: two directions are two channels.

const (
	DirectionForward Direction = "forward"
	DirectionReverse Direction = "reverse"
)

type DirtyProjection ¶

type DirtyProjection struct {
	Fields []*StateField
}

DirtyProjection is the computed set of state fields the widget's rendered output depends on, in state declaration order: every field its bindings and predicates read, plus the tick its motion re-arms on, whose value the markup carries as a per-tick identity. Under-declaring it is a correctness bug, which is why an author is not asked to maintain it.

type Document ¶

type Document struct {
	Name            string
	DialectVersion  int
	Region          string
	Palette         string
	StateFields     []*StateField
	Predicates      []*Predicate
	Bindings        []*Binding
	Labels          []*Label
	Slots           []*Slot
	Roles           []*Role
	Channels        []*Channel
	Placements      []*Placement
	Scene           *Scene
	Motion          *Motion
	Indicators      []*Indicator
	Controls        []*Control
	Events          []*EventDeclaration
	Streams         []*Stream
	Legend          Legend
	DirtyProjection DirtyProjection
	Span            diag.SourceSpan
}

Document is one resolved widget.

func (document *Document) Slot(kind SlotKind) (*Slot, bool)

type Edge ¶

type Edge struct {
	Name     string
	From     *Node
	To       *Node
	Channels []*Channel
	Geometry EdgeGeometry
	Span     diag.SourceSpan
}

Edge is an ordered pair of distinct nodes carrying one or more channels.

type EdgeGeometry ¶

type EdgeGeometry struct {
	LengthPercent float64
	AngleDegrees  float64
}

EdgeGeometry is an edge's length and angle. Both are computed from the two endpoints' placements and are never authored: LengthPercent is the distance across the normalized scene box, AngleDegrees the clockwise angle from the positive left axis, in (-180, 180].

type Emphasis ¶

type Emphasis struct {
	Name                 string
	Node                 *Node
	DurationMilliseconds int
	DelayMilliseconds    int
	Span                 diag.SourceSpan
}

Emphasis is one finite animation on one node.

type EventDeclaration ¶

type EventDeclaration struct {
	Name    string
	Wire    string
	Toggles *StateField
	Fields  []*EventField
	Span    diag.SourceSpan
}

EventDeclaration is one inbound event the widget accepts, with the wire name the host registers. The declared set is exhaustive and default-deny.

type EventField ¶

type EventField struct {
	WireName string
	Writes   *StateField
	Type     FieldType
	Span     diag.SourceSpan
}

EventField binds one wire payload field to one state field.

type FieldType ¶

type FieldType string

FieldType is a state field's declared type.

const (
	FieldFlag    FieldType = "flag"
	FieldCounter FieldType = "counter"
	FieldCount   FieldType = "count"
	FieldText    FieldType = "text"
)

type GuardPolarity ¶

type GuardPolarity string

GuardPolarity is a binding clause's polarity. The two polarities are two constructs, not two spellings of one.

const (
	GuardWhen    GuardPolarity = "when"
	GuardWhenNot GuardPolarity = "whenNot"
)

type Indicator ¶

type Indicator struct {
	Name      string
	Label     *Label
	Predicate *Predicate
	Span      diag.SourceSpan
}

Indicator is a named status mark whose tone one predicate selects.

type Label ¶

type Label struct {
	Name       string
	SourceKind LabelSourceKind
	Literal    *TextTemplate
	Binding    *Binding
	Span       diag.SourceSpan
}

Label is a named text slot holding exactly one source.

type LabelSourceKind ¶

type LabelSourceKind string

LabelSourceKind is which of a label's two sources it carries.

const (
	LabelLiteral LabelSourceKind = "literal"
	LabelBound   LabelSourceKind = "binding"
)

type Legend ¶

type Legend struct {
	Entries []LegendEntry
}

Legend is the computed projection of the declared channels, in declaration order. It is never authored, so it cannot disagree with the picture.

type LegendEntry ¶

type LegendEntry struct {
	Channel *Channel
	Label   *Label
}

LegendEntry is one row of the computed footer legend.

type Marker ¶

type Marker string

Marker is a role's marker size.

const (
	MarkerLarge Marker = "large"
	MarkerSmall Marker = "small"
)

type Motion ¶

type Motion struct {
	Requires       []*Predicate
	Forbids        []*Predicate
	RestartOn      *StateField
	Pulses         []*Pulse
	Emphases       []*Emphasis
	HostStatusGate bool
	Span           diag.SourceSpan
}

Motion gates and schedules every animation a widget has.

HostStatusGate is always true: the host's own connection status is part of the compiled gate whether or not the author mentioned it, because an animation running against a dead connection is a lie about liveness. It is carried explicitly so a generator reads the obligation rather than remembering it.

type Node ¶

type Node struct {
	Name         string
	Role         *Role
	Placement    *Placement
	TitleLabel   *Label
	CaptionLabel *Label
	Span         diag.SourceSpan
}

Node is a named participant drawn in the scene.

type NumericBound ¶

type NumericBound struct {
	Field      *StateField
	Comparison Comparison
	Value      int
	Span       diag.SourceSpan
}

NumericBound is a comparison of a numeric state field against an integer literal. It never compares two fields, so no evaluation order exists.

type Orbit ¶

type Orbit struct {
	Name  string
	Token Token
	Span  diag.SourceSpan
}

Orbit is a decorative ambient ellipse belonging to the scene.

type Placement ¶

type Placement struct {
	Name string
	Left int
	Top  int
	Span diag.SourceSpan
}

Placement is a named point in the scene's normalized box, in percent.

type Predicate ¶

type Predicate struct {
	Name     string
	Kind     PredicateKind
	Field    *StateField
	Requires []*Predicate
	Forbids  []*Predicate
	Bounds   []NumericBound
	Span     diag.SourceSpan
}

Predicate is a named boolean over state, from either of two declaration forms: a flag field under its own name, or a composition.

type PredicateKind ¶

type PredicateKind string

PredicateKind distinguishes a flag field used as a predicate from a composition declared in the predicates block.

const (
	PredicateAtomic   PredicateKind = "atomic"
	PredicateComposed PredicateKind = "composed"
)

type Pulse ¶

type Pulse struct {
	Name                 string
	Edge                 *Edge
	Channel              *Channel
	DurationMilliseconds int
	DelayMilliseconds    int
	Span                 diag.SourceSpan
}

Pulse is one finite animation of one channel on one edge.

type Role ¶

type Role struct {
	Name            string
	Token           Token
	Marker          Marker
	EmphasisAllowed bool
	Span            diag.SourceSpan
}

Role is a named node kind fixing appearance and animation eligibility.

type Scene ¶

type Scene struct {
	Name            string
	DescriptionSlot *Slot
	Orbits          []*Orbit
	Nodes           []*Node
	Edges           []*Edge
	Span            diag.SourceSpan
}

Scene is the widget's single drawing area and single accessibility boundary.

type Slot ¶

type Slot struct {
	Kind    SlotKind
	Label   *Label
	Ordinal int
	Span    diag.SourceSpan
}

Slot is a filled position in the widget's chrome.

type SlotKind ¶

type SlotKind string

SlotKind is one of the four closed chrome positions.

const (
	SlotTitle       SlotKind = "title"
	SlotSource      SlotKind = "source"
	SlotDescription SlotKind = "description"
	SlotStat        SlotKind = "stat"
)

type StateField ¶

type StateField struct {
	Name    string
	Type    FieldType
	Signal  string
	Writers []Writer
	Span    diag.SourceSpan
}

StateField is one named, typed field of the widget's state.

func (field *StateField) Interpolable() bool

func (field *StateField) Numeric() bool

type Stream ¶

type Stream struct {
	Name     string
	Source   string
	Delivers *EventDeclaration
	Ordering *StateField
	Span     diag.SourceSpan
}

Stream is a named long-running subscription delivering one event. It is a declaration, never a connection: it carries a source name and nothing else.

type TemplateSegment ¶

type TemplateSegment struct {
	Literal string
	Field   *StateField
}

TemplateSegment is one run of a text template: literal text, or one interpolated state field.

type TextTemplate ¶

type TextTemplate struct {
	Segments []TemplateSegment
	Span     diag.SourceSpan
}

TextTemplate is a sequence of literal runs and interpolations.

func (template *TextTemplate) Empty() bool

type Token ¶

type Token string

Token is one of the seven semantic token names. The namespace is closed: a widget writes a name only, and there is no inline colour and no `var(--…)` escape hatch.

const (
	TokenSurface  Token = "surface"
	TokenInk      Token = "ink"
	TokenMuted    Token = "muted"
	TokenRule     Token = "rule"
	TokenAccent   Token = "accent"
	TokenPositive Token = "positive"
	TokenWarning  Token = "warning"
)

type Trigger ¶

type Trigger string

Trigger is a control's DOM interaction.

const (
	TriggerClick  Trigger = "click"
	TriggerChange Trigger = "change"
	TriggerInput  Trigger = "input"
	TriggerSubmit Trigger = "submit"
)

type Writer ¶

type Writer struct {
	Kind   WriterKind
	Event  *EventDeclaration
	Field  *EventField
	Signal string
	Span   diag.SourceSpan
}

Writer is one resolved writer of a state field.

type WriterKind ¶

type WriterKind string

WriterKind is how a state field is written. There are exactly three writers, and a field written by none of them is an error.

const (
	WriterEventField  WriterKind = "eventField"
	WriterEventToggle WriterKind = "eventToggle"
	WriterSignal      WriterKind = "signal"
)