atom.io 0.40.9 → 0.41.0

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

@@ -4,11 +4,11 @@ import type { Json, primitive } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 export type SetUpdateType = `add` | `clear` | `del` | `tx`
-export type SetUpdate = `${SetUpdateType}:${string}`
-export type NumberedSetUpdate = `${number | `*`}=${SetUpdate}`
+export type SetUpdateString = `${SetUpdateType}:${string}`
+export type NumberedSetUpdateString = `${number | `*`}=${SetUpdateString}`
 
 export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
-	readonly cache: ReadonlyArray<NumberedSetUpdate | null>
+	readonly cache: ReadonlyArray<NumberedSetUpdateString | null>
 	readonly cacheLimit: number
 	readonly cacheIdx: number
 	readonly cacheUpdateNumber: number
@@ -16,7 +16,7 @@ export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {
 	members: P[]
-	cache: (NumberedSetUpdate | null)[]
+	cache: (NumberedSetUpdateString | null)[]
 	cacheLimit: number
 	cacheIdx: number
 	cacheUpdateNumber: number
@@ -24,13 +24,14 @@ export interface SetRTXJson<P extends primitive> extends Json.Object {
 export class SetRTX<P extends primitive>
 	extends Set<P>
 	implements
-		Transceiver<SetRTXView<P>, NumberedSetUpdate, SetRTXJson<P>>,
+		Transceiver<SetRTXView<P>, NumberedSetUpdateString, SetRTXJson<P>>,
 		Lineage
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject: Subject<SetUpdate> = new Subject<SetUpdate>()
+	public readonly subject: Subject<SetUpdateString> =
+		new Subject<SetUpdateString>()
 	public cacheLimit = 0
-	public cache: (NumberedSetUpdate | null)[] = []
+	public cache: (NumberedSetUpdateString | null)[] = []
 	public cacheIdx = -1
 	public cacheUpdateNumber = -1
 
@@ -100,7 +101,7 @@ export class SetRTX<P extends primitive>
 
 	public readonly parent: SetRTX<P> | null = null
 	public child: SetRTX<P> | null = null
-	public transactionUpdates: SetUpdate[] | null = null
+	public transactionUpdates: SetUpdateString[] | null = null
 	public transaction(run: (child: SetRTX<P>) => boolean): void {
 		this.mode = `transaction`
 		this.transactionUpdates = []
@@ -134,24 +135,24 @@ export class SetRTX<P extends primitive>
 
 	protected _subscribe(
 		key: string,
-		fn: (update: SetUpdate) => void,
+		fn: (update: SetUpdateString) => void,
 	): () => void {
 		return this.subject.subscribe(key, fn)
 	}
 	public subscribe(
 		key: string,
-		fn: (update: NumberedSetUpdate) => void,
+		fn: (update: NumberedSetUpdateString) => void,
 	): () => void {
 		return this.subject.subscribe(key, (update) => {
 			fn(`${this.cacheUpdateNumber}=${update}`)
 		})
 	}
 
-	public emit(update: SetUpdate): void {
+	public emit(update: SetUpdateString): void {
 		this.subject.next(update)
 	}
 
-	private doStep(update: SetUpdate): void {
+	private doStep(update: SetUpdateString): void {
 		const typeValueBreak = update.indexOf(`:`)
 		const type = update.substring(0, typeValueBreak) as SetUpdateType
 		const value = update.substring(typeValueBreak + 1)
@@ -167,17 +168,17 @@ export class SetRTX<P extends primitive>
 				break
 			case `tx`:
 				for (const subUpdate of value.split(`;`)) {
-					this.doStep(subUpdate as SetUpdate)
+					this.doStep(subUpdate as SetUpdateString)
 				}
 		}
 	}
 
-	public getUpdateNumber(update: NumberedSetUpdate): number {
+	public getUpdateNumber(update: NumberedSetUpdateString): number {
 		const breakpoint = update.indexOf(`=`)
 		return Number(update.substring(0, breakpoint))
 	}
 
-	public do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null {
+	public do(update: NumberedSetUpdateString): number | `OUT_OF_RANGE` | null {
 		const breakpoint = update.indexOf(`=`)
 		const updateNumber = Number(update.substring(0, breakpoint))
 		const eventOffset = updateNumber - this.cacheUpdateNumber
@@ -185,7 +186,7 @@ export class SetRTX<P extends primitive>
 		if (isFuture || Number.isNaN(eventOffset)) {
 			if (eventOffset === 1 || Number.isNaN(eventOffset)) {
 				this.mode = `playback`
-				const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+				const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 				this.doStep(innerUpdate)
 				this.mode = `record`
 				this.cacheUpdateNumber = updateNumber
@@ -211,7 +212,7 @@ export class SetRTX<P extends primitive>
 				this.undo(u)
 				done = this.cacheIdx === eventIdx - 1
 			}
-			const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+			const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 			this.doStep(innerUpdate)
 			this.mode = `record`
 			this.cacheUpdateNumber = updateNumber
@@ -220,7 +221,7 @@ export class SetRTX<P extends primitive>
 		return `OUT_OF_RANGE`
 	}
 
-	public undoStep(update: SetUpdate): void {
+	public undoStep(update: SetUpdateString): void {
 		const breakpoint = update.indexOf(`:`)
 		const type = update.substring(0, breakpoint) as SetUpdateType
 		const value = update.substring(breakpoint + 1)
@@ -237,7 +238,7 @@ export class SetRTX<P extends primitive>
 				break
 			}
 			case `tx`: {
-				const updates = value.split(`;`) as SetUpdate[]
+				const updates = value.split(`;`) as SetUpdateString[]
 				for (let i = updates.length - 1; i >= 0; i--) {
 					this.undoStep(updates[i])
 				}
@@ -245,12 +246,12 @@ export class SetRTX<P extends primitive>
 		}
 	}
 
-	public undo(update: NumberedSetUpdate): number | null {
+	public undo(update: NumberedSetUpdateString): number | null {
 		const breakpoint = update.indexOf(`=`)
 		const updateNumber = Number(update.substring(0, breakpoint))
 		if (updateNumber === this.cacheUpdateNumber) {
 			this.mode = `playback`
-			const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
+			const innerUpdate = update.substring(breakpoint + 1) as SetUpdateString
 			this.undoStep(innerUpdate)
 			this.mode = `record`
 			this.cacheUpdateNumber--

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

@@ -1,24 +1,68 @@
-import type { Transceiver, TransceiverMode } from "atom.io/internal"
-import { Subject } from "atom.io/internal"
-import type { Json, primitive, stringified } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
-
-export type UListUpdateType = `add` | `clear` | `del`
-export type UListUpdate<P extends primitive> =
-	| `${`add` | `del`}:${stringified<P>}`
-	| `clear:${stringified<P[]>}`
-
-export interface UListJson<P extends primitive> extends Json.Object {
-	members: P[]
+import type {
+	Enumeration,
+	Fn,
+	Transceiver,
+	TransceiverMode,
+} from "atom.io/internal"
+import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { primitive } from "atom.io/json"
+
+export type SetMutations = Exclude<
+	keyof Set<any>,
+	symbol | keyof ReadonlySet<any>
+>
+export type SetUpdate<P extends primitive> =
+	| {
+			type: `add` | `delete`
+			value: P
+	  }
+	| {
+			type: `clear`
+			values: P[]
+	  }
+export type UListUpdateType = SetUpdate<any>[`type`]
+true satisfies SetMutations extends UListUpdateType
+	? true
+	: Exclude<SetMutations, UListUpdateType>
+
+export type PackedSetUpdate<P extends primitive> = string & {
+	update?: SetUpdate<P>
+}
+
+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 class UList<P extends primitive>
 	extends Set<P>
-	implements Transceiver<ReadonlySet<P>, UListUpdate<P>, UListJson<P>>
+	implements
+		Transceiver<ReadonlySet<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
+		SetMutationHandler
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject: Subject<UListUpdate<P>> = new Subject<
-		UListUpdate<P>
-	>()
+	public readonly subject: Subject<PackedSetUpdate<P>> = new Subject()
 
 	public constructor(values?: Iterable<P>) {
 		super(values)
@@ -28,20 +72,18 @@ export class UList<P extends primitive>
 
 	public readonly READONLY_VIEW: ReadonlySet<P> = this
 
-	public toJSON(): UListJson<P> {
-		return {
-			members: [...this],
-		}
+	public toJSON(): ReadonlyArray<P> {
+		return [...this]
 	}
 
-	public static fromJSON<P extends primitive>(json: UListJson<P>): UList<P> {
-		return new UList<P>(json.members)
+	public static fromJSON<P extends primitive>(json: ReadonlyArray<P>): UList<P> {
+		return new UList<P>(json)
 	}
 
 	public add(value: P): this {
 		const result = super.add(value)
 		if (this.mode === `record`) {
-			this.emit(`add:${stringifyJson<P>(value)}`)
+			this.emit({ type: `add`, value })
 		}
 		return result
 	}
@@ -50,73 +92,61 @@ export class UList<P extends primitive>
 		const capturedContents = this.mode === `record` ? [...this] : null
 		super.clear()
 		if (capturedContents) {
-			this.emit(`clear:${stringifyJson(capturedContents)}`)
+			this.emit({ type: `clear`, values: capturedContents })
 		}
 	}
 
 	public delete(value: P): boolean {
 		const result = super.delete(value)
 		if (this.mode === `record`) {
-			this.emit(`del:${stringifyJson<P>(value)}`)
+			this.emit({ type: `delete`, value })
 		}
 		return result
 	}
 
 	public subscribe(
 		key: string,
-		fn: (update: UListUpdate<P>) => void,
+		fn: (update: PackedSetUpdate<P>) => void,
 	): () => void {
 		return this.subject.subscribe(key, fn)
 	}
 
-	public emit(update: UListUpdate<P>): void {
-		this.subject.next(update)
+	public emit(update: SetUpdate<P>): void {
+		this.subject.next(packSetUpdate(update))
 	}
 
-	private doStep(update: UListUpdate<P>): void {
-		const typeValueBreak = update.indexOf(`:`)
-		const type = update.substring(0, typeValueBreak) as UListUpdateType
-		const value = update.substring(typeValueBreak + 1)
-		switch (type) {
+	public do(packed: PackedSetUpdate<P>): null {
+		this.mode = `playback`
+		const update = unpackSetUpdate(packed)
+		switch (update.type) {
 			case `add`:
-				this.add(JSON.parse(value))
+				this.add(update.value)
 				break
-			case `del`:
-				this.delete(JSON.parse(value))
+			case `delete`:
+				this.delete(update.value)
 				break
 			case `clear`:
 				this.clear()
 		}
-	}
-
-	public do(update: UListUpdate<P>): null {
-		this.mode = `playback`
-		this.doStep(update)
 		this.mode = `record`
 		return null
 	}
 
-	public undoStep(update: UListUpdate<P>): void {
-		const breakpoint = update.indexOf(`:`)
-		const type = update.substring(0, breakpoint) as UListUpdateType
-		const value = update.substring(breakpoint + 1)
-		switch (type) {
+	public undo(packed: PackedSetUpdate<P>): number | null {
+		const update = unpackSetUpdate(packed)
+		this.mode = `playback`
+		switch (update.type) {
 			case `add`:
-				this.delete(JSON.parse(value))
+				this.delete(update.value)
 				break
-			case `del`:
-				this.add(JSON.parse(value))
+			case `delete`:
+				this.add(update.value)
 				break
 			case `clear`: {
-				const values = JSON.parse(value) as P[]
+				const values = update.values
 				for (const v of values) this.add(v)
 			}
 		}
-	}
-
-	public undo(update: UListUpdate<P>): number | null {
-		this.mode = `playback`
-		this.undoStep(update)
 		this.mode = `record`
 		return null
 	}