@matter/general 0.14.1-alpha.0-20250605-9fc134af0 → 0.14.1-alpha.0-20250606-a9bcd03f9

package/src/net/UdpInterface.ts

@@ -12,16 +12,24 @@ import { TransportInterface } from "./TransportInterface.js";
 import { UdpChannel } from "./UdpChannel.js";
 
 export class UdpInterface implements NetInterface {
+    readonly #server: UdpChannel;
+
     static async create(network: Network, type: "udp4" | "udp6", port?: number, host?: string, netInterface?: string) {
         return new UdpInterface(
             await network.createUdpChannel({ listeningPort: port, type, netInterface, listeningAddress: host }),
         );
     }
 
-    constructor(private readonly server: UdpChannel) {}
+    constructor(server: UdpChannel) {
+        this.#server = server;
+    }
+
+    protected get server() {
+        return this.#server;
+    }
 
     supports(type: ChannelType, address: string) {
-        return this.server.supports(type, address);
+        return this.#server.supports(type, address);
     }
 
     async openChannel(address: ServerAddress) {
@@ -29,48 +37,59 @@ export class UdpInterface implements NetInterface {
             throw new NetworkError(`Unsupported address type ${address.type}`);
         }
         const { ip, port } = address;
-        return Promise.resolve(new UdpConnection(this.server, ip, port));
+        return Promise.resolve(new UdpConnection(this.#server, ip, port));
     }
 
     onData(listener: (channel: Channel<Uint8Array>, messageBytes: Uint8Array) => void): TransportInterface.Listener {
-        return this.server.onData((_netInterface, peerHost, peerPort, data) =>
-            listener(new UdpConnection(this.server, peerHost, peerPort), data),
+        return this.#server.onData((_netInterface, peerHost, peerPort, data) =>
+            listener(new UdpConnection(this.#server, peerHost, peerPort), data),
         );
     }
 
     get port() {
-        return this.server.port;
+        return this.#server.port;
     }
 
     close() {
-        return this.server.close();
+        return this.#server.close();
+    }
+
+    addMembership(address: string) {
+        return this.#server.addMembership(address);
+    }
+
+    dropMembership(address: string) {
+        return this.#server.dropMembership(address);
     }
 }
 
-class UdpConnection implements IpNetworkChannel<Uint8Array> {
+export class UdpConnection implements IpNetworkChannel<Uint8Array> {
     readonly isReliable = false;
     readonly type = ChannelType.UDP;
+    readonly #server: UdpChannel;
+    readonly #peerAddress: string;
+    readonly #peerPort: number;
 
-    constructor(
-        private readonly server: UdpChannel,
-        private readonly peerAddress: string,
-        private readonly peerPort: number,
-    ) {}
+    constructor(server: UdpChannel, peerAddress: string, peerPort: number) {
+        this.#server = server;
+        this.#peerAddress = peerAddress;
+        this.#peerPort = peerPort;
+    }
 
     get maxPayloadSize() {
-        return this.server.maxPayloadSize;
+        return this.#server.maxPayloadSize;
     }
 
     send(data: Uint8Array) {
-        return this.server.send(this.peerAddress, this.peerPort, data);
+        return this.#server.send(this.#peerAddress, this.#peerPort, data);
     }
 
     get name() {
-        return `${this.type}://[${this.peerAddress}]:${this.peerPort}`;
+        return `${this.type}://[${this.#peerAddress}]:${this.#peerPort}`;
     }
 
     get networkAddress(): ServerAddressIp {
-        return { type: "udp", ip: this.peerAddress, port: this.peerPort };
+        return { type: "udp", ip: this.#peerAddress, port: this.#peerPort };
     }
 
     async close() {

package/src/net/UdpMulticastServer.ts

@@ -37,8 +37,8 @@ export class UdpMulticastServer {
                     type: "udp4",
                     netInterface,
                     listeningPort,
-                    membershipAddresses: [broadcastAddressIpv4],
                 });
+                await ipv4UdpChannel.addMembership(broadcastAddressIpv4);
             } catch (error) {
                 NoAddressAvailableError.accept(error);
                 logger.info(`IPv4 UDP channel not created because IPv4 is not available: ${asError(error).message}`);
@@ -46,18 +46,19 @@ export class UdpMulticastServer {
         }
 
         try {
+            const ipv6UdpChannel = await network.createUdpChannel({
+                type: "udp6",
+                netInterface,
+                listeningPort,
+            });
+            await ipv6UdpChannel.addMembership(broadcastAddressIpv6);
             return new UdpMulticastServer(
                 network,
                 broadcastAddressIpv4,
                 broadcastAddressIpv6,
                 listeningPort,
                 ipv4UdpChannel,
-                await network.createUdpChannel({
-                    type: "udp6",
-                    netInterface,
-                    listeningPort,
-                    membershipAddresses: [broadcastAddressIpv6],
-                }),
+                ipv6UdpChannel,
                 netInterface,
             );
         } catch (error) {

package/src/net/mock/MockUdpChannel.ts

@@ -59,4 +59,12 @@ export class MockUdpChannel implements UdpChannel {
     supports(type: ChannelType, _address: string) {
         return type === ChannelType.UDP;
     }
+
+    addMembership(_address: string): void {
+        // No-op for mock channel
+    }
+
+    dropMembership(_address: string): void {
+        // No-op for mock channel
+    }
 }

package/src/time/Time.ts

@@ -36,6 +36,11 @@ export class Time {
     }
     static readonly nowMs = (): number => Time.get().nowMs();
 
+    nowUs() {
+        return Math.floor(performance.now() + performance.timeOrigin) * 1000;
+    }
+    static readonly nowUs = (): number => Time.get().nowUs();
+
     /**
      * Create a timer that will call callback after durationMs has passed.
      */
@@ -91,6 +96,11 @@ export class Time {
     }
 }
 
+// Check if performance API is available and has the required methods. Use lower accuracy fallback if not.
+if (!performance || typeof performance.now !== "function" || typeof performance.timeOrigin !== "number") {
+    Time.prototype.nowUs = () => Time.nowMs() * 1000; // Fallback is a bit less accurate
+}
+
 const time = new Time();
 
 Time.startup.systemMs = Time.startup.processMs = time.nowMs();

package/src/util/DataReadQueue.ts

@@ -38,6 +38,10 @@ export class DataReadQueue<T> implements Stream<T> {
         this.push(data);
     }
 
+    get size() {
+        return this.#queue.length;
+    }
+
     /**
      * Same as write but doesn't require the await required to satisfy {@link Stream#write}.
      */

package/src/util/DataReader.ts

@@ -7,13 +7,13 @@
 import { Bytes, Endian } from "./Bytes.js";
 
 /** Reader that auto-increments its offset after each read. */
-export class DataReader<E extends Endian> {
+export class DataReader<E extends Endian = Endian.Big> {
     readonly #littleEndian: boolean;
     readonly #dataView: DataView;
     readonly #buffer: Uint8Array;
     #offset = 0;
 
-    constructor(buffer: Uint8Array, endian: E) {
+    constructor(buffer: Uint8Array, endian?: E) {
         this.#buffer = buffer;
         this.#dataView = Bytes.dataViewOf(this.#buffer);
         this.#littleEndian = endian === Endian.Little;

package/src/util/DataWriter.ts

@@ -9,12 +9,12 @@ import { toBigInt, toNumber } from "./Number.js";
 
 /** Writer that auto-increments its offset after each write. */
 // TODO: some research should be done to make sure this is most performant implementation.
-export class DataWriter<E extends Endian> {
+export class DataWriter<E extends Endian = Endian.Big> {
     private readonly littleEndian: boolean;
     private length = 0;
     private readonly chunks = new Array<Uint8Array>();
 
-    constructor(endian: E) {
+    constructor(endian?: E) {
         this.littleEndian = endian === Endian.Little;
     }
 

package/src/util/Ip.ts

@@ -46,6 +46,56 @@ export function ipv6ToBytes(ip: string) {
     return Uint8Array.from(Array.from(ipv6ToArray(ip)).flatMap(value => [value >> 8, value & 0xff]));
 }
 
+export function ipv6BytesToString(bytes: Uint8Array): string {
+    if (bytes.length !== 16) {
+        throw new Error("IPv6 address must be 16 bytes");
+    }
+
+    // Divide into 8 blocks of 2 bytes (16 bits) each
+    const blocks = [];
+    for (let i = 0; i < 16; i += 2) {
+        blocks.push(((bytes[i] << 8) | bytes[i + 1]).toString(16));
+    }
+
+    // Compression of the longest zero sequence (RFC 5952)
+    let bestStart = -1;
+    let bestLen = 0;
+    let currStart = -1;
+    let currLen = 0;
+    for (let i = 0; i < 8; i++) {
+        if (blocks[i] === "0") {
+            if (currStart === -1) {
+                currStart = i;
+                currLen = 1;
+            } else {
+                currLen++;
+            }
+        } else {
+            if (currLen > bestLen) {
+                bestStart = currStart;
+                bestLen = currLen;
+            }
+            currStart = -1;
+            currLen = 0;
+        }
+    }
+    if (currLen > bestLen) {
+        bestStart = currStart;
+        bestLen = currLen;
+    }
+    if (bestLen > 1) {
+        blocks.splice(bestStart, bestLen, "");
+        if (bestStart === 0) {
+            blocks.unshift("");
+        }
+        if (bestStart + bestLen === 8) {
+            blocks.push("");
+        }
+    }
+
+    return blocks.join(":").replace(/:{3,}/, "::").toLowerCase();
+}
+
 export function onSameNetwork(ip1: string, ip2: string, mask: string) {
     if (isIPv4(ip1)) {
         // IPv4 addresses

package/src/util/Map.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Observable } from "#util/Observable.js";
+
+/**
+ * Set change events.
+ */
+export interface ObservableMap<K, V> {
+    get added(): Observable<[key: K, newValue: V]>;
+    get deleted(): Observable<[key: K, oldValue: V]>;
+    get changed(): Observable<[key: K, newValue: V, oldValue: V]>;
+}
+
+/** Map extension to get added, deleted or changed events */
+export class BasicMap<K, V> extends Map<K, V> implements ObservableMap<K, V> {
+    #added?: Observable<[K, V]>;
+    #deleted?: Observable<[K, V]>;
+    #changed?: Observable<[K, V, V]>;
+
+    override set(key: K, value: V): this {
+        const existing = this.get(key);
+        if (existing !== undefined) {
+            if (existing === value) {
+                // No change, do not emit events
+                return this;
+            }
+            this.#changed?.emit(key, value, existing);
+        } else {
+            this.#added?.emit(key, value);
+        }
+        return super.set(key, value);
+    }
+
+    override delete(key: K): boolean {
+        const existing = this.get(key);
+        if (existing !== undefined) {
+            this.#deleted?.emit(key, existing);
+        }
+        return super.delete(key);
+    }
+
+    get added() {
+        if (this.#added === undefined) {
+            this.#added = Observable();
+        }
+        return this.#added;
+    }
+
+    get deleted() {
+        if (this.#deleted === undefined) {
+            this.#deleted = Observable();
+        }
+        return this.#deleted;
+    }
+
+    get changed() {
+        if (this.#changed === undefined) {
+            this.#changed = Observable();
+        }
+        return this.#changed;
+    }
+}

package/src/util/Set.ts

@@ -177,7 +177,19 @@ export class BasicSet<T, AddT = T> implements ImmutableSet<T>, MutableSet<T, Add
         return map;
     }
 
-    delete(item: T) {
+    delete(item: T): boolean;
+    delete<F extends keyof T>(field: keyof T, value: T[F]): boolean;
+    delete<F extends keyof T>(itemOrField: T | F, value?: T[F]): boolean {
+        let item: T | undefined;
+        if (value === undefined) {
+            item = itemOrField as T;
+        } else {
+            item = this.get(itemOrField as F, value);
+            if (item === undefined) {
+                return false; // Item not found
+            }
+        }
+
         if (!this.#entries.delete(item)) {
             return false;
         }

package/src/util/index.ts

@@ -20,6 +20,7 @@ export * from "./FormattedText.js";
 export * from "./GeneratedClass.js";
 export * from "./Ip.js";
 export * from "./Lifecycle.js";
+export * from "./Map.js";
 export * from "./Mutex.js";
 export * from "./NamedHandler.js";
 export * from "./Number.js";