atom.io 0.40.8 → 0.40.10

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

@@ -0,0 +1,412 @@
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
+import type { primitive } from "atom.io/json"
+
+type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
+export type ArrayUpdate<P extends primitive> =
+	| {
+			type: `copyWithin`
+			target: number
+			start: number
+			end?: number
+			prev: readonly P[]
+	  }
+	| {
+			type: `extend`
+			next: number
+			prev: number
+	  }
+	| {
+			type: `fill`
+			value: P
+			start?: number
+			end?: number
+			prev: readonly P[]
+	  }
+	| {
+			type: `pop` | `shift`
+			value?: P
+	  }
+	| {
+			type: `push` | `unshift`
+			items: readonly P[]
+	  }
+	| {
+			type: `reverse`
+	  }
+	| {
+			type: `set`
+			next: P
+			prev?: P
+			index: number
+	  }
+	| {
+			type: `sort`
+			next: readonly P[]
+			prev: readonly P[]
+	  }
+	| {
+			type: `splice`
+			start: number
+			deleteCount?: number
+			items?: readonly P[]
+			deleted?: readonly P[]
+	  }
+	| {
+			type: `truncate`
+			length: number
+			items: readonly P[]
+	  }
+export type OListUpdateType = ArrayUpdate<any>[`type`]
+true satisfies ArrayMutations extends OListUpdateType
+	? true
+	: Exclude<ArrayMutations, OListUpdateType>
+
+export type ArrayMutationHandler = {
+	[K in Exclude<OListUpdateType, `extend` | `set` | `truncate`>]: Fn
+}
+
+export class OList<P extends primitive>
+	extends Array<P>
+	implements
+		Transceiver<ReadonlyArray<P>, ArrayUpdate<P>, ReadonlyArray<P>>,
+		ArrayMutationHandler
+{
+	public mode: TransceiverMode = `record`
+	public readonly subject: Subject<ArrayUpdate<P>> = new Subject<
+		ArrayUpdate<P>
+	>()
+
+	public readonly READONLY_VIEW: ReadonlyArray<P> = this
+
+	public constructor(arrayLength?: number)
+	public constructor(...items: P[])
+	public constructor(...items: P[]) {
+		super(...items)
+		// biome-ignore lint/correctness/noConstructorReturn: this is chill
+		return new Proxy(this, {
+			set: (target, prop, value, receiver) => {
+				if (
+					typeof prop === `string` &&
+					!Number.isNaN(Number.parseInt(prop, 10))
+				) {
+					const index = Number(prop)
+					let prev: P | undefined
+					if (this.mode === `record`) {
+						prev = target[index]
+					}
+					target[index] = value
+					if (prev) {
+						this.emit({ type: `set`, index, next: value, prev })
+					} else if (this.mode === `record`) {
+						this.emit({ type: `set`, index, next: value })
+					}
+					return true
+				}
+				if (prop === `length`) {
+					if (this.mode === `record`) {
+						const prevLength = target.length
+						if (prevLength === value) return true
+						if (prevLength > value) {
+							const dropped = target.slice(value)
+							target.length = value
+							this.emit({ type: `truncate`, length: value, items: dropped })
+						} else {
+							target.length = value
+							this.emit({ type: `extend`, next: value, prev: prevLength })
+						}
+					} else {
+						target.length = value
+					}
+					return true
+				}
+				return Reflect.set(target, prop, value, receiver)
+			},
+		})
+	}
+
+	public toJSON(): ReadonlyArray<P> {
+		return [...this]
+	}
+
+	public static fromJSON<P extends primitive>(json: ReadonlyArray<P>): OList<P> {
+		return new OList<P>(...json)
+	}
+
+	public push(...items: P[]): number {
+		let result: number
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			result = super.push(...items)
+			this.mode = `record`
+			this.emit({ type: `push`, items })
+		} else {
+			result = super.push(...items)
+		}
+		return result
+	}
+	public pop(): P | undefined {
+		let value: P | undefined
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			value = super.pop()
+			if (value === undefined) {
+				this.emit({ type: `pop` })
+			} else {
+				this.emit({ type: `pop`, value })
+			}
+			this.mode = `record`
+		} else {
+			value = super.pop()
+		}
+		return value
+	}
+	public shift(): P | undefined {
+		let value: P | undefined
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			value = super.shift()
+			if (value === undefined) {
+				this.emit({ type: `shift` })
+			} else {
+				this.emit({ type: `shift`, value })
+			}
+			this.mode = `record`
+		} else {
+			value = super.shift()
+		}
+		return value
+	}
+	public unshift(...items: P[]): number {
+		let result: number
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			result = super.unshift(...items)
+			this.emit({ type: `unshift`, items })
+			this.mode = `record`
+		} else {
+			result = super.unshift(...items)
+		}
+		return result
+	}
+
+	public reverse(): this {
+		super.reverse()
+		if (this.mode === `record`) {
+			this.emit({ type: `reverse` })
+		}
+		return this
+	}
+
+	public sort(compareFn?: (a: P, b: P) => number): this {
+		if (this.mode === `record`) {
+			this.mode = `playback`
+			const prev = [...this]
+			super.sort(compareFn)
+			const next = [...this]
+			this.emit({ type: `sort`, next, prev })
+			this.mode = `record`
+		}
+		return this
+	}
+
+	public splice(start: number, deleteCount?: number): P[]
+	public splice(start: number, deleteCount: number, ...items: P[]): P[]
+	public splice(
+		...params: [start: number, deleteCount?: number, ...items: P[]]
+	): P[] {
+		const [start, deleteCount, ...items] = params
+		const originalMode = this.mode
+		if (originalMode === `record`) this.mode = `playback`
+		const deleted = super.splice(...(params as [number, number, ...P[]]))
+		if (originalMode === `record`) this.mode = `record`
+		if (deleteCount === undefined) {
+			this.emit({
+				type: `splice`,
+				start,
+				items,
+				deleted,
+				deleteCount: deleted.length,
+			})
+		} else {
+			this.emit({ type: `splice`, start, items, deleted, deleteCount })
+		}
+
+		return deleted
+	}
+
+	public copyWithin(target: number, start: number, end?: number): this {
+		const originalMode = this.mode
+		let prev: P[] | undefined
+		if (originalMode === `record`) {
+			prev = this.slice(target)
+			this.mode = `playback`
+		}
+		super.copyWithin(target, start, end)
+		if (originalMode === `record`) this.mode = `record`
+		if (prev) {
+			if (end === undefined) {
+				this.emit({ type: `copyWithin`, prev, target, start })
+			} else {
+				this.emit({ type: `copyWithin`, prev, target, start, end })
+			}
+		}
+		return this
+	}
+
+	public subscribe(
+		key: string,
+		fn: (update: ArrayUpdate<P>) => void,
+	): () => void {
+		return this.subject.subscribe(key, fn)
+	}
+
+	public emit(update: ArrayUpdate<P>): void {
+		this.subject.next(update)
+	}
+
+	private doStep(update: ArrayUpdate<P>): void {
+		const type = update.type
+		switch (type) {
+			case `copyWithin`:
+				this.copyWithin(update.target, update.start, update.end)
+				break
+			case `extend`:
+				this.length = update.next
+				break
+			case `fill`:
+				this.fill(update.value, update.start, update.end)
+				break
+			case `pop`:
+				this.pop()
+				break
+			case `push`:
+				this.push(...update.items)
+				break
+			case `reverse`:
+				this.reverse()
+				break
+			case `shift`:
+				this.shift()
+				break
+			case `sort`:
+				for (let i = 0; i < update.next.length; i++) {
+					this[i] = update.next[i]
+				}
+				this.length = update.next.length
+				break
+			case `splice`:
+				if (update.deleteCount !== undefined && update.items) {
+					this.splice(update.start, update.deleteCount, ...update.items)
+				} else {
+					this.splice(update.start)
+				}
+				break
+			case `truncate`:
+				this.length = update.length
+				break
+			case `set`:
+				this[update.index] = update.next
+				break
+			case `unshift`:
+				this.unshift(...update.items)
+				break
+		}
+	}
+
+	public do(update: ArrayUpdate<P>): null {
+		this.mode = `playback`
+		this.doStep(update)
+		this.mode = `record`
+		return null
+	}
+
+	public undoStep(update: ArrayUpdate<P>): void {
+		switch (update.type) {
+			case `copyWithin`:
+				for (let i = 0; i < update.prev.length; i++) {
+					this[i + update.target] = update.prev[i]
+				}
+				break
+			case `extend`:
+				this.length = update.prev
+				break
+			case `fill`:
+				{
+					const start = update.start ?? 0
+					for (let i = 0; i < update.prev.length; i++) {
+						this[i + start] = update.prev[i]
+					}
+				}
+				break
+			case `pop`:
+				if (update.value) this.push(update.value)
+				break
+			case `push`:
+				{
+					let i = update.items.length - 1
+					while (i >= 0) {
+						this.pop()
+						--i
+					}
+				}
+				break
+			case `reverse`:
+				this.reverse()
+				break
+			case `shift`:
+				if (update.value) this.unshift(update.value)
+				break
+			case `sort`:
+				for (let i = 0; i < update.prev.length; i++) {
+					this[i] = update.prev[i]
+				}
+				this.length = update.prev.length
+				break
+			case `set`:
+				if (update.prev) {
+					this[update.index] = update.prev
+				} else {
+					// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+					delete this[update.index]
+					const firstEmptyIndex = this.findIndex(
+						(_, i) => !Object.hasOwn(this, i),
+					)
+					if (firstEmptyIndex !== -1) {
+						this.length = firstEmptyIndex
+					}
+				}
+				break
+			case `splice`:
+				if (update.deleted) {
+					if (update.items) {
+						this.splice(update.start, update.items.length, ...update.deleted)
+					} else {
+						this.splice(update.start, 0, ...update.deleted)
+					}
+				} else if (update.items) {
+					this.splice(update.start, update.items.length)
+				}
+				break
+			case `truncate`:
+				this.push(...update.items)
+				break
+			case `unshift`:
+				{
+					let i = update.items.length - 1
+					while (i >= 0) {
+						this.shift()
+						--i
+					}
+				}
+				break
+		}
+	}
+
+	public undo(update: ArrayUpdate<P>): number | null {
+		this.mode = `playback`
+		this.undoStep(update)
+		this.mode = `record`
+		return null
+	}
+}

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

@@ -5,7 +5,7 @@ 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 NumberedSetUpdate = `${number | `*`}=${SetUpdate}`
 
 export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 	readonly cache: ReadonlyArray<NumberedSetUpdate | null>
@@ -182,8 +182,8 @@ export class SetRTX<P extends primitive>
 		const updateNumber = Number(update.substring(0, breakpoint))
 		const eventOffset = updateNumber - this.cacheUpdateNumber
 		const isFuture = eventOffset > 0
-		if (isFuture) {
-			if (eventOffset === 1) {
+		if (isFuture || Number.isNaN(eventOffset)) {
+			if (eventOffset === 1 || Number.isNaN(eventOffset)) {
 				this.mode = `playback`
 				const innerUpdate = update.substring(breakpoint + 1) as SetUpdate
 				this.doStep(innerUpdate)

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

@@ -0,0 +1 @@
+export * from "./u-list"

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

@@ -0,0 +1,123 @@
+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[]
+}
+export class UList<P extends primitive>
+	extends Set<P>
+	implements Transceiver<ReadonlySet<P>, UListUpdate<P>, UListJson<P>>
+{
+	public mode: TransceiverMode = `record`
+	public readonly subject: Subject<UListUpdate<P>> = new Subject<
+		UListUpdate<P>
+	>()
+
+	public constructor(values?: Iterable<P>) {
+		super(values)
+		if (values instanceof UList) {
+		}
+	}
+
+	public readonly READONLY_VIEW: ReadonlySet<P> = this
+
+	public toJSON(): UListJson<P> {
+		return {
+			members: [...this],
+		}
+	}
+
+	public static fromJSON<P extends primitive>(json: UListJson<P>): UList<P> {
+		return new UList<P>(json.members)
+	}
+
+	public add(value: P): this {
+		const result = super.add(value)
+		if (this.mode === `record`) {
+			this.emit(`add:${stringifyJson<P>(value)}`)
+		}
+		return result
+	}
+
+	public clear(): void {
+		const capturedContents = this.mode === `record` ? [...this] : null
+		super.clear()
+		if (capturedContents) {
+			this.emit(`clear:${stringifyJson(capturedContents)}`)
+		}
+	}
+
+	public delete(value: P): boolean {
+		const result = super.delete(value)
+		if (this.mode === `record`) {
+			this.emit(`del:${stringifyJson<P>(value)}`)
+		}
+		return result
+	}
+
+	public subscribe(
+		key: string,
+		fn: (update: UListUpdate<P>) => void,
+	): () => void {
+		return this.subject.subscribe(key, fn)
+	}
+
+	public emit(update: UListUpdate<P>): void {
+		this.subject.next(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) {
+			case `add`:
+				this.add(JSON.parse(value))
+				break
+			case `del`:
+				this.delete(JSON.parse(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) {
+			case `add`:
+				this.delete(JSON.parse(value))
+				break
+			case `del`:
+				this.add(JSON.parse(value))
+				break
+			case `clear`: {
+				const values = JSON.parse(value) as P[]
+				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
+	}
+}

package/dist/employ-socket-D6wgByWh.js

@@ -1,12 +0,0 @@
-//#region src/realtime-server/employ-socket.ts
-function employSocket(socket, event, handleEvent) {
-	socket.on(event, handleEvent);
-	const retireSocket = () => {
-		socket.off(event, handleEvent);
-	};
-	return retireSocket;
-}
-
-//#endregion
-export { employSocket };
-//# sourceMappingURL=employ-socket-D6wgByWh.js.map

package/dist/employ-socket-D6wgByWh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"employ-socket-D6wgByWh.js","names":[],"sources":["../src/realtime-server/employ-socket.ts"],"sourcesContent":["import type { Events } from \"./ipc-sockets\"\nimport type { Socket } from \"./socket-interface\"\n\nexport function employSocket<I extends Events, K extends string & keyof I>(\n\tsocket: Socket,\n\tevent: K,\n\thandleEvent: (...data: I[K]) => void,\n): () => void {\n\tsocket.on(event, handleEvent)\n\tconst retireSocket = () => {\n\t\tsocket.off(event, handleEvent)\n\t}\n\treturn retireSocket\n}\n"],"mappings":";AAGA,SAAgB,aACf,QACA,OACA,aACa;AACb,QAAO,GAAG,OAAO,YAAY;CAC7B,MAAM,qBAAqB;AAC1B,SAAO,IAAI,OAAO,YAAY;;AAE/B,QAAO"}