@vgai/p2p-colyseus 0.5.2 → 0.5.4

package/src/codec.ts

@@ -1,78 +0,0 @@
-import type { StatePatch, StatePatchOperation } from './protocol';
-import { encodeSnapshotState } from './schema';
-
-export function encodeSnapshot(value: unknown): unknown {
-  return encodeSnapshotState(value);
-}
-
-export function createStatePatch(previous: unknown, next: unknown): StatePatch {
-  const operations: StatePatchOperation[] = [];
-  diffValue([], previous, next, operations);
-  return { type: 'patch', operations };
-}
-
-export function applyStatePatch(previous: unknown, patch: StatePatch): unknown {
-  const root = clone(previous);
-  for (const operation of patch.operations) {
-    if (operation.op === 'set') setPath(root, operation.path, operation.value);
-    else deletePath(root, operation.path);
-  }
-  return root;
-}
-
-export function clone<T>(value: T): T {
-  if (value === undefined) return value;
-  return JSON.parse(JSON.stringify(value)) as T;
-}
-
-function diffValue(
-  path: string[],
-  previous: unknown,
-  next: unknown,
-  operations: StatePatchOperation[],
-): void {
-  if (isRecord(previous) && isRecord(next)) {
-    for (const key of Object.keys(previous)) {
-      if (!(key in next)) operations.push({ op: 'delete', path: [...path, key] });
-    }
-    for (const [key, nextValue] of Object.entries(next)) {
-      diffValue([...path, key], previous[key], nextValue, operations);
-    }
-    return;
-  }
-
-  if (JSON.stringify(previous) !== JSON.stringify(next)) {
-    operations.push({ op: 'set', path, value: clone(next) });
-  }
-}
-
-function setPath(root: unknown, path: readonly string[], value: unknown): void {
-  if (path.length === 0) return;
-  const parent = parentAt(root, path);
-  parent[path[path.length - 1]!] = clone(value);
-}
-
-function deletePath(root: unknown, path: readonly string[]): void {
-  if (path.length === 0) return;
-  const parent = parentAt(root, path);
-  delete parent[path[path.length - 1]!];
-}
-
-function parentAt(root: unknown, path: readonly string[]): Record<string, unknown> {
-  if (!isRecord(root)) throw new Error('Cannot patch non-object state root');
-  let parent = root;
-  for (const segment of path.slice(0, -1)) {
-    const child = parent[segment];
-    if (!isRecord(child)) {
-      parent[segment] = {};
-      parent = parent[segment] as Record<string, unknown>;
-    } else {
-      parent = child;
-    }
-  }
-  return parent;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

package/src/replication.ts

@@ -1,164 +0,0 @@
-type AddHandler = (item: Record<string, unknown>, key: string) => void;
-type RemoveHandler = (item: Record<string, unknown>, key: string) => void;
-type ChangeHandler = () => void;
-type StateHandler = (state: Record<string, unknown>) => void;
-
-export class ClientReplication {
-  state: Record<string, unknown> = {};
-  private readonly collectionAdd = new Map<string, Set<AddHandler>>();
-  private readonly collectionRemove = new Map<string, Set<RemoveHandler>>();
-  private readonly itemChange = new WeakMap<object, Set<ChangeHandler>>();
-  private readonly stateChange = new Set<StateHandler>();
-
-  applySnapshot(next: unknown): void {
-    const incoming = isRecord(next) ? next : {};
-    this.mergeRoot(incoming);
-    for (const handler of [...this.stateChange]) handler(this.state);
-  }
-
-  onAdd(collection: string, handler: AddHandler): () => void {
-    const handlers = getSet(this.collectionAdd, collection);
-    handlers.add(handler);
-    const current = this.state[collection];
-    if (isRecord(current)) {
-      for (const [key, value] of Object.entries(current)) {
-        if (isRecord(value)) handler(value, key);
-      }
-    }
-    return () => handlers.delete(handler);
-  }
-
-  onRemove(collection: string, handler: RemoveHandler): () => void {
-    const handlers = getSet(this.collectionRemove, collection);
-    handlers.add(handler);
-    return () => handlers.delete(handler);
-  }
-
-  onChange(item: Record<string, unknown>, handler: ChangeHandler): () => void {
-    const handlers = this.itemChange.get(item) ?? new Set<ChangeHandler>();
-    handlers.add(handler);
-    this.itemChange.set(item, handlers);
-    return () => handlers.delete(handler);
-  }
-
-  /**
-   * Mirror `properties` of a replicated item onto `target` — immediately (when
-   * `immediate`, the default, matching the real SDK) and again on every change.
-   * Compat with @colyseus/sdk's `StateCallbacks.bindTo(from, to, props?, immediate?)`;
-   * returns the unbind function.
-   */
-  bindTo<TTarget extends Record<string, unknown>>(
-    from: Record<string, unknown>,
-    to: TTarget,
-    properties?: readonly string[],
-    immediate = true,
-  ): () => void {
-    const copy = () => {
-      const keys = properties ?? Object.keys(from).filter((key) => typeof from[key] !== 'function');
-      for (const key of keys) {
-        (to as Record<string, unknown>)[key] = from[key];
-      }
-    };
-    if (immediate) copy();
-    return this.onChange(from, copy);
-  }
-
-  onStateChange(handler: StateHandler): () => void {
-    this.stateChange.add(handler);
-    return () => this.stateChange.delete(handler);
-  }
-
-  private mergeRoot(incoming: Record<string, unknown>): void {
-    for (const key of Object.keys(this.state)) {
-      if (!(key in incoming)) delete this.state[key];
-    }
-
-    for (const [key, value] of Object.entries(incoming)) {
-      const current = this.state[key];
-      if (isRecord(value) && isCollectionRecord(value)) {
-        this.state[key] = this.mergeCollection(key, isRecord(current) ? current : {}, value);
-      } else if (isRecord(value)) {
-        this.state[key] = mergeRecord(isRecord(current) ? current : {}, value, this.itemChange);
-      } else {
-        this.state[key] = value;
-      }
-    }
-  }
-
-  private mergeCollection(
-    collection: string,
-    current: Record<string, unknown>,
-    incoming: Record<string, unknown>,
-  ): Record<string, unknown> {
-    const removeHandlers = this.collectionRemove.get(collection);
-    for (const key of Object.keys(current)) {
-      if (!(key in incoming)) {
-        const old = current[key];
-        if (isRecord(old)) {
-          for (const handler of removeHandlers ?? []) handler(old, key);
-        }
-        delete current[key];
-      }
-    }
-
-    const addHandlers = this.collectionAdd.get(collection);
-    for (const [key, value] of Object.entries(incoming)) {
-      if (!isRecord(value)) {
-        current[key] = value;
-        continue;
-      }
-
-      const existed = key in current;
-      const target = isRecord(current[key]) ? current[key] : {};
-      current[key] = mergeRecord(target, value, this.itemChange);
-      if (!existed && isRecord(current[key])) {
-        for (const handler of addHandlers ?? []) handler(current[key], key);
-      }
-    }
-
-    return current;
-  }
-}
-
-function mergeRecord(
-  target: Record<string, unknown>,
-  incoming: Record<string, unknown>,
-  itemChange: WeakMap<object, Set<ChangeHandler>>,
-): Record<string, unknown> {
-  let changed = false;
-  for (const key of Object.keys(target)) {
-    if (!(key in incoming)) {
-      delete target[key];
-      changed = true;
-    }
-  }
-  for (const [key, value] of Object.entries(incoming)) {
-    if (isRecord(value)) {
-      const child = isRecord(target[key]) ? target[key] : {};
-      target[key] = mergeRecord(child, value, itemChange);
-    } else if (target[key] !== value) {
-      target[key] = value;
-      changed = true;
-    }
-  }
-  if (changed) {
-    for (const handler of itemChange.get(target) ?? []) handler();
-  }
-  return target;
-}
-
-function getSet<K, V>(map: Map<K, Set<V>>, key: K): Set<V> {
-  const existing = map.get(key);
-  if (existing) return existing;
-  const created = new Set<V>();
-  map.set(key, created);
-  return created;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function isCollectionRecord(value: Record<string, unknown>): boolean {
-  return Object.values(value).every((item) => isRecord(item));
-}

package/src/schema.ts

@@ -1,287 +0,0 @@
-const SCHEMA_TYPES = Symbol('p2pColyseusSchemaTypes');
-
-export const $refId = '~refId';
-export const $track = '~track';
-export const $encoder = '~encoder';
-export const $decoder = '~decoder';
-export const $filter = '~filter';
-export const $getByIndex = '~getByIndex';
-export const $deleteByIndex = '~deleteByIndex';
-export const $changes = '~changes';
-export const $childType = '~childType';
-
-export const OPERATION = {
-  ADD: 128,
-  REPLACE: 0,
-  DELETE: 64,
-  DELETE_AND_MOVE: 96,
-  MOVE_AND_ADD: 160,
-  DELETE_AND_ADD: 192,
-  CLEAR: 10,
-  REVERSE: 15,
-  MOVE: 32,
-  DELETE_BY_REFID: 33,
-  ADD_BY_REFID: 129,
-} as const;
-
-export class Schema {
-  constructor(props?: Record<string, unknown>) {
-    if (props) this.assign(props as Partial<this>);
-  }
-
-  static getSchemaTypes(): ReadonlyMap<string, unknown> {
-    const combined = new Map<string, unknown>();
-    // biome-ignore lint/complexity/noThisInStatic: schema metadata must be read from the concrete subclass.
-    const parent = Object.getPrototypeOf(this) as {
-      getSchemaTypes?: () => ReadonlyMap<string, unknown>;
-    } | null;
-    if (parent && parent !== Schema && parent.getSchemaTypes) {
-      for (const [key, value] of parent.getSchemaTypes()) combined.set(key, value);
-    }
-    // biome-ignore lint/complexity/noThisInStatic: schema metadata must be read from the concrete subclass.
-    const own = (this as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> })[SCHEMA_TYPES];
-    for (const [key, value] of own ?? []) combined.set(key, value);
-    return combined;
-  }
-
-  static is(type: unknown): boolean {
-    return typeof type === 'function' && (type === Schema || type.prototype instanceof Schema);
-  }
-
-  static isSchema(obj: unknown): obj is Schema {
-    return obj instanceof Schema;
-  }
-
-  assign<T extends Partial<this>>(props: T): this {
-    Object.assign(this, props);
-    return this;
-  }
-
-  restore(jsonData: Record<string, unknown>): this {
-    Object.assign(this, jsonData);
-    return this;
-  }
-
-  setDirty(_property?: string | number | symbol, _operation?: unknown): void {
-    // This shim snapshots mutable state each tick, so explicit dirty marking is unnecessary.
-  }
-
-  clone(): this {
-    const cloned = new (this.constructor as new () => this)();
-    return cloned.restore(deepClone(this.toJSON() as Record<string, unknown>));
-  }
-
-  toJSON(): unknown {
-    return encodeSnapshotState(this);
-  }
-
-  discardAllChanges(): void {
-    // Compatibility no-op. Change tracking is handled by snapshot diffing.
-  }
-}
-
-export class MapSchema<T> extends Map<string, T> {
-  constructor(entries?: Iterable<readonly [string, T]> | null) {
-    super(entries);
-  }
-}
-
-export class ArraySchema<T> extends Array<T> {
-  constructor(...items: T[]) {
-    super(...items);
-  }
-}
-
-export class CollectionSchema<T> extends Set<T> {
-  constructor(values?: Iterable<T> | null) {
-    super(values);
-  }
-}
-
-export class SetSchema<T> extends Set<T> {
-  constructor(values?: Iterable<T> | null) {
-    super(values);
-  }
-}
-
-export function type(_kind: unknown): PropertyDecorator {
-  return (target, propertyKey) => {
-    const ctor = target.constructor as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> };
-    ctor[SCHEMA_TYPES] ??= new Map();
-    ctor[SCHEMA_TYPES].set(String(propertyKey), _kind);
-  };
-}
-
-export const schema = type;
-export const view = type;
-export const entity = type;
-export const deprecated = type;
-
-export function defineTypes<T extends typeof Schema>(
-  target: T,
-  fields: Record<string, unknown>,
-): T {
-  const ctor = target as unknown as { [SCHEMA_TYPES]?: Map<string, unknown> };
-  ctor[SCHEMA_TYPES] ??= new Map();
-  for (const [key, value] of Object.entries(fields)) ctor[SCHEMA_TYPES].set(key, value);
-  return target;
-}
-
-export function defineCustomTypes<T extends Record<string, unknown>>(types: T): T {
-  return types;
-}
-
-export function registerType(): void {
-  // Custom binary type registration is not needed by the JSON snapshot codec.
-}
-
-export function dumpChanges(value: unknown): unknown {
-  return encodeSnapshotState(value);
-}
-
-export const encode = {
-  number(value: number): number {
-    return value;
-  },
-  string(value: string): string {
-    return value;
-  },
-  boolean(value: boolean): boolean {
-    return value;
-  },
-};
-
-export const decode = {
-  number(value: number): number {
-    return value;
-  },
-  string(value: string): string {
-    return value;
-  },
-  boolean(value: boolean): boolean {
-    return value;
-  },
-};
-
-export class Encoder<T = unknown> {
-  constructor(public state?: T) {}
-
-  encode(): Uint8Array {
-    return new TextEncoder().encode(JSON.stringify(encodeSnapshotState(this.state)));
-  }
-
-  encodeAll(): Uint8Array {
-    return this.encode();
-  }
-
-  discardChanges(): void {}
-}
-
-export class Decoder<T = unknown> {
-  state: T | undefined;
-
-  decode(bytes: Uint8Array): T | undefined {
-    const text = new TextDecoder().decode(bytes);
-    this.state = text ? (JSON.parse(text) as T) : undefined;
-    return this.state;
-  }
-}
-
-export class StateView {
-  readonly items = new Set<unknown>();
-
-  add(item: unknown): void {
-    this.items.add(item);
-  }
-
-  remove(item: unknown): void {
-    this.items.delete(item);
-  }
-
-  has(item: unknown): boolean {
-    return this.items.has(item);
-  }
-}
-
-export class Reflection {}
-export class ReflectionType extends Schema {}
-export class ReflectionField extends Schema {}
-export class Metadata {}
-export class TypeContext {}
-export class ChangeTree {}
-
-export class Callbacks {
-  static get(state: unknown): unknown {
-    return state;
-  }
-}
-
-export const StateCallbackStrategy = {};
-
-export function getDecoderStateCallbacks(state: unknown): unknown {
-  return state;
-}
-
-export function getRawChangesCallback(
-  callback: (...args: unknown[]) => void,
-): (...args: unknown[]) => void {
-  return callback;
-}
-
-export function encodeSchemaOperation(value: unknown): unknown {
-  return value;
-}
-
-export function encodeArray(value: unknown): unknown {
-  return value;
-}
-
-export function encodeKeyValueOperation(value: unknown): unknown {
-  return value;
-}
-
-export function decodeSchemaOperation(value: unknown): unknown {
-  return value;
-}
-
-export function decodeKeyValueOperation(value: unknown): unknown {
-  return value;
-}
-
-export function encodeSnapshotState(value: unknown): unknown {
-  if (value instanceof ArraySchema || Array.isArray(value)) {
-    return value.map((item) => encodeSnapshotState(item));
-  }
-
-  if (value instanceof CollectionSchema || value instanceof SetSchema || value instanceof Set) {
-    return [...value.values()].map((item) => encodeSnapshotState(item));
-  }
-
-  if (value instanceof MapSchema || value instanceof Map) {
-    const out: Record<string, unknown> = {};
-    for (const [key, item] of value.entries()) out[String(key)] = encodeSnapshotState(item);
-    return out;
-  }
-
-  if (value instanceof Schema || isPlainObject(value)) {
-    const out: Record<string, unknown> = {};
-    for (const [key, item] of Object.entries(value)) {
-      if (typeof item === 'function') continue;
-      out[key] = encodeSnapshotState(item);
-    }
-    return out;
-  }
-
-  return value;
-}
-
-function deepClone<T>(value: T): T {
-  if (typeof structuredClone === 'function') return structuredClone(value);
-  return JSON.parse(JSON.stringify(value)) as T;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype
-  );
-}