openrtc-netcode 0.1.0

package/dist/events.d.ts

@@ -0,0 +1,6 @@
+export declare class TypedEmitter<TEvents extends object> {
+    private readonly listeners;
+    on<K extends keyof TEvents>(event: K, handler: (payload: TEvents[K]) => void): () => void;
+    emit<K extends keyof TEvents>(event: K, payload: TEvents[K]): void;
+    clear(): void;
+}

package/dist/events.js

@@ -0,0 +1,21 @@
+export class TypedEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, handler) {
+        const listeners = this.listeners.get(event) ?? new Set();
+        listeners.add(handler);
+        this.listeners.set(event, listeners);
+        return () => {
+            listeners.delete(handler);
+        };
+    }
+    emit(event, payload) {
+        for (const listener of this.listeners.get(event) ?? []) {
+            listener(payload);
+        }
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { OpenRtcNetcodeClient, createNetcode, shouldInitiateConnection, } from './client.js';
+export { ReplicatedObjectStore } from './objects.js';
+export { NETCODE_PROTOCOL, NETCODE_PROTOCOL_VERSION, decodeEnvelope, encodeEnvelope, isEnvelopeKind, } from './protocol.js';
+export type { HelloBody, MetadataBody, NetcodeEnvelope, NetcodeEnvelopeKind, ObjectRemoveBody, ObjectSnapshotBody, ObjectUpsertBody, StatePatchBody, StateSnapshotBody, UserMessageBody, VoiceSignalBody, } from './protocol.js';
+export type { CreateLobbyOptions, JoinLobbyOptions, NetVar, NetVarOptions, NetcodeClient, NetcodeEventHandler, NetcodeEventName, NetcodeEvents, NetcodeLobby, NetcodeMessage, NetcodeMessageHandler, NetcodeObjectChange, NetcodeObjectState, NetcodeObjectStore, NetcodeObjectUpsert, NetcodeOptions, NetcodePeer, NetcodePeerStats, NetcodePhysicsState, NetcodeQuaternion, NetcodeReliability, NetcodeRuntime, NetcodeState, NetcodeTransform, NetcodeVector3, NetcodeVoice, NetcodeVoiceEvents, NetcodeVoiceOptions, NetcodeVoicePeer, NetcodeVoiceSignal, SendOptions, } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { OpenRtcNetcodeClient, createNetcode, shouldInitiateConnection, } from './client.js';
+export { ReplicatedObjectStore } from './objects.js';
+export { NETCODE_PROTOCOL, NETCODE_PROTOCOL_VERSION, decodeEnvelope, encodeEnvelope, isEnvelopeKind, } from './protocol.js';

package/dist/objects.d.ts

@@ -0,0 +1,28 @@
+import type { NetcodeObjectChange, NetcodeObjectStore, NetcodeObjectState, NetcodeObjectUpsert } from './types.js';
+type ObjectListener = (change: NetcodeObjectChange) => void;
+export declare class ReplicatedObjectStore implements NetcodeObjectStore {
+    private readonly localPeerId;
+    private readonly publishUpsert;
+    private readonly publishRemove;
+    private readonly objectsById;
+    private readonly listeners;
+    private nextObjectId;
+    constructor(localPeerId: () => string | null, publishUpsert: (object: NetcodeObjectState) => Promise<void>, publishRemove: (id: string) => Promise<void>);
+    list(): NetcodeObjectState[];
+    get(id: string): NetcodeObjectState | undefined;
+    snapshot(): Record<string, NetcodeObjectState>;
+    spawn(input: NetcodeObjectUpsert): Promise<NetcodeObjectState>;
+    upsert(input: NetcodeObjectUpsert): Promise<NetcodeObjectState>;
+    update(id: string, patch: Partial<Omit<NetcodeObjectState, 'id'>>): Promise<NetcodeObjectState>;
+    remove(id: string): Promise<void>;
+    onChange(listener: ObjectListener): () => void;
+    clear(): void;
+    applySnapshot(objects: Record<string, NetcodeObjectState>, from: string): void;
+    applyUpsert(object: NetcodeObjectState, from: string): void;
+    applyRemove(id: string, from: string): void;
+    private applyObject;
+    private createObjectId;
+    private emit;
+}
+export declare function isNetcodeObjectState(value: unknown): value is NetcodeObjectState;
+export {};

package/dist/objects.js

@@ -0,0 +1,187 @@
+export class ReplicatedObjectStore {
+    constructor(localPeerId, publishUpsert, publishRemove) {
+        this.localPeerId = localPeerId;
+        this.publishUpsert = publishUpsert;
+        this.publishRemove = publishRemove;
+        this.objectsById = new Map();
+        this.listeners = new Set();
+        this.nextObjectId = 0;
+    }
+    list() {
+        return Array.from(this.objectsById.values()).map(cloneObject);
+    }
+    get(id) {
+        const object = this.objectsById.get(id);
+        return object ? cloneObject(object) : undefined;
+    }
+    snapshot() {
+        const snapshot = {};
+        for (const [id, object] of this.objectsById) {
+            snapshot[id] = cloneObject(object);
+        }
+        return snapshot;
+    }
+    async spawn(input) {
+        return this.upsert({
+            ownerId: this.localPeerId() ?? 'local',
+            ...input,
+            id: input.id ?? this.createObjectId(input.kind),
+        });
+    }
+    async upsert(input) {
+        const previous = input.id ? this.objectsById.get(input.id) : undefined;
+        const object = normalizeObject({
+            ...previous,
+            ...input,
+            id: input.id ?? previous?.id ?? this.createObjectId(input.kind),
+            kind: input.kind ?? previous?.kind ?? 'object',
+            ownerId: input.ownerId ?? previous?.ownerId ?? this.localPeerId() ?? 'local',
+            transform: {
+                ...(previous?.transform ?? {}),
+                ...(input.transform ?? {}),
+            },
+            physics: {
+                ...(previous?.physics ?? {}),
+                ...(input.physics ?? {}),
+            },
+            metadata: {
+                ...(previous?.metadata ?? {}),
+                ...(input.metadata ?? {}),
+            },
+            updatedAt: input.updatedAt ?? Date.now(),
+        });
+        this.applyObject(object, 'local');
+        await this.publishUpsert(object);
+        return cloneObject(object);
+    }
+    async update(id, patch) {
+        const previous = this.objectsById.get(id);
+        if (!previous) {
+            throw new Error(`openrtc-netcode object does not exist: ${id}`);
+        }
+        return this.upsert({
+            ...patch,
+            id,
+            kind: patch.kind ?? previous.kind,
+            ownerId: patch.ownerId ?? previous.ownerId,
+            transform: {
+                ...previous.transform,
+                ...(patch.transform ?? {}),
+            },
+            physics: {
+                ...(previous.physics ?? {}),
+                ...(patch.physics ?? {}),
+            },
+            metadata: {
+                ...(previous.metadata ?? {}),
+                ...(patch.metadata ?? {}),
+            },
+        });
+    }
+    async remove(id) {
+        this.applyRemove(id, 'local');
+        await this.publishRemove(id);
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    clear() {
+        this.objectsById.clear();
+        this.emit({ type: 'snapshot', objects: [], from: 'local' });
+    }
+    applySnapshot(objects, from) {
+        for (const object of Object.values(objects)) {
+            this.applyObject(object, from);
+        }
+        this.emit({ type: 'snapshot', objects: this.list(), from });
+    }
+    applyUpsert(object, from) {
+        this.applyObject(object, from);
+    }
+    applyRemove(id, from) {
+        const existed = this.objectsById.delete(id);
+        if (existed) {
+            this.emit({ type: 'remove', id, from });
+        }
+    }
+    applyObject(input, from) {
+        const object = normalizeObject(input);
+        const previous = this.objectsById.get(object.id);
+        if (previous && previous.updatedAt > object.updatedAt) {
+            return;
+        }
+        this.objectsById.set(object.id, object);
+        this.emit({ type: 'upsert', object: cloneObject(object), from });
+    }
+    createObjectId(kind = 'object') {
+        const peerId = this.localPeerId() ?? 'local';
+        this.nextObjectId += 1;
+        return `${peerId}:${kind}:${this.nextObjectId}`;
+    }
+    emit(change) {
+        for (const listener of this.listeners) {
+            listener(change);
+        }
+    }
+}
+export function isNetcodeObjectState(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return typeof value.id === 'string'
+        && typeof value.kind === 'string'
+        && typeof value.ownerId === 'string'
+        && isRecord(value.transform)
+        && isVector3(value.transform.position)
+        && typeof value.updatedAt === 'number';
+}
+function normalizeObject(input) {
+    return {
+        id: input.id,
+        kind: input.kind,
+        ownerId: input.ownerId,
+        transform: {
+            position: normalizeVector3(input.transform.position),
+            rotation: input.transform.rotation ? normalizeQuaternion(input.transform.rotation) : undefined,
+            scale: input.transform.scale ? normalizeVector3(input.transform.scale) : undefined,
+        },
+        physics: input.physics ? {
+            linearVelocity: input.physics.linearVelocity ? normalizeVector3(input.physics.linearVelocity) : undefined,
+            angularVelocity: input.physics.angularVelocity ? normalizeVector3(input.physics.angularVelocity) : undefined,
+            sleeping: !!input.physics.sleeping,
+        } : undefined,
+        metadata: input.metadata ? { ...input.metadata } : {},
+        updatedAt: input.updatedAt,
+    };
+}
+function normalizeVector3(value) {
+    return {
+        x: finiteNumber(value?.x),
+        y: finiteNumber(value?.y),
+        z: finiteNumber(value?.z),
+    };
+}
+function normalizeQuaternion(value) {
+    return {
+        x: finiteNumber(value?.x),
+        y: finiteNumber(value?.y),
+        z: finiteNumber(value?.z),
+        w: finiteNumber(value?.w, 1),
+    };
+}
+function finiteNumber(value, fallback = 0) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function isVector3(value) {
+    return isRecord(value)
+        && typeof value.x === 'number'
+        && typeof value.y === 'number'
+        && typeof value.z === 'number';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function cloneObject(object) {
+    return JSON.parse(JSON.stringify(object));
+}

package/dist/protocol.d.ts

@@ -0,0 +1,50 @@
+export declare const NETCODE_PROTOCOL = "openrtc-netcode";
+export declare const NETCODE_PROTOCOL_VERSION = 1;
+export type NetcodeEnvelopeKind = 'hello' | 'peer' | 'user' | 'state.snapshot' | 'state.patch' | 'object.snapshot' | 'object.upsert' | 'object.remove' | 'lobby.meta' | 'member.meta' | 'voice.signal' | 'ping' | 'pong';
+export interface NetcodeEnvelope<TBody = unknown> {
+    protocol: typeof NETCODE_PROTOCOL;
+    v: typeof NETCODE_PROTOCOL_VERSION;
+    kind: NetcodeEnvelopeKind;
+    lobbyId: string;
+    from: string;
+    seq: number;
+    sentAt: number;
+    target?: string;
+    body: TBody;
+}
+export interface HelloBody {
+    peerId: string;
+    displayName?: string;
+}
+export interface UserMessageBody {
+    type: string;
+    payload: unknown;
+}
+export interface StateSnapshotBody {
+    values: Record<string, unknown>;
+    owners: Record<string, string>;
+}
+export interface StatePatchBody {
+    key: string;
+    value: unknown;
+    owner: string;
+}
+export interface ObjectSnapshotBody {
+    objects: Record<string, unknown>;
+}
+export interface ObjectUpsertBody {
+    object: unknown;
+}
+export interface ObjectRemoveBody {
+    id: string;
+}
+export interface MetadataBody {
+    values: Record<string, string>;
+}
+export interface VoiceSignalBody {
+    signal: unknown;
+}
+export declare function encodeEnvelope(envelope: NetcodeEnvelope): string;
+export declare function decodeEnvelope(value: unknown): NetcodeEnvelope | null;
+export declare function isEnvelopeKind(value: unknown): value is NetcodeEnvelopeKind;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/protocol.js

@@ -0,0 +1,53 @@
+export const NETCODE_PROTOCOL = 'openrtc-netcode';
+export const NETCODE_PROTOCOL_VERSION = 1;
+export function encodeEnvelope(envelope) {
+    return JSON.stringify(envelope);
+}
+export function decodeEnvelope(value) {
+    const candidate = typeof value === 'string' ? parseJson(value) : value;
+    if (!isRecord(candidate)) {
+        return null;
+    }
+    if (candidate.protocol !== NETCODE_PROTOCOL || candidate.v !== NETCODE_PROTOCOL_VERSION) {
+        return null;
+    }
+    if (!isEnvelopeKind(candidate.kind)) {
+        return null;
+    }
+    if (typeof candidate.lobbyId !== 'string'
+        || typeof candidate.from !== 'string'
+        || typeof candidate.seq !== 'number'
+        || typeof candidate.sentAt !== 'number') {
+        return null;
+    }
+    if ('target' in candidate && candidate.target !== undefined && typeof candidate.target !== 'string') {
+        return null;
+    }
+    return candidate;
+}
+export function isEnvelopeKind(value) {
+    return value === 'hello'
+        || value === 'peer'
+        || value === 'user'
+        || value === 'state.snapshot'
+        || value === 'state.patch'
+        || value === 'object.snapshot'
+        || value === 'object.upsert'
+        || value === 'object.remove'
+        || value === 'lobby.meta'
+        || value === 'member.meta'
+        || value === 'voice.signal'
+        || value === 'ping'
+        || value === 'pong';
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/state.d.ts

@@ -0,0 +1,16 @@
+import type { NetVar, NetVarOptions, NetcodeState } from './types.js';
+export declare class ReplicatedState implements NetcodeState {
+    private readonly resolveOwner;
+    private readonly publishPatch;
+    private readonly entries;
+    constructor(resolveOwner: (options?: NetVarOptions) => string, publishPatch: (key: string, value: unknown, owner: string) => Promise<void>);
+    define<T>(key: string, initial: T, options?: NetVarOptions): NetVar<T>;
+    get<T = unknown>(key: string): T | undefined;
+    snapshot(): Record<string, unknown>;
+    owners(): Record<string, string>;
+    replaceOwner(previousOwner: string, nextOwner: string): void;
+    applySnapshot(values: Record<string, unknown>, owners: Record<string, string>): void;
+    applyPatch(key: string, value: unknown, owner: string): void;
+    private applyRemoteValue;
+    private createNetVar;
+}

package/dist/state.js

@@ -0,0 +1,94 @@
+export class ReplicatedState {
+    constructor(resolveOwner, publishPatch) {
+        this.resolveOwner = resolveOwner;
+        this.publishPatch = publishPatch;
+        this.entries = new Map();
+    }
+    define(key, initial, options) {
+        const existing = this.entries.get(key);
+        if (existing) {
+            return this.createNetVar(existing);
+        }
+        const entry = {
+            key,
+            value: initial,
+            owner: this.resolveOwner(options),
+            listeners: new Set(),
+        };
+        this.entries.set(key, entry);
+        return this.createNetVar(entry);
+    }
+    get(key) {
+        return this.entries.get(key)?.value;
+    }
+    snapshot() {
+        const values = {};
+        for (const [key, entry] of this.entries) {
+            values[key] = entry.value;
+        }
+        return values;
+    }
+    owners() {
+        const values = {};
+        for (const [key, entry] of this.entries) {
+            values[key] = entry.owner;
+        }
+        return values;
+    }
+    replaceOwner(previousOwner, nextOwner) {
+        for (const entry of this.entries.values()) {
+            if (entry.owner === previousOwner) {
+                entry.owner = nextOwner;
+            }
+        }
+    }
+    applySnapshot(values, owners) {
+        for (const [key, value] of Object.entries(values)) {
+            this.applyRemoteValue(key, value, owners[key] ?? this.resolveOwner());
+        }
+    }
+    applyPatch(key, value, owner) {
+        this.applyRemoteValue(key, value, owner);
+    }
+    applyRemoteValue(key, value, owner) {
+        const existing = this.entries.get(key);
+        if (!existing) {
+            this.entries.set(key, {
+                key,
+                value,
+                owner,
+                listeners: new Set(),
+            });
+            return;
+        }
+        const previous = existing.value;
+        existing.value = value;
+        existing.owner = owner;
+        for (const listener of existing.listeners) {
+            listener(value, previous);
+        }
+    }
+    createNetVar(entry) {
+        return {
+            key: entry.key,
+            get owner() {
+                return entry.owner;
+            },
+            get value() {
+                return entry.value;
+            },
+            set: async (value) => {
+                const previous = entry.value;
+                entry.value = value;
+                for (const listener of entry.listeners) {
+                    listener(value, previous);
+                }
+                await this.publishPatch(entry.key, value, entry.owner);
+            },
+            onChange: (callback) => {
+                entry.listeners.add(callback);
+                return () => entry.listeners.delete(callback);
+            },
+        };
+    }
+}