Struct FeedbackDraft 

pub struct FeedbackDraft {
    pub issue: String,
    pub include_context: bool,
    pub include_screenshot: bool,
}

Ephemeral CRDT state, admitted only into a private component host. Its fields are edited at their paths; the effects review and send it.

Fields

issue: String

The issue, in the person’s words.

include_context: bool

Whether contextual information is included.

include_screenshot: bool

Whether a single masked app screenshot is included.

Implementations

impl FeedbackDraft

pub fn paths() -> FeedbackDraftPaths<Self>

The typed paths into a FeedbackDraft, rooted at it.

Trait Implementations

impl Clone for FeedbackDraft

fn clone(&self) -> FeedbackDraft

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FeedbackDraft

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FeedbackDraft

fn default() -> FeedbackDraft

Returns the “default value” for a type.

impl Fields for FeedbackDraft

const ITEM_FIELDS: &'static [&'static str] = Self::__COLLECTIONS

The collection fields whose items are published as item resources (Collection, Keyed, Ordered); #[derive(Model)] lists them.

fn read_fields(doc: &Doc, obj: &ObjId) -> Result<Self, ModelError>

Errors

fn write_fields(&self, doc: &mut Doc, obj: &ObjId) -> Result<(), ModelError>

Errors

fn write_changed_fields( &self, before: &Self, doc: &mut Doc, obj: &ObjId, dirty: &Delta, ) -> Result<(), ModelError>

Write the fields to the map obj, which holds before: the operations write_fields would write, with each field compared to its value in before rather than read back (see Model::store_changed). #[derive(Model)] writes only the fields that changed; the default writes every field.

fn edit_fields( doc: &mut Doc, obj: &ObjId, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path below the map obj; see Model::edit. #[derive(Model)] routes each field segment to its field; the default edits nothing.

fn refresh_fields( &mut self, doc: &Doc, obj: &ObjId, delta: &Delta, ) -> Result<(), ModelError>

Bring fields read earlier from the map obj up to date after the changes in delta, re-reading only the fields they touched.

fn item_collections(&self) -> Vec<ItemCollection>

The items of each Collection field, so actions on an item can be offered on the item (see [crate::items]), at most ITEM_PAGE of each. #[derive(Model)] lists them; the default has none.

fn item_label(&self, field: &str, id: &Id) -> Option<String>

The label the item id of the collection field field is offered under, or None when there is no such item.

fn item_search(&self) -> Vec<ItemText>

Every item of the collection fields whose type has a #[model(label)], with its text: what search indexes by default.

fn item_collection_sizes(&self) -> Vec<(&'static str, usize)>

How many items each Collection field holds, by field, in the order of item_collections, without listing them. #[derive(Model)] counts them; the default lists them.

impl Model for FeedbackDraft

const SHAPE: Shape

How the value is laid out in the document; see Shape. Types written whole keep the default.

const CHECKS: bool

Whether this type or any value inside it has a #[model(check)] invariant; Self::check has nothing to do otherwise.

const OPS: bool

Whether this type or a value inside it has a vocabulary of its own (Operations, rich text’s): a record routes those edits’ gestures, landing places and schemas only into such fields, and never instantiates the routing for the others.

const TABLE: &'static ModelTable

The type’s functions as data, which a record holding it reaches it through ([crate::table]): by default its own functions, erased.

type Paths<__R> = FeedbackDraftPaths<__R>

The typed paths into a value of this type, rooted in the record R: a struct of field paths for a record, the Path itself for a value edited whole or through its own operations.

fn paths_at<__R>(path: Path<__R, Self>) -> Self::Paths<__R>

The paths of the value at path.

fn to_json(&self) -> Value

The value as JSON: what [EditOp::Set] carries and history shows.

fn from_json(value: &Value) -> Result<Self, ModelError>

A value from its Self::to_json form.

fn edit( doc: &mut Doc, slot: Slot<'_>, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path, below the value in slot, touching only what it changes, then run the invariants of the values it touched. The default edits a value only as a whole.

fn check(&self) -> Result<(), Refusal>

Run every #[model(check)] invariant of this value and the values inside it.

fn op_coalesces( path: &[Segment], previous: &Value, next: &Value, ) -> Option<bool>

Whether two edits in the own vocabulary of the value at path below this type are one gesture (Operations); None when nothing there has one.

fn op_continuable(path: &[Segment], op: &Value) -> Option<bool>

Whether a gesture may go on after the edit op at path.

fn diff<__E>(&self, after: &Self, path: &[Segment], out: &mut Vec<Edit<__E>>)

The field edits that turn self into after, at path below the record: what a surface that edited a local copy submits. The default sets the value whole when it changed; containers and records edit only what differs, item by item and field by field.

fn op_describe(path: &[Segment], op: &Value) -> Option<OpDescription>

What the edit op at path below this type did, in the history entry’s terms (Operations::describe).

fn op_lands(&self, path: &[Segment], op: &Value) -> Option<Place>

Where the actor of the edit op at path below this value is after it applied.

fn op_schemas(prefix: &str, out: &mut Vec<(String, Value)>)

The schemas of the own vocabularies of the values below this type, by path pattern from prefix (* for every item).

fn get_at(&self, path: &[Segment]) -> Option<&dyn Any>

The value at path below this one, if it is there. A value with nothing inside it is found only at the empty path.

fn load(doc: &Doc, value: &Value<'_>, id: &ObjId) -> Result<Self, ModelError>

Read from the value a parent found in its slot.

fn value_schema() -> Value

The JSON Schema of this value’s JSON form (Self::to_json), as the published field edit describes what a path takes; the default accepts any value.

fn missing() -> Result<Self, ModelError>

The value of an absent slot. Types with a natural empty value return it, so a field added to a schema reads older documents without migration.

fn store(&self, doc: &mut Doc, slot: Slot<'_>) -> Result<(), ModelError>

Write self into slot, changing only what differs from what the slot already holds.

fn stores_as(&self, before: &Self) -> bool

Whether writing self over a slot that holds before, as a store left it, would change nothing: an in-memory comparison, so an action that changed one item of a long collection does not visit the others. Must only answer true when store would write no operation; the default answers false (unknown).

fn store_changed( &self, before: &Self, doc: &mut Doc, slot: Slot<'_>, dirty: &Delta, ) -> Result<(), ModelError>

Write self into slot, which holds before: exactly the operations store would write, found by comparing with before where store would read the document.

fn refresh( &mut self, doc: &Doc, value: &Value<'_>, id: &ObjId, delta: &Delta, ) -> Result<(), ModelError>

Bring a value read earlier up to date after the changes in delta, re-reading only what they touched. value and id are what the parent’s slot holds now — the same object as when self was read, or the parent would have read it anew. The default reads the value again, which is right for scalars and short values.

fn collect_text(&self, out: &mut Vec<String>)

Append the human-readable text this value carries, for search indexing.

const NULLABLE: bool = false

Whether null is a value of the type: an absent Option. A field edit setting any other type to null is refused.

const SCALAR: bool = false

Whether store writes one scalar, with nothing inside it that a concurrent writer could add to. A record made just now leaves out such a field holding its missing value: an absent key reads as it. An object (text, a map, a list) is always made with its record, so two writers fill the same one.

fn nested_collections(&self) -> Vec<ItemCollection>

The item collections inside this value, when it is an item of a collection itself (a slide’s elements); #[derive(Model)] lists a record’s, the default has none.

fn read_whole(&mut self, doc: &AutoCommit) -> Result<(), ModelError>

Read everything this value holds, for a field marked #[model(whole)]: a value read lazily (rich text reads its paragraphs as views ask for them) reads all of it, so every reader of the record — a verb, search, read_content — sees all of it. The default has nothing more to read.

fn label(&self) -> Option<String>

What names this value for people (#[model(label)]): history, search, agents and item resources use it.

impl PartialEq for FeedbackDraft

fn eq(&self, other: &FeedbackDraft) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Resource for FeedbackDraft

fn register(registry: &mut ActionRegistry)

Its actions, and the undo of a change too large to record its restoring edits.

fn publication_cache_epoch(_state: &Self) -> Option<String>

A record’s publication is a function of its state.

const KIND: &'static str = "tilo.feedback-draft"

Stable kind of record this resource lives in, e.g. "notes.notebook".

const LABEL: &'static str = "Feedback"

Human name of one resource of this kind, e.g. "Notebook".

const EDITS: bool = true

Whether the resource’s actions include field edits (Edit), published as FIELD_EDIT. #[resource] records have them.

type State = FeedbackDraft

What views render. For a record resource this is the record itself.

type Action = Stamped<FeedbackDraftAction>

The replayable mutation. Must be deterministic: no clock, no RNG, no local state — use ActionCx for ids and time.

fn read(doc: &Doc) -> Result<Self, ModelError>

Read the state from a document.

fn copy_state(state: &Self) -> Option<Self>

A copy of state for refresh to bring up to date while the state the reader holds is shared (a view still holds the last one): refreshing a copy reads only what a change touched, where without one the state is read whole. #[resource] copies a Clone record; the default has none.

fn refresh(state: &mut Self, doc: &Doc, delta: &Delta) -> Result<(), ModelError>

Bring state, read earlier from this document, up to date after the changes in delta. Re-read only what they touched: this runs on every keystroke, local or a collaborator’s. The default reads everything again, which is right for small resources.

fn initialize(doc: &mut Doc) -> Result<(), ModelError>

Write the initial content of a brand-new record: its genesis.

fn declarations() -> Vec<ActionDecl<Self>>

Mutations offered by name. The generic APPLY action is always offered in addition, so any typed value can reach the host.

fn edit_action(edit: Edit<Self>) -> Option<Self::Action>

The action a field edit of this resource is, when it has field edits (Self::EDITS).

fn stamp(action: &mut Self::Action, now_ms: i64)

Stamp the origin’s clock on an action as the door admits it. A caller never supplies the time an action carries.

fn kind_of(action: &Self::Action) -> ActionKind

What kind of action action is: whether it only reads, changes only the document, or reaches outside it. Derived by #[resource] from what each verb is able to do, never declared.

fn coalesces(previous: &Self::Action, next: &Self::Action) -> bool

Whether next, applied right after previous by the same person, continues it as one undo step — the characters of a word typed one keystroke at a time, the values a slider passes through in one drag. The default keeps every action its own step.

fn continuable(action: &Self::Action) -> bool

Whether a later action may continue action (coalesces), so its undo step stays open for it. One that never continues — a paragraph split after a typed word, a block moved — is a step of its own, recorded at once. The default keeps every step open for what may follow.

fn lands(state: &Self, action: &Self::Action) -> Option<Place>

Where action, just applied, leaves the participant who took it, read off the state after it: the paragraph an append wrote and the caret at its end. Every collaborator’s view draws that participant there, so one with no pointer or caret of its own (an agent) shows where it works. The default places it nowhere in particular.

fn op_schemas() -> Vec<(String, Value)>

The schemas of the own vocabularies of the record’s fields (Operations), by field path pattern (* for every item): what a field edit in that vocabulary carries.

fn children(state: &Self) -> Vec<Resource>

Resources nested inside this one (a track’s clips, a list’s items, a page’s rich-text body), each exporting actions with their arguments already bound. Published beneath the root resource for the palette, agents and scripts — the same door as the root, not a second tree.

fn children_parts(state: &Self) -> ChildrenParts

children split into the children that are not items and the items of the record’s collections, so a publisher can keep the item children it built for an earlier version and build only those whose label changed. others followed by item_children of the rest must be exactly children. The default puts every child in others; #[resource] splits off its item collections.

fn child(state: &Self, id: &str) -> Option<Resource>

The nested resource id, when children leaves it out. A resource with more children than a published tree should carry (a book of contacts, a long history) publishes a bounded page from children and resolves the rest here, so an action addressed to any of them still reaches it through the same door. The default resolves nothing beyond children.

fn search(state: &Self) -> Vec<SearchEntry>

fn search_scopes(state: &Self) -> Vec<ScopeDecl>

Entries for the system search index.

fn shape() -> Option<Shape>

The stored layout of this resource’s content, for services that act on it generically: History restores a past version through it, field by field and item by item. #[resource] returns the record’s Model::SHAPE; the default opts out.

fn action_schema() -> Option<Value>

The JSON Schema of Action’s serde form, published as the schema of the generic APPLY operation’s argument, so agents and scripts can read the edit vocabulary from the descriptor and binding refuses a malformed edit by name. A variant that only restates a declaration is published as a reference to it. Return Some(<Self::Action as JsonSchema>::json_schema()) for an action type deriving JsonSchema; #[resource] describes its operations from their declarations. The default publishes no schema.

const ACTION_TYPE: &'static str = Self::KIND

The registry type id every action of this resource is replayed under.

fn locate(state: &Self::State, obj: &ExId) -> Option<Vec<(ExId, Prop)>>

Where obj sits in the document, when the state already knows: the path from the root to it. A change to an object the state has read (the paragraph being typed in) is then placed without asking the document, which for a large document is the costly part of reading a change. The default knows nothing, and the document is asked.

fn load( state: &mut Self::State, doc: &AutoCommit, demand: &Demand, ) -> Result<(), ModelError>

Make sure the parts of the state views asked for are read, and drop parts nobody asks for any more. For a resource too large to read whole, read reads a spine (the order of a document’s paragraphs, the rows of a sheet) and this reads the parts on screen. Called after every read and refresh and whenever the demand changes, so it must be cheap when everything demanded is already there. The default reads nothing: the state is read whole.

fn field_of(action: &Self::Action) -> Option<&'static str>

The one field of the record action writes, when it writes only one: a reply or a note writes the comments, so a grant on that field (what someone who may only comment holds) reaches it. None by default. A declared action that builds it names the same field with ActionDecl::below_field.

fn least_need() -> ActionNeed

The least any of the resource’s actions is (kind_of, field_of): what the generic APPLY and group actions are offered under, each invocation then decided by what its value is. An undoable change of the record by default; an undoable change of its comments for a resource someone who may only comment can still reply in.

fn item_effects(_field: &str, _item: &Id) -> Vec<ActionSpec>

The effects offered on the item item of the collection field, bound to it (#[resource(effects = E)] with #[effect(item = field)] variants): published on the item resource beside its item verbs.

fn item_views(_field: &str, _item: &Id) -> Vec<ResourceViewSpec>

The views the item item of the collection field offers (#[resource(item_views = path)]): published on the item resource, so a link to the item opens it in one, each opened by one of the item’s own actions (item_effects).

fn children_offer_bound(state: &Self::State) -> Vec<&'static str>

The ids of the declarations that children offer on some child with arguments already bound (an item action on each item of a list), which the resource then publishes for scripts rather than the palette.

fn local_operations() -> Vec<ActionSpec>

View and effect operations on this resource: local presentation and jobs that have no document delta (show a week, start a sync drain, open a system file picker). They are published on the same tree as declarations. A document mutation does not belong here — it is a declarations entry or APPLY. publish drops a Document spec so it cannot become a second write path.

fn views(_state: &Self::State) -> Vec<ResourceViewSpec>

Named presentations of this resource (editor, reader) with stable ids. Not an action called open: ordinary presentation toggles never become composable views by accident. Defaults to none.

const READABLE: bool = false

Whether read_content answers. A resource that does is published with the framework’s read operation, so a script, an agent or an assistive tool reads what it holds as typed data through the same door, permissions and audit as every other action — never from a screenshot.

fn read_content( state: &Self::State, doc: &AutoCommit, item: Option<&str>, ) -> Result<Value, String>

What the resource holds, as JSON a caller can act on: with no item, the resource itself (a notebook’s pages); with item, the nested resource of that id from children (one page’s title and blocks). Read from doc, the committed document, so the answer is never older than the action that preceded it. Called only when READABLE is set.

fn answer(_doc: &AutoCommit, _action: &str, _changes: &[Patch]) -> Option<Value>

What declared action action (one ActionDecl::answering) made, answered to its caller once it applied to doc as changes: the ids it minted, the area it selected, a warning that what it drew is hidden. A compact summary, so the caller needs no second read to see what happened. The default answers nothing.

const VERSION: u32 = 1

The storage version documents of this resource are written at; #[resource(version = N)] raises it with each incompatible change and Self::migrate brings older documents up to it.

fn migrate(doc: &mut AutoCommit, from: u32) -> Result<(), ModelError>

Bring a document stored at version from up to Self::VERSION, reading its old shape with the model helpers. Called once per document by [crate::evolution::migrate].

fn surface() -> Surface

The public surface: verbs, their parameters and kinds, and the stored fields ([crate::surface]).

fn availability(state: &Self::State, action: &str) -> Availability

Whether the declared action action can be taken in state, and why not when it cannot. #[resource(available = path)] answers it.

fn seed() -> Option<Self::Action>

The first content of a new record, written by its creator once it is created: nobody’s undo step. #[resource(seed = path)] provides it.

impl Settable for FeedbackDraft

impl StructuralPartialEq for FeedbackDraft