jazz-tools

CoValues

type ID

type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>

IDs are unique identifiers for CoValues.
Can be used with a type argument to refer to a specific
CoValue type.
FileStreams are CoFeeds that contain binary data, collaborative versions of Blobs.
Content
BinaryCoStream.loadAsBlob(id, options): Promise<Blob | undefined>
id: ID<FileStream>,
options: { allowUnfinished: boolean }
Load a FileStream as a Blob
BinaryCoStream.loadAsBlob(id, as, options): Promise<Blob | undefined>
id: ID<FileStream>,
as: Account,
options: { allowUnfinished: boolean }
⚠️ undocumented
BinaryCoStream.createFromBlob(blob, options): Promise<FileStream>
blob: File | Blob,
options: { owner: Group | Account, onProgress: (progress: number) => void } | Group | Account
Create a FileStream from a Blob or File
Example
import { co, FileStream } from "jazz-tools";

const fileStream = await FileStream.createFromBlob(file, {owner: group})
.id: ID<FileStream>
The ID of this FileStream
.toJSON(): { id: string, _type: "BinaryCoStream", mimeType: string, totalSizeBytes: number, fileName: string, chunks: Uint8Array[], finished: boolean }
Get a JSON representation of the FileStream
Subscription & Loading
BinaryCoStream.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends FileStream
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a FileStream
BinaryCoStream.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends FileStream
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
BinaryCoStream.subscribe<C, Depth>(id, depth, listener): () => void
C extends FileStream
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Subscribe to a FileStream, when you have an ID but don't have a FileStream instance yet
BinaryCoStream.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends FileStream
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.subscribe<B, Depth>(depth, listener): () => void
B extends FileStream
this: B,
depth: Depth & DepthsIn<B>,
listener: (value: DeeplyLoaded<B, Depth>) => void
An instance method to subscribe to an existing FileStream
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the FileStream to be uploaded to the other peers.
Collaboration
._owner: Group | Account
⚠️ undocumented
Internals
BinaryCoStream.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "BinaryCoStream"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
BinaryCoStream.create<S>(options): S
S extends FileStream
this: CoValueClass<S>,
options: { owner: Group | Account } | Group | Account
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
.getChunks(options): BinaryStreamInfo & { chunks: Uint8Array[], finished: boolean } | undefined
options: { allowUnfinished: boolean }
⚠️ undocumented
.isBinaryStreamEnded(): boolean
⚠️ undocumented
.start(options): void
options: BinaryStreamInfo
⚠️ undocumented
.push(data): void
data: Uint8Array
⚠️ undocumented
.end(): void
⚠️ undocumented
.toBlob(options): Blob | undefined
options: { allowUnfinished: boolean }
⚠️ undocumented
.ensureLoaded<B, Depth>(depth): Promise<DeeplyLoaded<B, Depth> | undefined>
B extends FileStream
this: B,
depth: Depth & DepthsIn<B>
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
CoFeeds are collaborative logs of data.
Declaration
CoFeed.Of<Item>(item): CoFeed
item: IfCo<Item, Item>
Declare a CoFeed by subclassing CoFeed.Of(...) and passing the item schema using a co primitive or a co.ref.
Example
class ColorFeed extends CoFeed.Of(co.string) {}
class AnimalFeed extends CoFeed.Of(co.ref(Animal)) {}
Content
They are similar to CoLists, but with a few key differences:
- They are append-only
- They consist of several internal append-only logs, one per account session (tab, device, app instance, etc.)
- They expose those as a per-account aggregated view (default) or a precise per-session view

Example
favDog.push("Poodle");
favDog.push("Schnowzer");
.id: ID<CoFeed<Item>>
The ID of this CoFeed
.byMe: CoFeedEntry<Item> | undefined
The current account's view of this CoFeed
.perSession: { undefined }
The per-session view of this CoFeed
.inCurrentSession: CoFeedEntry<Item> | undefined
The current session's view of this CoFeed

This is a shortcut for
this.perSession where the session ID is the current session ID.
.push(items): void
items: Item[]
Push items to this CoFeed

Items are appended to the current session's log. Each session (tab, device, app instance)
maintains its own append-only log, which is then aggregated into the per-account view.
Example
// Adds items to current session's log
feed.push("item1", "item2");

// View items from current session
console.log(feed.inCurrentSession);

// View aggregated items from all sessions for current account
console.log(feed.byMe);
Creation
CoFeed.create<S>(init, options): S
S extends CoFeed<any>
this: CoValueClass<S>,
init: TODO type conditional,
options: { owner: Group | Account } | Group | Account
Create a new CoFeed
Subscription & Loading
CoFeed.load<S, Depth>(id, depth): Promise<DeeplyLoaded<S, Depth> | undefined>
S extends CoFeed<any>
this: CoValueClass<S>,
id: ID<S>,
depth: Depth & DepthsIn<S>
Load a CoFeed
CoFeed.load<S, Depth>(id, as, depth): Promise<DeeplyLoaded<S, Depth> | undefined>
S extends CoFeed<any>
this: CoValueClass<S>,
id: ID<S>,
as: Account,
depth: Depth & DepthsIn<S>
⚠️ undocumented
CoFeed.subscribe<S, Depth>(id, depth, listener): () => void
S extends CoFeed<any>
this: CoValueClass<S>,
id: ID<S>,
depth: Depth & DepthsIn<S>,
listener: (value: DeeplyLoaded<S, Depth>) => void
Subscribe to a CoFeed, when you have an ID but don't have a CoFeed instance yet
CoFeed.subscribe<S, Depth>(id, as, depth, listener): () => void
S extends CoFeed<any>
this: CoValueClass<S>,
id: ID<S>,
as: Account,
depth: Depth & DepthsIn<S>,
listener: (value: DeeplyLoaded<S, Depth>) => void
⚠️ undocumented
.ensureLoaded<S, Depth>(depth): Promise<DeeplyLoaded<S, Depth> | undefined>
S extends CoFeed<any>
this: S,
depth: Depth & DepthsIn<S>
Ensure a CoFeed is loaded to the specified depth
.subscribe<S, Depth>(depth, listener): () => void
S extends CoFeed<any>
this: S,
depth: Depth & DepthsIn<S>,
listener: (value: DeeplyLoaded<S, Depth>) => void
An instance method to subscribe to an existing CoFeed

No need to provide an ID or Account since they're already part of the instance.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoFeed to be uploaded to the other peers.
Collaboration
._owner: Group | Account
⚠️ undocumented
Internals
CoFeed.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoStream<JsonValue, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoStream"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
.constructor: NO TYPE
⚠️ undocumented
.pushItem(item): void
item: Item
⚠️ undocumented
.toJSON(): { id: string, _type: "CoStream", in: { undefined } }
Get a JSON representation of the CoFeed
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
CoLists are collaborative versions of plain arrays.
Declaration
CoList.Of<Item>(item): CoList
item: Item
Declare a CoList by subclassing CoList.Of(...) and passing the item schema using co.
Example
class ColorList extends CoList.Of(
co.string
) {}
class AnimalList extends CoList.Of(
co.ref(Animal)
) {}
Content
You can access items on a CoList as if they were normal items on a plain array, using [] notation, etc.

Since
CoList is a subclass of Array, you can use all the normal array methods like push, pop, splice, etc.

Example
colorList[0];
colorList[3] = "yellow";
colorList.push("Kawazaki Green");
colorList.splice(1, 1);
.id: ID<CoList<Item>>
The ID of this CoList
._refs: { undefined } & { length: number, [iterator]: NO TYPE }
If a CoList's items are a co.ref(...), you can use coList._refs[i] to access
the
Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example
animals._refs[0].id; // => ID<Animal>
animals._refs[0].value;
// => Animal | null
const animal = await animals._refs[0].load();
Creation
CoList.create<L>(items, options): L
L extends CoList<any>
this: CoValueClass<L>,
items: UnCo<L[number]>[],
options: { owner: Group | Account } | Group | Account
Create a new CoList with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoList will immediately be persisted and synced to connected peers.
Example
const colours = ColorList.create(
["red", "green", "blue"],
{ owner: me }
);
const animals = AnimalList.create(
[cat, dog, fish],
{ owner: me }
);
Subscription & Loading
CoList.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoList<any>
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a CoList with a given ID, as a given account.

depth specifies if item CoValue references should be loaded as well before resolving.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or for shallowly loading only this CoList, or [itemDepth] for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.
Example
const animalsWithVets =
await ListOfAnimals.load(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
me,
[{ vet: {} }]
);
CoList.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoList<any>
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
CoList.subscribe<C, Depth>(id, depth, listener): () => void
C extends CoList<any>
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Load and subscribe to a CoList with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies if item CoValue references should be loaded as well before calling listener for the first time.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or for shallowly loading only this CoList, or [itemDepth] for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
Example
const unsub = ListOfAnimals.subscribe(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
me,
{ vet: {} },
(animalsWithVets) => console.log(animalsWithVets)
);
CoList.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends CoList<any>
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<L, Depth>(depth): Promise<DeeplyLoaded<L, Depth> | undefined>
L extends CoList<any>
this: L,
depth: Depth & DepthsIn<L>
Given an already loaded CoList, ensure that items are loaded to the specified depth.

Works like
CoList.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<L, Depth>(depth, listener): () => void
L extends CoList<any>
this: L,
depth: Depth & DepthsIn<L>,
listener: (value: DeeplyLoaded<L, Depth>) => void
Given an already loaded CoList, subscribe to updates to the CoList and ensure that items are loaded to the specified depth.

Works like
CoList.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoList to be uploaded to the other peers.
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any[]
⚠️ undocumented
Internals
CoList.fromRaw<V>(raw): V & CoList<any>
V extends CoList<any>
this: CoValueClass<V> & CoList,
raw: RawCoList<JsonValue, JsonObject | null>
⚠️ undocumented
._raw: RawCoList<JsonValue, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoList"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoList[species]: ArrayConstructor
⚠️ undocumented
CoList.isArray(arg): arg is any[]
arg: any
⚠️ undocumented
CoList.from<T>(arrayLike): T[]
arrayLike: ArrayLike<T>
Creates an array from an array-like object.
CoList.from<T, U>(arrayLike, mapfn, thisArg): U[]
arrayLike: ArrayLike<T>,
mapfn: (v: T, k: number) => U,
thisArg: any
Creates an array from an iterable object.
CoList.from<T>(iterable): T[]
iterable: ArrayLike<T> | Iterable<T>
Creates an array from an iterable object.
CoList.from<T, U>(iterable, mapfn, thisArg): U[]
iterable: ArrayLike<T> | Iterable<T>,
mapfn: (v: T, k: number) => U,
thisArg: any
Creates an array from an iterable object.
.constructor: NO TYPE
⚠️ undocumented
._edits: { undefined }
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.push(items): number
items: Item[]
⚠️ undocumented
.unshift(items): number
items: Item[]
⚠️ undocumented
.pop(): Item | undefined
⚠️ undocumented
.shift(): Item | undefined
⚠️ undocumented
.splice(start, deleteCount, items): Item[]
start: number,
deleteCount: number,
items: Item[]
⚠️ undocumented
.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.
.toString(): string
Returns a string representation of an array.
.toLocaleString(): string
Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.
.concat(items): Item[]
items: ConcatArray<Item>[]
Combines two or more arrays.
This method returns a new array without modifying any existing arrays.
.concat(items): Item[]
items: ConcatArray<Item> | Item[]
Combines two or more arrays.
This method returns a new array without modifying any existing arrays.
.join(separator): string
separator: string
Adds all the elements of an array into a string, separated by the specified separator string.
.reverse(): Item[]
Reverses the elements in an array in place.
This method mutates the array and returns a reference to the same array.
.slice(start, end): Item[]
start: number,
end: number
Returns a copy of a section of an array.
For both start and end, a negative index can be used to indicate an offset from the end of the array.
For example, -2 refers to the second to last element of the array.
.sort(compareFn): this
compareFn: (a: Item, b: Item) => number
Sorts an array in place.
This method mutates the array and returns a reference to the same array.
.indexOf(searchElement, fromIndex): number
searchElement: Item,
fromIndex: number
Returns the index of the first occurrence of a value in an array, or -1 if it is not present.
.lastIndexOf(searchElement, fromIndex): number
searchElement: Item,
fromIndex: number
Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.
.every<S>(predicate, thisArg): this is S[]
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Determines whether all the members of an array satisfy the specified test.
.every(predicate, thisArg): boolean
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Determines whether all the members of an array satisfy the specified test.
.some(predicate, thisArg): boolean
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Determines whether the specified callback function returns true for any element of an array.
.forEach(callbackfn, thisArg): void
callbackfn: (value: Item, index: number, array: Item[]) => void,
thisArg: any
Performs the specified action for each element in an array.
.map<U>(callbackfn, thisArg): U[]
callbackfn: (value: Item, index: number, array: Item[]) => U,
thisArg: any
Calls a defined callback function on each element of an array, and returns an array that contains the results.
.filter<S>(predicate, thisArg): S[]
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Returns the elements of an array that meet the condition specified in a callback function.
.filter(predicate, thisArg): Item[]
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Returns the elements of an array that meet the condition specified in a callback function.
.reduce(callbackfn): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduce(callbackfn, initialValue): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item,
initialValue: Item
⚠️ undocumented
.reduce<U>(callbackfn, initialValue): U
callbackfn: (previousValue: U, currentValue: Item, currentIndex: number, array: Item[]) => U,
initialValue: U
Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduceRight(callbackfn): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item
Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.reduceRight(callbackfn, initialValue): Item
callbackfn: (previousValue: Item, currentValue: Item, currentIndex: number, array: Item[]) => Item,
initialValue: Item
⚠️ undocumented
.reduceRight<U>(callbackfn, initialValue): U
callbackfn: (previousValue: U, currentValue: Item, currentIndex: number, array: Item[]) => U,
initialValue: U
Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
.find<S>(predicate, thisArg): S | undefined
predicate: (value: Item, index: number, obj: Item[]) => value is S,
thisArg: any
Returns the value of the first element in the array where predicate is true, and undefined
otherwise.
.find(predicate, thisArg): Item | undefined
predicate: (value: Item, index: number, obj: Item[]) => unknown,
thisArg: any
⚠️ undocumented
.findIndex(predicate, thisArg): number
predicate: (value: Item, index: number, obj: Item[]) => unknown,
thisArg: any
Returns the index of the first element in the array where predicate is true, and -1
otherwise.
.fill(value, start, end): this
value: Item,
start: number,
end: number
Changes all array elements from start to end index to a static value and returns the modified array
.copyWithin(target, start, end): this
target: number,
start: number,
end: number
Returns the this object after copying a section of the array identified by start and end
to the same array starting at position target
.entries(): IterableIterator<[number, Item]>
Returns an iterable of key, value pairs for every entry in the array
.keys(): IterableIterator<number>
Returns an iterable of keys in the array
.values(): IterableIterator<Item>
Returns an iterable of values in the array
.includes(searchElement, fromIndex): boolean
searchElement: Item,
fromIndex: number
Determines whether an array includes a certain element, returning true or false as appropriate.
.flatMap<U, This>(callback, thisArg): U[]
callback: (this: This, value: Item, index: number, array: Item[]) => TODO type typeOperator | U,
thisArg: This
Calls a defined callback function on each element of an array. Then, flattens the result into
a new array.
This is identical to a map followed by flat with depth 1.
.flat<A, D>(depth): FlatArray<A, D>[]
D extends number
this: A,
depth: D
Returns a new array with all sub-array elements concatenated into it recursively up to the
specified depth.
.at(index): Item | undefined
index: number
Returns the item located at the specified index.
.findLast<S>(predicate, thisArg): S | undefined
predicate: (value: Item, index: number, array: Item[]) => value is S,
thisArg: any
Returns the value of the last element in the array where predicate is true, and undefined
otherwise.
.findLast(predicate, thisArg): Item | undefined
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
⚠️ undocumented
.findLastIndex(predicate, thisArg): number
predicate: (value: Item, index: number, array: Item[]) => unknown,
thisArg: any
Returns the index of the last element in the array where predicate is true, and -1
otherwise.
.toReversed(): Item[]
Returns a copy of an array with its elements reversed.
.toSorted(compareFn): Item[]
compareFn: (a: Item, b: Item) => number
Returns a copy of an array with its elements sorted.
.toSpliced(start, deleteCount, items): Item[]
start: number,
deleteCount: number,
items: Item[]
Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.
.toSpliced(start, deleteCount): Item[]
start: number,
deleteCount: number
Copies an array and removes elements while returning the remaining elements.
.with(index, value): Item[]
index: number,
value: Item
Copies an array, then overwrites the value at the provided index with the
given value. If the index is negative, then it replaces from the end
of the array.
.[iterator](): IterableIterator<Item>
Iterator
[unscopables]: { length: boolean, toString: NO TYPE, toLocaleString: NO TYPE, pop: NO TYPE, push: NO TYPE, concat: NO TYPE, join: NO TYPE, reverse: NO TYPE, shift: NO TYPE, slice: NO TYPE, sort: NO TYPE, splice: NO TYPE, unshift: NO TYPE, indexOf: NO TYPE, lastIndexOf: NO TYPE, every: NO TYPE, some: NO TYPE, forEach: NO TYPE, map: NO TYPE, filter: NO TYPE, reduce: NO TYPE, reduceRight: NO TYPE, find: NO TYPE, findIndex: NO TYPE, fill: NO TYPE, copyWithin: NO TYPE, entries: NO TYPE, keys: NO TYPE, values: NO TYPE, includes: NO TYPE, flatMap: NO TYPE, flat: NO TYPE, at: NO TYPE, findLast: NO TYPE, findLastIndex: NO TYPE, toReversed: NO TYPE, toSorted: NO TYPE, toSpliced: NO TYPE, with: NO TYPE, [iterator]: NO TYPE, [unscopables]: boolean }
Is an object whose properties have the value 'true'
when they will be absent when used in a 'with' statement.
CoMaps are collaborative versions of plain objects, mapping string-like keys to values.
Declaration
Declare your own CoMap schemas by subclassing CoMap and assigning field schemas with co.

Optional
co.ref(...) fields must be marked with { optional: true }.

Example
import { co, CoMap } from "jazz-tools";

class Person extends CoMap {
name = co.string;
age = co.number;
pet = co.ref(Animal);
car = co.ref(Car, { optional: true });
}
CoMap.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
You can access properties you declare on a CoMap (using co) as if they were normal properties on a plain object, using dot notation, Object.keys(), etc.

Example
person.name;
person["age"];
person.age = 42;
person.pet?.name;
Object.keys(person);
// => ["name", "age", "pet"]
.id: ID<CoMap>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the
Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
Return a JSON representation of the CoMap
Creation
CoMap.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue } | Group | Account
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example
const person = Person.create({
name: "Alice",
age: 42,
pet: cat,
}, { owner: friendGroup });
Subscription & Loading
CoMap.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.
Example
const person = await Person.load(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} }
);
CoMap.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
CoMap.subscribe<C, Depth>(id, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
Example
const unsub = Person.subscribe(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} },
(person) => console.log(person)
);
CoMap.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoMap to be uploaded to the other peers.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], LastAndAllCoMapEdits<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.[inspect](): any[]
⚠️ undocumented
Internals
CoMap.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoMap.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: Group | AnonymousJazzAgent | Account
⚠️ undocumented
.applyDiff<N>(newValues): CoMap
N extends Partial<CoMapInit<CoMap>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
SchemaUnion allows you to create union types of CoValues that can be discriminated at runtime.
Declaration
Declare your union types by extending SchemaUnion.Of(...) and passing a discriminator function that determines which concrete type to use based on the raw data.

Example
import { SchemaUnion, CoMap } from "jazz-tools";

class BaseWidget extends CoMap {
type = co.string;
}

class ButtonWidget extends BaseWidget {
type = co.literal("button");
label = co.string;
}

class SliderWidget extends BaseWidget {
type = co.literal("slider");
min = co.number;
max = co.number;
}

const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
switch (raw.get("type")) {
case "button": return ButtonWidget;
case "slider": return SliderWidget;
default: throw new Error("Unknown widget type");
}
});
SchemaUnion.Of<V>(discriminator): CoValueClass<V> & SchemaUnion
V extends CoValue
discriminator: (raw: V["_raw"]) => CoValueClass<V> & CoValueFromRaw<V>
Create a new union type from a discriminator function.

The discriminator function receives the raw data and should return the appropriate concrete class to use for that data.

When loading a SchemaUnion, the correct subclass will be instantiated based on the discriminator.
Example
const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
switch (raw.get("type")) {
case "button": return ButtonWidget;
case "slider": return SliderWidget;
default: throw new Error("Unknown widget type");
}
});

const widget = await loadCoValue(WidgetUnion, id, me, {});

// You can narrow the returned instance to a subclass by using `instanceof`
if (widget instanceof ButtonWidget) {
console.log(widget.label);
} else if (widget instanceof SliderWidget) {
console.log(widget.min, widget.max);
}
Content
.id: ID<SchemaUnion>
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): any[] | string | object
⚠️ undocumented
.[inspect](): any[] | string | object
⚠️ undocumented
Internals
._raw: RawCoValue
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: string
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
.constructor: NO TYPE
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

Identity & Permissions

Content
.id: ID<Account>
⚠️ undocumented
Subscription & Loading
Account.load<A, Depth>(id, depth): Promise<DeeplyLoaded<A, Depth> | undefined>
A extends Account
this: CoValueClass<A>,
id: ID<A>,
depth: Depth & DepthsIn<A>
⚠️ undocumented
Account.load<A, Depth>(id, as, depth): Promise<DeeplyLoaded<A, Depth> | undefined>
A extends Account
this: CoValueClass<A>,
id: ID<A>,
as: Account,
depth: Depth & DepthsIn<A>
⚠️ undocumented
Account.subscribe<A, Depth>(id, depth, listener): () => void
A extends Account
this: CoValueClass<A>,
id: ID<A>,
depth: Depth & DepthsIn<A>,
listener: (value: DeeplyLoaded<A, Depth>) => void
⚠️ undocumented
Account.subscribe<A, Depth>(id, as, depth, listener): () => void
A extends Account
this: CoValueClass<A>,
id: ID<A>,
as: Account,
depth: Depth & DepthsIn<A>,
listener: (value: DeeplyLoaded<A, Depth>) => void
⚠️ undocumented
.ensureLoaded<A, Depth>(depth): Promise<DeeplyLoaded<A, Depth> | undefined>
A extends Account
this: A,
depth: Depth & DepthsIn<A>
⚠️ undocumented
.subscribe<A, Depth>(depth, listener): () => void
A extends Account
this: A,
depth: Depth & DepthsIn<A>,
listener: (value: DeeplyLoaded<A, Depth>) => void
⚠️ undocumented
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the Account to be uploaded to the other peers.
.waitForAllCoValuesSync(options): Promise<unknown[][]>
options: { timeout: number }
Wait for all the available CoValues to be uploaded to the other peers.
Collaboration
._owner: Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): any[] | object
⚠️ undocumented
.[inspect](): any[] | object
⚠️ undocumented
Internals
Account.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawControlledAccount<AccountMeta> | RawAccount<AccountMeta>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "Account"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Account._schema: any
⚠️ undocumented
Account.create<A>(options): Promise<A>
A extends Account
this: CoValueClass<A> & Account,
options: { creationProps: { name: string }, crypto: CryptoProvider<any>, initialAgentSecret: TODO type templateLiteral, peersToLoadFrom: Peer[] }
⚠️ undocumented
Account.getMe<A>(): A
A extends Account
this: CoValueClass<A> & Account
⚠️ undocumented
Account.createAs<A>(as, options): Promise<A>
A extends Account
this: CoValueClass<A> & Account,
as: Account,
options: { creationProps: { name: string } }
⚠️ undocumented
Account.fromNode<A>(node): A
A extends Account
this: CoValueClass<A>,
node: LocalNode
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
._schema: { profile: Schema, root: Schema }
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.profile: Profile | null
⚠️ undocumented
.root: CoMap | null
⚠️ undocumented
._refs: { profile: Ref<Profile> | undefined, root: Ref<CoMap> | undefined }
⚠️ undocumented
.isMe: boolean
⚠️ undocumented
.sessionID: TODO type templateLiteral | TODO type templateLiteral | undefined
⚠️ undocumented
.myRole(): "admin" | undefined
⚠️ undocumented
.acceptInvite<V>(valueID, inviteSecret, coValueClass): Promise<(TODO type conditional) | undefined>
V extends CoValue
valueID: ID<V>,
inviteSecret: TODO type templateLiteral,
coValueClass: CoValueClass<V>
⚠️ undocumented
.applyMigration(creationProps): Promise<void>
creationProps: { name: string, onboarding: boolean }
⚠️ undocumented
.migrate(creationProps): void
creationProps: { name: string }
⚠️ undocumented
isControlledAccount(account): account is Account & { isMe: true, sessionID: TODO type templateLiteral | TODO type templateLiteral, _raw: RawControlledAccount<AccountMeta> }
account: Account
Content
.id: ID<Group>
⚠️ undocumented
Subscription & Loading
Group.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends Group
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
⚠️ undocumented
Group.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends Group
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
Group.subscribe<C, Depth>(id, depth, listener): () => void
C extends Group
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
Group.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends Group
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<G, Depth>(depth): Promise<DeeplyLoaded<G, Depth> | undefined>
G extends Group
this: G,
depth: Depth & DepthsIn<G>
⚠️ undocumented
.subscribe<G, Depth>(depth, listener): () => void
G extends Group
this: G,
depth: Depth & DepthsIn<G>,
listener: (value: DeeplyLoaded<G, Depth>) => void
⚠️ undocumented
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the Group to be uploaded to the other peers.
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): any[] | string | object
⚠️ undocumented
.[inspect](): any[] | string | object
⚠️ undocumented
Internals
Group.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawGroup<JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "Group"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Group._schema: any
⚠️ undocumented
Group.create<G>(options): G
G extends Group
this: CoValueClass<G>,
options: { owner: Account } | Account
⚠️ undocumented
.constructor: NO TYPE
⚠️ undocumented
._schema: { profile: Schema, root: Schema, [MembersSym]: RefEncoded<Account> }
⚠️ undocumented
.profile: Profile | null
⚠️ undocumented
.root: CoMap | null
⚠️ undocumented
._refs: { profile: Ref<Profile> | undefined, root: Ref<CoMap> | undefined }
⚠️ undocumented
.myRole(): Role | undefined
⚠️ undocumented
.addMember(member, role): Group
member: Account | "everyone",
role: Role
⚠️ undocumented
.removeMember(member): Group
member: Account | "everyone"
⚠️ undocumented
.members: { id: ID<this[MembersSym]> | "everyone", role: Role | undefined, ref: Ref<NonNullable<this[MembersSym]>> | undefined, account: NO TYPE }[]
⚠️ undocumented
.extend(parent): Group
parent: Group
⚠️ undocumented
[MembersSym]: Account | null
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
Declaration
Profile.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
.id: ID<Profile>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the
Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
Return a JSON representation of the CoMap
Creation
Profile.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue } | Group | Account
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example
const person = Person.create({
name: "Alice",
age: 42,
pet: cat,
}, { owner: friendGroup });
Subscription & Loading
Profile.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.
Example
const person = await Person.load(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} }
);
Profile.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
Profile.subscribe<C, Depth>(id, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
Example
const unsub = Person.subscribe(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} },
(person) => console.log(person)
);
Profile.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoMap to be uploaded to the other peers.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], LastAndAllCoMapEdits<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.[inspect](): any[]
⚠️ undocumented
Internals
Profile.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
Profile.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: Group | AnonymousJazzAgent | Account
⚠️ undocumented
.name: co<string>
⚠️ undocumented
.inbox: co<CoID<InboxRoot> | undefined>
⚠️ undocumented
.inboxInvite: co<TODO type templateLiteral | undefined>
⚠️ undocumented
.applyDiff<N>(newValues): Profile
N extends Partial<CoMapInit<Profile>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

Schema definition

Encoders reflection

co reflection

type co

type co<T> = T & CoMarker | T

⚠️ undocumented

Abstract interfaces

Content
.id: ID<CoValue>
⚠️ undocumented
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(key, seenAbove): any[] | string | object
key: string,
seenAbove: ID<CoValue>[]
⚠️ undocumented
.[inspect](): any
⚠️ undocumented
Internals
._raw: RawCoValue
⚠️ undocumented
Type Helpers
._type: string
⚠️ undocumented
Content
.id: ID<CoPlainText>
⚠️ undocumented
Subscription & Loading
CoPlainText.load<T>(id, as): Promise<T | undefined>
T extends CoPlainText
this: CoValueClass<T>,
id: ID<T>,
as: Account
Load a CoPlainText with a given ID, as a given account.
CoPlainText.subscribe<T>(id, listener): () => void
T extends CoPlainText
this: CoValueClass<T>,
id: ID<T>,
listener: (value: T) => void
Load and subscribe to a CoPlainText with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

Check out the
load methods on CoMap/CoList/CoStream/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
CoPlainText.subscribe<T>(id, as, listener): () => void
T extends CoPlainText
this: CoValueClass<T>,
id: ID<T>,
as: Account,
listener: (value: T) => void
⚠️ undocumented
.subscribe<T>(listener): () => void
T extends CoPlainText
this: T,
listener: (value: T) => void
Given an already loaded CoPlainText, subscribe to updates to the CoPlainText and ensure that the specified fields are loaded to the specified depth.

Works like
CoPlainText.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
Collaboration
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.toJSON(): string
⚠️ undocumented
.[inspect](): string
⚠️ undocumented
Internals
._raw: RawCoPlainText<JsonObject | null>
⚠️ undocumented
Type Helpers
._type: "CoPlainText"
⚠️ undocumented
Other
CoPlainText.create<T>(text, options): T
T extends CoPlainText
this: CoValueClass<T>,
text: string,
options: { owner: Group | Account }
⚠️ undocumented
CoPlainText.fromRaw<V>(raw): V & CoPlainText
V extends CoPlainText
this: CoValueClass<V> & CoPlainText,
raw: RawCoPlainText<JsonObject | null>
⚠️ undocumented
CoPlainText.fromCharCode(codes): string
codes: number[]
⚠️ undocumented
CoPlainText.fromCodePoint(codePoints): string
codePoints: number[]
Return the String value whose elements are, in order, the elements in the List elements.
If length is 0, the empty string is returned.
CoPlainText.raw(template, substitutions): string
template: { raw: TODO type typeOperator | ArrayLike<string> },
substitutions: any[]
String.raw is usually used as a tag function of a Tagged Template String. When called as
such, the first argument will be a well formed template call site object and the rest
parameter will contain the substitution values. It can also be called directly, for example,
to interleave strings and values from your own tag function, and in this case the only thing
it needs from the first argument is the raw property.
.constructor: NO TYPE
⚠️ undocumented
._loadedAs: Account
⚠️ undocumented
.length: number
⚠️ undocumented
.toString(): string
⚠️ undocumented
.valueOf(): string
⚠️ undocumented
.insertAfter(idx, text): void
idx: number,
text: string
⚠️ undocumented
.deleteRange(range): void
range: { from: number, to: number }
⚠️ undocumented
.posBefore(idx): OpID | undefined
idx: number
⚠️ undocumented
.posAfter(idx): OpID | undefined
idx: number
⚠️ undocumented
.idxBefore(pos): undefined | number
pos: OpID
⚠️ undocumented
.idxAfter(pos): undefined | number
pos: OpID
⚠️ undocumented
.charAt(pos): string
pos: number
Returns the character at the specified index.
.charCodeAt(index): number
index: number
Returns the Unicode value of the character at the specified location.
.concat(strings): string
strings: string[]
Returns a string that contains the concatenation of two or more strings.
.indexOf(searchString, position): number
searchString: string,
position: number
Returns the position of the first occurrence of a substring.
.lastIndexOf(searchString, position): number
searchString: string,
position: number
Returns the last occurrence of a substring in the string.
.localeCompare(that): number
that: string
Determines whether two strings are equivalent in the current locale.
.localeCompare(that, locales, options): number
that: string,
locales: string[] | string,
options: CollatorOptions
Determines whether two strings are equivalent in the current or specified locale.
.localeCompare(that, locales, options): number
that: string,
locales: LocalesArgument,
options: CollatorOptions
Determines whether two strings are equivalent in the current or specified locale.
.match(regexp): RegExpMatchArray | null
regexp: RegExp | string
Matches a string with a regular expression, and returns an array containing the results of that search.
.match(matcher): RegExpMatchArray | null
matcher: { [match]: NO TYPE }
Matches a string or an object that supports being matched against, and returns an array
containing the results of that search, or null if no matches are found.
.replace(searchValue, replaceValue): string
searchValue: RegExp | string,
replaceValue: string
Replaces text in a string, using a regular expression or search string.
.replace(searchValue, replacer): string
searchValue: RegExp | string,
replacer: (substring: string, args: any[]) => string
Replaces text in a string, using a regular expression or search string.
.replace(searchValue, replaceValue): string
searchValue: { [replace]: NO TYPE },
replaceValue: string
Passes a string and @linkcode replaceValue to the [Symbol.replace] method on @linkcode searchValue. This method is expected to implement its own replacement algorithm.
.replace(searchValue, replacer): string
searchValue: { [replace]: NO TYPE },
replacer: (substring: string, args: any[]) => string
Replaces text in a string, using an object that supports replacement within a string.
.search(regexp): number
regexp: RegExp | string
Finds the first substring match in a regular expression search.
.search(searcher): number
searcher: { [search]: NO TYPE }
Finds the first substring match in a regular expression search.
.slice(start, end): string
start: number,
end: number
Returns a section of a string.
.split(separator, limit): string[]
separator: RegExp | string,
limit: number
Split a string into substrings using the specified separator and return them as an array.
.split(splitter, limit): string[]
splitter: { [split]: NO TYPE },
limit: number
Split a string into substrings using the specified separator and return them as an array.
.substring(start, end): string
start: number,
end: number
Returns the substring at the specified location within a String object.
.toLowerCase(): string
Converts all the alphabetic characters in a string to lowercase.
.toLocaleLowerCase(locales): string
locales: string[] | string
Converts all alphabetic characters to lowercase, taking into account the host environment's current locale.
.toLocaleLowerCase(locales): string
locales: LocalesArgument
Converts all alphabetic characters to lowercase, taking into account the host environment's current locale.
.toUpperCase(): string
Converts all the alphabetic characters in a string to uppercase.
.toLocaleUpperCase(locales): string
locales: string[] | string
Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale.
.toLocaleUpperCase(locales): string
locales: LocalesArgument
Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale.
.trim(): string
Removes the leading and trailing white space and line terminator characters from a string.
.substr(from, length): string
from: number,
length: number
Gets a substring beginning at the specified location and having the specified length.
.codePointAt(pos): undefined | number
pos: number
Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
value of the UTF-16 encoded code point starting at the string element at position pos in
the String resulting from converting this object to a String.
If there is no element at that position, the result is undefined.
If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
.includes(searchString, position): boolean
searchString: string,
position: number
Returns true if searchString appears as a substring of the result of converting this
object to a String, at one or more positions that are
greater than or equal to position; otherwise, returns false.
.endsWith(searchString, endPosition): boolean
searchString: string,
endPosition: number
Returns true if the sequence of elements of searchString converted to a String is the
same as the corresponding elements of this object (converted to a String) starting at
endPosition – length(this). Otherwise returns false.
.normalize(form): string
form: "NFKD" | "NFKC" | "NFD" | "NFC"
Returns the String value result of normalizing the string into the normalization form
named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms.
.normalize(form): string
form: string
Returns the String value result of normalizing the string into the normalization form
named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms.
.repeat(count): string
count: number
Returns a String value that is made from count copies appended together. If count is 0,
the empty string is returned.
.startsWith(searchString, position): boolean
searchString: string,
position: number
Returns true if the sequence of elements of searchString converted to a String is the
same as the corresponding elements of this object (converted to a String) starting at
position. Otherwise returns false.
.anchor(name): string
name: string
Returns an <a> HTML anchor element and sets the name attribute to the text value
.big(): string
Returns a <big> HTML element
.blink(): string
Returns a <blink> HTML element
.bold(): string
Returns a <b> HTML element
.fixed(): string
Returns a <tt> HTML element
.fontcolor(color): string
color: string
Returns a <font> HTML element and sets the color attribute value
.fontsize(size): string
size: number
Returns a <font> HTML element and sets the size attribute value
.fontsize(size): string
size: string
Returns a <font> HTML element and sets the size attribute value
.italics(): string
Returns an <i> HTML element
.link(url): string
url: string
Returns an <a> HTML element and sets the href attribute value
.small(): string
Returns a <small> HTML element
.strike(): string
Returns a <strike> HTML element
.sub(): string
Returns a <sub> HTML element
.sup(): string
Returns a <sup> HTML element
.padStart(maxLength, fillString): string
maxLength: number,
fillString: string
Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
The padding is applied from the start (left) of the current string.
.padEnd(maxLength, fillString): string
maxLength: number,
fillString: string
Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
The padding is applied from the end (right) of the current string.
.trimEnd(): string
Removes the trailing white space and line terminator characters from a string.
.trimStart(): string
Removes the leading white space and line terminator characters from a string.
.trimLeft(): string
Removes the leading white space and line terminator characters from a string.
.trimRight(): string
Removes the trailing white space and line terminator characters from a string.
.matchAll(regexp): IterableIterator<RegExpExecArray>
regexp: RegExp
Matches a string with a regular expression, and returns an iterable of matches
containing the results of that search.
.replaceAll(searchValue, replaceValue): string
searchValue: RegExp | string,
replaceValue: string
Replace all instances of a substring in a string, using a regular expression or search string.
.replaceAll(searchValue, replacer): string
searchValue: RegExp | string,
replacer: (substring: string, args: any[]) => string
Replace all instances of a substring in a string, using a regular expression or search string.
.at(index): undefined | string
index: number
Returns a new String consisting of the single UTF-16 code unit located at the specified index.
.[iterator](): IterableIterator<string>
Iterator
Value extends CoValue

Media

Declaration
ImageDefinition.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
.id: ID<ImageDefinition>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the
Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
Return a JSON representation of the CoMap
Creation
ImageDefinition.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue } | Group | Account
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example
const person = Person.create({
name: "Alice",
age: 42,
pet: cat,
}, { owner: friendGroup });
Subscription & Loading
ImageDefinition.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.
Example
const person = await Person.load(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} }
);
ImageDefinition.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
ImageDefinition.subscribe<C, Depth>(id, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
Example
const unsub = Person.subscribe(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} },
(person) => console.log(person)
);
ImageDefinition.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoMap to be uploaded to the other peers.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], LastAndAllCoMapEdits<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.[inspect](): any[]
⚠️ undocumented
Internals
ImageDefinition.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
ImageDefinition.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: Group | AnonymousJazzAgent | Account
⚠️ undocumented
.originalSize: co<[number, number]>
⚠️ undocumented
.highestResAvailable(options): { res: TODO type templateLiteral, stream: FileStream } | undefined
options: { maxWidth: number }
⚠️ undocumented
[ItemsSym]: co<FileStream | null>
⚠️ undocumented
.applyDiff<N>(newValues): ImageDefinition
N extends Partial<CoMapInit<ImageDefinition>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented
.placeholderDataURL: co<string>
⚠️ undocumented

Other

type AgentID

type AgentIDundefined = TODO type templateLiteral

⚠️ undocumented

type CoValueUniqueness

type CoValueUniquenessundefined = { uniqueness: JsonValue, createdAt: null | TODO type templateLiteral }

⚠️ undocumented

type InviteSecret

type InviteSecretundefined = TODO type templateLiteral

⚠️ undocumented

type SessionID

type SessionIDundefined = TODO type templateLiteral

⚠️ undocumented

type SyncMessage

type SyncMessageundefined = DoneMessage | NewContentMessage | KnownStateMessage | LoadMessage

⚠️ undocumented
I extends CoValue,
O extends CoValue | undefined

type AccountClass

type AccountClass<Acc extends Account> = CoValueClass<Acc> & { fromNode: Account["fromNode"] }

⚠️ undocumented

CoStream

FileStream

type CoMapInit

type CoMapInit<Map extends object> = {[Key in CoKeys<Map>]: ForceRequiredRef<Map[Key]>} & {[Key in CoKeys<Map>]: ForceRequiredRef<Map[Key]>}

⚠️ undocumented

type TextPos

type TextPosundefined = OpID

⚠️ undocumented
Main class for handling rich text content with marks.
Combines plain text with a list of marks for formatting and annotations.
Provides methods for text manipulation, mark insertion, and tree conversion.
Declaration
CoRichText.Record<Value>(value): RecordLikeCoMap
value: IfCo<Value, Value>
Declare a Record-like CoMap schema, by extending CoMap.Record(...) and passing the value schema using co. Keys are always string.
Example
import { co, CoMap } from "jazz-tools";

class ColorToFruitMap extends CoMap.Record(
co.ref(Fruit)
) {}

// assume we have map: ColorToFruitMap
// and strawberry: Fruit
map["red"] = strawberry;
Content
.id: ID<CoRichText>
The ID of this CoMap
._refs: {[Key in string]: IfCo<this[Key], RefIfCoValue<this[Key]>>}
If property prop is a co.ref(...), you can use coMaps._refs.prop to access
the
Ref instead of the potentially loaded/null value.

This allows you to always get the ID or load the value manually.
Example
person._refs.pet.id; // => ID<Animal>
person._refs.pet.value;
// => Animal | null
const pet = await person._refs.pet.load();
.toJSON(_key, seenAbove): any[]
_key: string,
seenAbove: ID<CoValue>[]
Return a JSON representation of the CoMap
Creation
CoRichText.create<M>(init, options): M
M extends CoMap
this: CoValueClass<M>,
init: Simplify<CoMapInit<M>>,
options: { owner: Group | Account, unique: JsonValue } | Group | Account
Create a new CoMap with the given initial values and owner.

The owner (a Group or Account) determines access rights to the CoMap.

The CoMap will immediately be persisted and synced to connected peers.
Example
const person = Person.create({
name: "Alice",
age: 42,
pet: cat,
}, { owner: friendGroup });
Subscription & Loading
CoRichText.load<C, Depth>(id, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>
Load a CoMap with a given ID, as a given account.

depth specifies which (if any) fields that reference other CoValues to load as well before resolving.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.
Example
const person = await Person.load(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} }
);
CoRichText.load<C, Depth>(id, as, depth): Promise<DeeplyLoaded<C, Depth> | undefined>
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>
⚠️ undocumented
CoRichText.subscribe<C, Depth>(id, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
Load and subscribe to a CoMap with a given ID, as a given account.

Automatically also subscribes to updates to all referenced/nested CoValues as soon as they are accessed in the listener.

depth specifies which (if any) fields that reference other CoValues to load as well before calling listener for the first time.
The
DeeplyLoaded return type guarantees that corresponding referenced CoValues are loaded to the specified depth.

You can pass
[] or {} for shallowly loading only this CoMap, or { fieldA: depthA, fieldB: depthB } for recursively loading referenced CoValues.

Check out the
load methods on CoMap/CoList/CoFeed/Group/Account to see which depth structures are valid to nest.

Returns an unsubscribe function that you should call when you no longer need updates.

Also see the
useCoState hook to reactively subscribe to a CoValue in a React component.
Example
const unsub = Person.subscribe(
"co_zdsMhHtfG6VNKt7RqPUPvUtN2Ax",
{ pet: {} },
(person) => console.log(person)
);
CoRichText.subscribe<C, Depth>(id, as, depth, listener): () => void
C extends CoMap
this: CoValueClass<C>,
id: ID<C>,
as: Account,
depth: Depth & DepthsIn<C>,
listener: (value: DeeplyLoaded<C, Depth>) => void
⚠️ undocumented
.ensureLoaded<M, Depth>(depth): Promise<DeeplyLoaded<M, Depth> | undefined>
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>
Given an already loaded CoMap, ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.load(), but you don't need to pass the ID or the account to load as again.
.subscribe<M, Depth>(depth, listener): () => void
M extends CoMap
this: M,
depth: Depth & DepthsIn<M>,
listener: (value: DeeplyLoaded<M, Depth>) => void
Given an already loaded CoMap, subscribe to updates to the CoMap and ensure that the specified fields are loaded to the specified depth.

Works like
CoMap.subscribe(), but you don't need to pass the ID or the account to load as again.

Returns an unsubscribe function that you should call when you no longer need updates.
.waitForSync(options): Promise<unknown[]>
options: { timeout: number }
Wait for the CoMap to be uploaded to the other peers.
Collaboration
._edits: {[Key in string]: IfCo<this[Key], LastAndAllCoMapEdits<this[Key]>>}
⚠️ undocumented
._owner: Group | Account
⚠️ undocumented
Stringifying & Inspection
.[inspect](): any[]
⚠️ undocumented
Internals
CoRichText.fromRaw<V>(raw): V
V extends CoValue
this: CoValueClass<V>,
raw: RawCoValue
⚠️ undocumented
._raw: RawCoMap<{ undefined }, JsonObject | null>
⚠️ undocumented
._instanceID: string
⚠️ undocumented
Type Helpers
._type: "CoMap"
⚠️ undocumented
.castAs<Cl>(cl): InstanceType<Cl>
Cl extends CoValueClass<CoValue> & CoValueFromRaw<CoValue>
cl: Cl
⚠️ undocumented
Other
CoRichText.createFromPlainText(text, options): CoRichText
text: string,
options: { owner: Group | Account }
Create a CoRichText from plain text.
CoRichText.createFromPlainTextAndMark<MarkClass>(text, WrapIn, extraArgs, options): CoRichText
MarkClass extends (args: any[]) => Mark
text: string,
WrapIn: MarkClass,
extraArgs: Omit<CoMapInit<InstanceType<MarkClass>>, "endBefore" | "endAfter" | "startBefore" | "startAfter">,
options: { owner: Group | Account }
Create a CoRichText from plain text and a mark.
CoRichText.findUnique<M>(unique, ownerID, as): ID<M>
M extends CoMap
this: CoValueClass<M>,
unique: JsonValue,
ownerID: ID<Group> | ID<Account>,
as: Group | AnonymousJazzAgent | Account
⚠️ undocumented
.text: co<CoPlainText | null>
⚠️ undocumented
.marks: co<CoList<co<Mark | null>> | null>
⚠️ undocumented
.insertAfter(idx, text): void
idx: number,
text: string
Insert text at a specific index.
.deleteRange(range): void
range: { from: number, to: number }
Delete a range of text.
.posBefore(idx): OpID | undefined
idx: number
Get the position of a specific index.
.posAfter(idx): OpID | undefined
idx: number
Get the position of a specific index.
.idxBefore(pos): undefined | number
pos: OpID
Get the index of a specific position.
.idxAfter(pos): undefined | number
pos: OpID
Get the index of a specific position.
.insertMark<MarkClass>(start, end, RangeClass, extraArgs, options): void
MarkClass extends (args: any[]) => Mark
start: number,
end: number,
RangeClass: MarkClass,
extraArgs: Omit<CoMapInit<InstanceType<MarkClass>>, "endBefore" | "endAfter" | "startBefore" | "startAfter">,
options: { markOwner: Group | Account }
Insert a mark at a specific range.
.removeMark<MarkClass>(start, end, RangeClass, options): void
MarkClass extends (args: any[]) => Mark
start: number,
end: number,
RangeClass: MarkClass,
options: { tag: string }
Remove a mark at a specific range.
.resolveMarks(): ResolvedMark<Mark>[]
Resolve the positions of all marks.
.resolveAndDiffuseMarks(): ResolvedAndDiffusedMark<Mark>[]
Resolve and diffuse the positions of all marks.
.resolveAndDiffuseAndFocusMarks(): ResolvedAndFocusedMark<Mark>[]
Resolve, diffuse, and focus the positions of all marks.
.toTree(tagPrecedence): TreeNode
tagPrecedence: string[]
Convert a CoRichText to a tree structure useful for client libraries.
.length: number
⚠️ undocumented
.toString(): string
Convert a CoRichText to plain text.
.applyDiff<N>(newValues): CoRichText
N extends Partial<CoMapInit<CoRichText>>
newValues: N
⚠️ undocumented
._loadedAs: AnonymousJazzAgent | Account
⚠️ undocumented

Marks reflection

type TreeLeaf

type TreeLeafundefined = { type: "leaf", start: number, end: number }

Represents a leaf node in the rich text tree structure.
Contains plain text without any marks.

type TreeNode

type TreeNodeundefined = { type: "node", tag: string, start: number, end: number, children: TreeLeaf | TreeNode[], range: ResolvedAndFocusedMark }

Represents a node in the rich text tree structure.
Can contain other nodes or leaves, and includes formatting information.

type ResolvedMark

type ResolvedMark<R extends Mark> = { startAfter: number, startBefore: number, endAfter: number, endBefore: number, sourceMark: R }

A mark with resolved numeric positions in text.
Contains both position information and reference to the source mark.

type DeeplyLoaded

type DeeplyLoaded<V, Depth, DepthLimit extends number, CurrentDepth extends number[]> = TODO type conditional

⚠️ undocumented

type DepthsIn

type DepthsIn<V, DepthLimit extends number, CurrentDepth extends number[]> = never[] | (TODO type conditional)

⚠️ undocumented
createCoValueObservable<V, Depth>(options): { getCurrentValue: () => DeeplyLoaded<V, Depth> | undefined, subscribe: (cls: CoValueClass<V>, id: ID<V>, as: AnonymousJazzAgent | Account, depth: Depth & DepthsIn<V>, listener: () => void, onUnavailable: () => void) => () => void }
options: { syncResolution: boolean }
loadCoValue<V, Depth>(cls, id, as, depth): Promise<DeeplyLoaded<V, Depth> | undefined>
cls: CoValueClass<V>,
id: ID<V>,
as: AnonymousJazzAgent | Account,
depth: Depth & DepthsIn<V>
subscribeToCoValue<V, Depth>(cls, id, as, depth, listener, onUnavailable, syncResolution): () => void
cls: CoValueClass<V>,
id: ID<V>,
as: AnonymousJazzAgent | Account,
depth: Depth & DepthsIn<V>,
listener: (value: DeeplyLoaded<V, Depth>, unsubscribe: () => void) => void,
onUnavailable: () => void,
syncResolution: boolean
createAnonymousJazzContext({ peersToLoadFrom, crypto }): Promise<JazzContextWithAgent>
{ peersToLoadFrom: Peer[], crypto: CryptoProvider<any> }
createJazzContext<Acc>(__namedParameters): Promise<JazzContextWithAccount<Acc>>
ContextParamsWithAuth<Acc>
createJazzContext(__namedParameters): Promise<JazzContextWithAgent>
BaseContextParams
createJazzContext<Acc>(options): Promise<JazzContext<Acc>>
options: ContextParamsWithAuth<Acc> | BaseContextParams
ephemeralCredentialsAuth(): AuthMethod
fixedCredentialsAuth(credentials): AuthMethod
credentials: { accountID: ID<Account>, secret: TODO type templateLiteral }
randomSessionProvider(accountID, crypto): Promise<{ sessionID: TODO type templateLiteral | TODO type templateLiteral, sessionDone: () => void }>
accountID: ID<Account>,
crypto: CryptoProvider<any>

type AuthResult

type AuthResultundefined = { type: "new", creationProps: { name: string, anonymous: boolean }, saveCredentials: (credentials: Credentials) => Promise<void>, onSuccess: () => void, onError: (error: Error | string) => void, logOut: () => void, initialSecret: AgentSecret } | { type: "existing", credentials: Credentials, onSuccess: () => void, onError: (error: Error | string) => void, logOut: () => void, saveCredentials: (credentials: Credentials) => Promise<void> }

⚠️ undocumented

type Credentials

type Credentialsundefined = { accountID: ID<Account>, secret: AgentSecret }

⚠️ undocumented