atom.io 0.41.0 → 0.42.0

package/src/transceivers/o-list/o-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
 export type ArrayUpdate<P extends primitive> =
@@ -95,179 +92,27 @@ true satisfies ArrayUpdate<any>[`type`] extends (typeof ARRAY_UPDATES)[number]
 export const ARRAY_UPDATE_ENUM: Enumeration<typeof ARRAY_UPDATES> =
 	enumeration(ARRAY_UPDATES)
 
-export function packArrayUpdate<P extends primitive>(
-	update: ArrayUpdate<P>,
-): PackedArrayUpdate<P> {
-	let packed = ARRAY_UPDATE_ENUM[update.type] + `\u001F`
-	switch (update.type) {
-		case `set`:
-			packed += update.index + `\u001E` + packValue(update.next)
-			if (update.prev !== undefined) {
-				packed += `\u001E` + packValue(update.prev)
-			}
-			return packed
-		case `truncate`:
-			return (
-				packed +
-				update.length +
-				`\u001E` +
-				update.items.map(packValue).join(`\u001E`)
-			)
-		case `extend`:
-			return packed + update.next + `\u001E` + update.prev
-		case `pop`:
-		case `shift`:
-			if (update.value !== undefined) {
-				packed += packValue(update.value)
-			}
-			return packed
-		case `push`:
-		case `unshift`:
-			return packed + update.items.map(packValue).join(`\u001E`)
-		case `copyWithin`:
-			packed += update.target + `\u001E` + update.start
-			if (update.end !== undefined) {
-				packed += `\u001E` + update.end
-			}
-			packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
-			return packed
-		case `fill`:
-			packed += packValue(update.value)
-			if (update.start !== undefined) {
-				packed += `\u001E` + update.start
-			}
-			if (update.end !== undefined) {
-				packed += `\u001E` + update.end
-			}
-			packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
-			return packed
-		case `splice`:
-			return (
-				packed +
-				update.start +
-				`\u001E\u001E` +
-				update.deleteCount +
-				`\u001E\u001E` +
-				update.items.map(packValue).join(`\u001E`) +
-				`\u001E\u001E` +
-				update.deleted.map(packValue).join(`\u001E`)
-			)
-		case `reverse`:
-			return packed
-		case `sort`:
-			return (
-				packed +
-				update.next.map(packValue).join(`\u001E`) +
-				`\u001E\u001E` +
-				update.prev.map(packValue).join(`\u001E`)
-			)
-	}
-}
-
-export function unpackArrayUpdate<P extends primitive>(
-	packed: PackedArrayUpdate<P>,
-): ArrayUpdate<P> {
-	const [head, tail] = packed.split(`\u001F`) as [
-		Extract<keyof typeof ARRAY_UPDATE_ENUM, number>,
-		string,
-	]
-	const type = ARRAY_UPDATE_ENUM[head]
-	switch (type) {
-		case `set`: {
-			const [i, n, p] = tail.split(`\u001E`)
-			const index = +i
-			const next = unpackValue(n) as P
-			if (p === undefined) {
-				return { type, index, next }
-			}
-			const prev = unpackValue(p) as P
-			return { type, index, next, prev }
-		}
-		case `truncate`: {
-			const [l, ...i] = tail.split(`\u001E`)
-			const length = +l
-			const items = i.map(unpackValue) as P[]
-			return { type, length, items }
-		}
-		case `extend`: {
-			const [n, p] = tail.split(`\u001E`)
-			const next = +n
-			const prev = +p
-			return { type, next, prev }
-		}
-		case `pop`:
-		case `shift`:
-			if (tail !== ``) {
-				const value = unpackValue(tail) as P
-				return { type, value }
-			}
-			return { type }
-		case `push`:
-		case `unshift`: {
-			const items = tail.split(`\u001E`).map(unpackValue) as P[]
-			return { type, items }
-		}
-		case `copyWithin`: {
-			const [numbers, data] = tail.split(`\u001E\u001E`)
-			const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
-			const [t, s, e] = numbers.split(`\u001E`)
-			const target = +t
-			const start = +s
-			if (e === undefined) {
-				return { type, target, start, prev }
-			}
-			const end = +e
-			return { type, target, start, prev, end }
-		}
-		case `fill`: {
-			const [numbers, data] = tail.split(`\u001E\u001E`)
-			const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
-			const [v, s, e] = numbers.split(`\u001E`)
-			const value = unpackValue(v) as P
-			if (s === undefined && e === undefined) {
-				return { type, value, prev }
-			}
-			const start = +s
-			if (e === undefined) {
-				return { type, value, prev, start }
-			}
-			const end = +e
-			return { type, value, prev, start, end }
-		}
-		case `splice`: {
-			const [s, c, i, d] = tail.split(`\u001E\u001E`)
-
-			const start = +s
-			const deleteCount = +c
-			const items = i ? (i.split(`\u001E`).map(unpackValue) as P[]) : []
-			const deleted = d ? (d.split(`\u001E`).map(unpackValue) as P[]) : []
-			return { type, start, deleteCount, items, deleted }
-		}
-		case `reverse`:
-			return { type }
-		case `sort`: {
-			const [n, p] = tail.split(`\u001E\u001E`)
-			const next = n ? (n.split(`\u001E`).map(unpackValue) as P[]) : []
-			const prev = p ? (p.split(`\u001E`).map(unpackValue) as P[]) : []
-			return { type, next, prev }
-		}
-	}
-}
-
 export type ArrayMutationHandler = {
 	[K in Exclude<OListUpdateType, `extend` | `set` | `truncate`>]: Fn
 }
 
+export type OListView<P extends primitive> = ReadonlyArray<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedArrayUpdate<P>) => void,
+	) => () => void
+}
+
 export class OList<P extends primitive>
 	extends Array<P>
 	implements
-		Transceiver<ReadonlyArray<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<OListView<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
 		ArrayMutationHandler
 {
 	public mode: TransceiverMode = `record`
 	public readonly subject: Subject<PackedArrayUpdate<P>> = new Subject()
 
-	public readonly READONLY_VIEW: ReadonlyArray<P> = this
+	public readonly READONLY_VIEW: OListView<P> = this
 
 	public constructor(arrayLength?: number)
 	public constructor(...items: P[])
@@ -473,7 +318,7 @@ export class OList<P extends primitive>
 	}
 
 	public emit(update: ArrayUpdate<P>): void {
-		this.subject.next(packArrayUpdate(update))
+		this.subject.next(OList.packUpdate(update))
 	}
 
 	private doStep(update: ArrayUpdate<P>): void {
@@ -523,7 +368,7 @@ export class OList<P extends primitive>
 
 	public do(update: PackedArrayUpdate<P>): null {
 		this.mode = `playback`
-		const unpacked = unpackArrayUpdate(update)
+		const unpacked = OList.unpackUpdate(update)
 		this.doStep(unpacked)
 		this.mode = `record`
 		return null
@@ -605,9 +450,168 @@ export class OList<P extends primitive>
 
 	public undo(update: PackedArrayUpdate<P>): number | null {
 		this.mode = `playback`
-		const unpacked = unpackArrayUpdate(update)
+		const unpacked = OList.unpackUpdate(update)
 		this.undoStep(unpacked)
 		this.mode = `record`
 		return null
 	}
+
+	public static packUpdate<P extends primitive>(
+		update: ArrayUpdate<P>,
+	): PackedArrayUpdate<P> {
+		let packed = ARRAY_UPDATE_ENUM[update.type] + `\u001F`
+		switch (update.type) {
+			case `set`:
+				packed += update.index + `\u001E` + packValue(update.next)
+				if (update.prev !== undefined) {
+					packed += `\u001E` + packValue(update.prev)
+				}
+				return packed
+			case `truncate`:
+				return (
+					packed +
+					update.length +
+					`\u001E` +
+					update.items.map(packValue).join(`\u001E`)
+				)
+			case `extend`:
+				return packed + update.next + `\u001E` + update.prev
+			case `pop`:
+			case `shift`:
+				if (update.value !== undefined) {
+					packed += packValue(update.value)
+				}
+				return packed
+			case `push`:
+			case `unshift`:
+				return packed + update.items.map(packValue).join(`\u001E`)
+			case `copyWithin`:
+				packed += update.target + `\u001E` + update.start
+				if (update.end !== undefined) {
+					packed += `\u001E` + update.end
+				}
+				packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
+				return packed
+			case `fill`:
+				packed += packValue(update.value)
+				if (update.start !== undefined) {
+					packed += `\u001E` + update.start
+				}
+				if (update.end !== undefined) {
+					packed += `\u001E` + update.end
+				}
+				packed += `\u001E\u001E` + update.prev.map(packValue).join(`\u001E`)
+				return packed
+			case `splice`:
+				return (
+					packed +
+					update.start +
+					`\u001E\u001E` +
+					update.deleteCount +
+					`\u001E\u001E` +
+					update.items.map(packValue).join(`\u001E`) +
+					`\u001E\u001E` +
+					update.deleted.map(packValue).join(`\u001E`)
+				)
+			case `reverse`:
+				return packed
+			case `sort`:
+				return (
+					packed +
+					update.next.map(packValue).join(`\u001E`) +
+					`\u001E\u001E` +
+					update.prev.map(packValue).join(`\u001E`)
+				)
+		}
+	}
+
+	public static unpackUpdate<P extends primitive>(
+		packed: PackedArrayUpdate<P>,
+	): ArrayUpdate<P> {
+		const [head, tail] = packed.split(`\u001F`) as [
+			Extract<keyof typeof ARRAY_UPDATE_ENUM, number>,
+			string,
+		]
+		const type = ARRAY_UPDATE_ENUM[head]
+		switch (type) {
+			case `set`: {
+				const [i, n, p] = tail.split(`\u001E`)
+				const index = +i
+				const next = unpackValue(n) as P
+				if (p === undefined) {
+					return { type, index, next }
+				}
+				const prev = unpackValue(p) as P
+				return { type, index, next, prev }
+			}
+			case `truncate`: {
+				const [l, ...i] = tail.split(`\u001E`)
+				const length = +l
+				const items = i.map(unpackValue) as P[]
+				return { type, length, items }
+			}
+			case `extend`: {
+				const [n, p] = tail.split(`\u001E`)
+				const next = +n
+				const prev = +p
+				return { type, next, prev }
+			}
+			case `pop`:
+			case `shift`:
+				if (tail !== ``) {
+					const value = unpackValue(tail) as P
+					return { type, value }
+				}
+				return { type }
+			case `push`:
+			case `unshift`: {
+				const items = tail.split(`\u001E`).map(unpackValue) as P[]
+				return { type, items }
+			}
+			case `copyWithin`: {
+				const [numbers, data] = tail.split(`\u001E\u001E`)
+				const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
+				const [t, s, e] = numbers.split(`\u001E`)
+				const target = +t
+				const start = +s
+				if (e === undefined) {
+					return { type, target, start, prev }
+				}
+				const end = +e
+				return { type, target, start, prev, end }
+			}
+			case `fill`: {
+				const [numbers, data] = tail.split(`\u001E\u001E`)
+				const prev = data ? (data.split(`\u001E`).map(unpackValue) as P[]) : []
+				const [v, s, e] = numbers.split(`\u001E`)
+				const value = unpackValue(v) as P
+				if (s === undefined && e === undefined) {
+					return { type, value, prev }
+				}
+				const start = +s
+				if (e === undefined) {
+					return { type, value, prev, start }
+				}
+				const end = +e
+				return { type, value, prev, start, end }
+			}
+			case `splice`: {
+				const [s, c, i, d] = tail.split(`\u001E\u001E`)
+
+				const start = +s
+				const deleteCount = +c
+				const items = i ? (i.split(`\u001E`).map(unpackValue) as P[]) : []
+				const deleted = d ? (d.split(`\u001E`).map(unpackValue) as P[]) : []
+				return { type, start, deleteCount, items, deleted }
+			}
+			case `reverse`:
+				return { type }
+			case `sort`: {
+				const [n, p] = tail.split(`\u001E\u001E`)
+				const next = n ? (n.split(`\u001E`).map(unpackValue) as P[]) : []
+				const prev = p ? (p.split(`\u001E`).map(unpackValue) as P[]) : []
+				return { type, next, prev }
+			}
+		}
+	}
 }

package/src/transceivers/set-rtx/set-rtx.ts

@@ -12,6 +12,10 @@ export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 	readonly cacheLimit: number
 	readonly cacheIdx: number
 	readonly cacheUpdateNumber: number
+	readonly subscribe: (
+		key: string,
+		fn: (update: NumberedSetUpdateString) => void,
+	) => () => void
 }
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {

package/src/transceivers/u-list/u-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type SetMutations = Exclude<
 	keyof Set<any>,
@@ -32,33 +29,19 @@ export type PackedSetUpdate<P extends primitive> = string & {
 export const SET_UPDATE_ENUM: Enumeration<[`add`, `delete`, `clear`]> =
 	enumeration([`add`, `delete`, `clear`] as const)
 
-export function packSetUpdate<P extends primitive>(
-	update: SetUpdate<P>,
-): PackedSetUpdate<P> {
-	const head = SET_UPDATE_ENUM[update.type] + `\u001F`
-	if (update.type === `clear`) {
-		return head + update.values.map(packValue).join(`\u001E`)
-	}
-	return head + packValue(update.value)
-}
-export function unpackSetUpdate<P extends primitive>(
-	packed: PackedSetUpdate<P>,
-): SetUpdate<P> {
-	const [type, tail] = packed.split(`\u001F`) as [0 | 1 | 2, string]
-	const head = SET_UPDATE_ENUM[type]
-	if (head === `clear`) {
-		const values = tail.split(`\u001E`).map(unpackValue) as P[]
-		return { type: `clear`, values }
-	}
-	return { type: head, value: unpackValue(tail) as P }
-}
-
 export type SetMutationHandler = { [K in UListUpdateType]: Fn }
 
+export type UListView<P extends primitive> = ReadonlySet<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedSetUpdate<P>) => void,
+	) => () => void
+}
+
 export class UList<P extends primitive>
 	extends Set<P>
 	implements
-		Transceiver<ReadonlySet<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<UListView<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
 		SetMutationHandler
 {
 	public mode: TransceiverMode = `record`
@@ -70,7 +53,7 @@ export class UList<P extends primitive>
 		}
 	}
 
-	public readonly READONLY_VIEW: ReadonlySet<P> = this
+	public readonly READONLY_VIEW: UListView<P> = this
 
 	public toJSON(): ReadonlyArray<P> {
 		return [...this]
@@ -112,12 +95,12 @@ export class UList<P extends primitive>
 	}
 
 	public emit(update: SetUpdate<P>): void {
-		this.subject.next(packSetUpdate(update))
+		this.subject.next(UList.packUpdate(update))
 	}
 
 	public do(packed: PackedSetUpdate<P>): null {
 		this.mode = `playback`
-		const update = unpackSetUpdate(packed)
+		const update = UList.unpackUpdate(packed)
 		switch (update.type) {
 			case `add`:
 				this.add(update.value)
@@ -133,7 +116,7 @@ export class UList<P extends primitive>
 	}
 
 	public undo(packed: PackedSetUpdate<P>): number | null {
-		const update = unpackSetUpdate(packed)
+		const update = UList.unpackUpdate(packed)
 		this.mode = `playback`
 		switch (update.type) {
 			case `add`:
@@ -150,4 +133,25 @@ export class UList<P extends primitive>
 		this.mode = `record`
 		return null
 	}
+
+	public static packUpdate<P extends primitive>(
+		update: SetUpdate<P>,
+	): PackedSetUpdate<P> {
+		const head = SET_UPDATE_ENUM[update.type] + `\u001F`
+		if (update.type === `clear`) {
+			return head + update.values.map(packValue).join(`\u001E`)
+		}
+		return head + packValue(update.value)
+	}
+	public static unpackUpdate<P extends primitive>(
+		packed: PackedSetUpdate<P>,
+	): SetUpdate<P> {
+		const [type, tail] = packed.split(`\u001F`) as [0 | 1 | 2, string]
+		const head = SET_UPDATE_ENUM[type]
+		if (head === `clear`) {
+			const values = tail.split(`\u001E`).map(unpackValue) as P[]
+			return { type: `clear`, values }
+		}
+		return { type: head, value: unpackValue(tail) as P }
+	}
 }