@project-chip/matter.js 0.0.0 → 0.0.2

package/dist/tlv/TlvCodec.js

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { INT16_MAX, INT16_MIN, INT32_MAX, INT32_MIN, INT8_MAX, INT8_MIN, UINT16_MAX, UINT32_MAX, UINT8_MAX } from "../util/Number.js";
+import { BitmapSchema, BitFieldEnum, BitField } from "../schema/BitmapSchema.js";
+/**
+ * Schema of the ControlByte.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.7.2
+ */
+const ControlByteSchema = BitmapSchema({
+    typeLength: BitField(0, 5),
+    tagControl: BitFieldEnum(5, 3),
+});
+/** {@link MatterCoreSpecificationV1_0} § 2.5.2 and § A.8.3 */
+const MATTER_COMMON_PROFILE = 0x00000000;
+export class TlvCodec {
+    static getUIntTlvLength(value) {
+        if (value <= UINT8_MAX) {
+            return 0 /* TlvLength.OneByte */;
+        }
+        else if (value <= UINT16_MAX) {
+            return 1 /* TlvLength.TwoBytes */;
+        }
+        else if (value <= UINT32_MAX) {
+            return 2 /* TlvLength.FourBytes */;
+        }
+        else {
+            return 3 /* TlvLength.EightBytes */;
+        }
+    }
+    static getIntTlvLength(value) {
+        if (value > 0) {
+            if (value <= INT8_MAX) {
+                return 0 /* TlvLength.OneByte */;
+            }
+            else if (value <= INT16_MAX) {
+                return 1 /* TlvLength.TwoBytes */;
+            }
+            else if (value <= INT32_MAX) {
+                return 2 /* TlvLength.FourBytes */;
+            }
+            else {
+                return 3 /* TlvLength.EightBytes */;
+            }
+        }
+        else {
+            if (value >= INT8_MIN) {
+                return 0 /* TlvLength.OneByte */;
+            }
+            else if (value >= INT16_MIN) {
+                return 1 /* TlvLength.TwoBytes */;
+            }
+            else if (value >= INT32_MIN) {
+                return 2 /* TlvLength.FourBytes */;
+            }
+            else {
+                return 3 /* TlvLength.EightBytes */;
+            }
+        }
+    }
+    /** @see {@link MatterCoreSpecificationV1_0} § A.7 */
+    static readTagType(reader) {
+        const { tagControl, typeLength } = ControlByteSchema.decode(reader.readUInt8());
+        return { tag: this.readTag(reader, tagControl), typeLength: this.parseTypeLength(typeLength) };
+    }
+    static readTag(reader, tagControl) {
+        switch (tagControl) {
+            case 0 /* TagControl.Anonymous */:
+                return undefined;
+            case 1 /* TagControl.ContextSpecific */:
+                return { id: reader.readUInt8() };
+            case 2 /* TagControl.CommonProfile16 */:
+                return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt16() };
+            case 3 /* TagControl.CommonProfile32 */:
+                return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt32() };
+            case 4 /* TagControl.ImplicitProfile16 */:
+            case 5 /* TagControl.ImplicitProfile32 */:
+                throw new Error(`Unsupported implicit profile ${tagControl}`);
+            case 6 /* TagControl.FullyQualified48 */:
+                return { profile: reader.readUInt32(), id: reader.readUInt16() };
+            case 6 /* TagControl.FullyQualified48 */:
+                return { profile: reader.readUInt32(), id: reader.readUInt32() };
+            default:
+                throw new Error(`Unexpected tagControl ${tagControl}`);
+        }
+    }
+    static parseTypeLength(typeLength) {
+        const length = (typeLength & 0x03);
+        const type = typeLength & 0xFC;
+        switch (type) {
+            case 12 /* TlvType.Utf8String */:
+            case 16 /* TlvType.ByteString */:
+            case 0 /* TlvType.SignedInt */:
+            case 4 /* TlvType.UnsignedInt */:
+                return { type, length };
+            case 8 /* TlvType.Boolean */:
+                switch (length) {
+                    case 0 /* TlvLength.OneByte */: return { type, value: false };
+                    case 1 /* TlvLength.TwoBytes */: return { type, value: true };
+                    case 2 /* TlvLength.FourBytes */: return { type: 10 /* TlvType.Float */, length };
+                    case 3 /* TlvLength.EightBytes */: return { type: 10 /* TlvType.Float */, length };
+                }
+            default:
+                return { type: typeLength };
+        }
+    }
+    static readPrimitive(reader, typeLength) {
+        switch (typeLength.type) {
+            case 0 /* TlvType.SignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readInt8();
+                    case 1 /* TlvLength.TwoBytes */: return reader.readInt16();
+                    case 2 /* TlvLength.FourBytes */: return reader.readInt32();
+                    case 3 /* TlvLength.EightBytes */: return reader.readInt64();
+                }
+            case 4 /* TlvType.UnsignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readUInt8();
+                    case 1 /* TlvLength.TwoBytes */: return reader.readUInt16();
+                    case 2 /* TlvLength.FourBytes */: return reader.readUInt32();
+                    case 3 /* TlvLength.EightBytes */: return reader.readUInt64();
+                }
+            case 10 /* TlvType.Float */:
+                switch (typeLength.length) {
+                    case 2 /* TlvLength.FourBytes */: return reader.readFloat();
+                    case 3 /* TlvLength.EightBytes */: return reader.readDouble();
+                }
+            case 12 /* TlvType.Utf8String */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readUtf8String(reader.readUInt8());
+                    case 1 /* TlvLength.TwoBytes */: return reader.readUtf8String(reader.readUInt16());
+                    case 2 /* TlvLength.FourBytes */: return reader.readUtf8String(reader.readUInt32());
+                    case 3 /* TlvLength.EightBytes */: return reader.readUtf8String(Number(reader.readUInt64()));
+                }
+            case 16 /* TlvType.ByteString */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readByteArray(reader.readUInt8());
+                    case 1 /* TlvLength.TwoBytes */: return reader.readByteArray(reader.readUInt16());
+                    case 2 /* TlvLength.FourBytes */: return reader.readByteArray(reader.readUInt32());
+                    case 3 /* TlvLength.EightBytes */: return reader.readByteArray(Number(reader.readUInt64()));
+                }
+            case 8 /* TlvType.Boolean */:
+                return typeLength.value;
+            case 20 /* TlvType.Null */:
+                return null;
+            default:
+                throw new Error(`Unexpected TLV type ${typeLength.type}`);
+        }
+    }
+    /** @see {@link MatterCoreSpecificationV1_0} § A.7 & A.8 */
+    static writeTag(writer, typeLengthValue, { profile, id } = {}) {
+        let typeLength;
+        switch (typeLengthValue.type) {
+            case 12 /* TlvType.Utf8String */:
+            case 16 /* TlvType.ByteString */:
+            case 0 /* TlvType.SignedInt */:
+            case 4 /* TlvType.UnsignedInt */:
+            case 10 /* TlvType.Float */:
+                typeLength = typeLengthValue.type | typeLengthValue.length;
+                break;
+            case 8 /* TlvType.Boolean */:
+                typeLength = typeLengthValue.type + (typeLengthValue.value ? 1 : 0);
+                break;
+            default:
+                typeLength = typeLengthValue.type;
+        }
+        if (profile === undefined && id === undefined) {
+            writer.writeUInt8(ControlByteSchema.encode({ tagControl: 0 /* TagControl.Anonymous */, typeLength }));
+        }
+        else if (profile === undefined) {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a context specific tag.");
+            writer.writeUInt8(ControlByteSchema.encode({ tagControl: 1 /* TagControl.ContextSpecific */, typeLength }));
+            writer.writeUInt8(id);
+        }
+        else if (profile === MATTER_COMMON_PROFILE) {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a common profile.");
+            if ((id & 0xFFFF0000) === 0) {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 2 /* TagControl.CommonProfile16 */, typeLength }));
+                writer.writeUInt16(id);
+            }
+            else {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 3 /* TagControl.CommonProfile32 */, typeLength }));
+                writer.writeUInt32(id);
+            }
+        }
+        else {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a custom profile.");
+            if ((id & 0xFFFF0000) === 0) {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 6 /* TagControl.FullyQualified48 */, typeLength }));
+                writer.writeUInt32(profile);
+                writer.writeUInt16(id);
+            }
+            else {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 7 /* TagControl.FullyQualified64 */, typeLength }));
+                writer.writeUInt32(profile);
+                writer.writeUInt32(id);
+            }
+        }
+    }
+    static writePrimitive(writer, typeLength, value) {
+        switch (typeLength.type) {
+            case 0 /* TlvType.SignedInt */:
+                return this.writeUInt(writer, typeLength.length, value);
+            case 4 /* TlvType.UnsignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return writer.writeUInt8(value);
+                    case 1 /* TlvLength.TwoBytes */: return writer.writeUInt16(value);
+                    case 2 /* TlvLength.FourBytes */: return writer.writeUInt32(value);
+                    case 3 /* TlvLength.EightBytes */: return writer.writeUInt64(value);
+                }
+            case 10 /* TlvType.Float */:
+                switch (typeLength.length) {
+                    case 2 /* TlvLength.FourBytes */: return writer.writeFloat(value);
+                    case 3 /* TlvLength.EightBytes */: return writer.writeDouble(value);
+                }
+            case 12 /* TlvType.Utf8String */:
+                const string = value;
+                this.writeUInt(writer, typeLength.length, string.length);
+                return writer.writeUtf8String(string);
+            case 16 /* TlvType.ByteString */:
+                const byteArray = value;
+                this.writeUInt(writer, typeLength.length, byteArray.length);
+                return writer.writeByteArray(byteArray);
+            case 8 /* TlvType.Boolean */:
+                return;
+            default:
+                throw new Error(`Unexpected TLV type ${typeLength.type}`);
+        }
+    }
+    static writeUInt(writer, length, value) {
+        switch (length) {
+            case 0 /* TlvLength.OneByte */: return writer.writeInt8(value);
+            case 1 /* TlvLength.TwoBytes */: return writer.writeInt16(value);
+            case 2 /* TlvLength.FourBytes */: return writer.writeInt32(value);
+            case 3 /* TlvLength.EightBytes */: return writer.writeInt64(value);
+        }
+    }
+}

package/dist/tlv/TlvNullable.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvTag, TlvTypeLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+/**
+ * Schema to encode a nulable value in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.6
+ */
+export declare class NullableSchema<T> extends TlvSchema<T | null> {
+    private readonly schema;
+    constructor(schema: TlvSchema<T>);
+    encodeTlvInternal(writer: TlvWriter, value: T | null, tag?: TlvTag): void;
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): T | null;
+}
+/** Nullable TLV schema. */
+export declare const TlvNullable: <T>(schema: TlvSchema<T>) => NullableSchema<T>;

package/dist/tlv/TlvNullable.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvSchema } from "./TlvSchema.js";
+/**
+ * Schema to encode a nulable value in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.6
+ */
+export class NullableSchema extends TlvSchema {
+    constructor(schema) {
+        super();
+        this.schema = schema;
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        if (value === null) {
+            writer.writeTag({ type: 20 /* TlvType.Null */ }, tag);
+        }
+        else {
+            this.schema.encodeTlvInternal(writer, value, tag);
+        }
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type === 20 /* TlvType.Null */)
+            return null;
+        return this.schema.decodeTlvInternalValue(reader, typeLength);
+    }
+}
+/** Nullable TLV schema. */
+export const TlvNullable = (schema) => new NullableSchema(schema);

package/dist/tlv/TlvNumber.d.ts

@@ -0,0 +1,46 @@
+import { TlvType, TlvTag, TlvTypeLength, TlvLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+import { TlvWrapper } from "./TlvWrapper.js";
+import { BitSchema, TypeFromBitSchema } from "../schema/BitmapSchema.js";
+/**
+ * Schema to encode an unsigned integer in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.1
+ */
+export declare class TlvNumericSchema<T extends bigint | number> extends TlvSchema<T> {
+    protected readonly type: TlvType.UnsignedInt | TlvType.SignedInt | TlvType.Float;
+    protected readonly lengthProvider: (value: T) => TlvLength;
+    protected readonly min?: T | undefined;
+    protected readonly max?: T | undefined;
+    constructor(type: TlvType.UnsignedInt | TlvType.SignedInt | TlvType.Float, lengthProvider: (value: T) => TlvLength, min?: T | undefined, max?: T | undefined);
+    encodeTlvInternal(writer: TlvWriter, value: T, tag?: TlvTag): void;
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): T;
+    validate(value: T): void;
+    /** Restrict value range. */
+    bound({ min, max }: NumericConstraints<T>): TlvNumericSchema<T>;
+}
+export type NumericConstraints<T extends number | bigint = number | bigint> = {
+    min?: T;
+    max?: T;
+};
+export declare class TlvNumberSchema extends TlvNumericSchema<number> {
+    constructor(type: TlvType.UnsignedInt | TlvType.SignedInt | TlvType.Float, lengthProvider: (value: number) => TlvLength, min?: number, max?: number);
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): number;
+    bound({ min, max }: NumericConstraints<number>): TlvNumericSchema<number>;
+}
+export declare const TlvLongNumberSchema: {
+    new (type: TlvType.UnsignedInt | TlvType.SignedInt | TlvType.Float, lengthProvider: (value: number | bigint) => TlvLength, min?: number | bigint | undefined, max?: number | bigint | undefined): TlvNumericSchema<number | bigint>;
+};
+/** Unsigned integer TLV schema. */
+export declare const TlvFloat: TlvNumberSchema;
+export declare const TlvDouble: TlvNumberSchema;
+export declare const TlvInt8: TlvNumberSchema;
+export declare const TlvInt16: TlvNumberSchema;
+export declare const TlvInt32: TlvNumberSchema;
+export declare const TlvInt64: TlvNumericSchema<number | bigint>;
+export declare const TlvUInt8: TlvNumberSchema;
+export declare const TlvUInt16: TlvNumberSchema;
+export declare const TlvUInt32: TlvNumberSchema;
+export declare const TlvUInt64: TlvNumericSchema<number | bigint>;
+export declare const TlvEnum: <T>() => TlvSchema<T>;
+export declare const TlvBitmap: <T extends BitSchema>(underlyingSchema: TlvNumberSchema, bitSchema: T) => TlvWrapper<TypeFromBitSchema<T>, number>;

package/dist/tlv/TlvNumber.js

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FLOAT32_MAX, FLOAT32_MIN, INT16_MAX, INT16_MIN, INT32_MAX, INT32_MIN, INT64_MAX, INT64_MIN, INT8_MAX, INT8_MIN, maxValue, minValue, UINT16_MAX, UINT32_MAX, UINT64_MAX, UINT8_MAX } from "../util/Number.js";
+import { TlvCodec } from "./TlvCodec.js";
+import { TlvSchema } from "./TlvSchema.js";
+import { TlvWrapper } from "./TlvWrapper.js";
+import { BitmapSchema } from "../schema/BitmapSchema.js";
+/**
+ * Schema to encode an unsigned integer in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.1
+ */
+export class TlvNumericSchema extends TlvSchema {
+    constructor(type, lengthProvider, min, max) {
+        super();
+        this.type = type;
+        this.lengthProvider = lengthProvider;
+        this.min = min;
+        this.max = max;
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        const typeLength = { type: this.type, length: this.lengthProvider(value) };
+        writer.writeTag(typeLength, tag);
+        writer.writePrimitive(typeLength, value);
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== this.type)
+            throw new Error(`Unexpected type ${typeLength.type}, was expecting ${this.type}.`);
+        const value = reader.readPrimitive(typeLength);
+        this.validate(value);
+        return value;
+    }
+    validate(value) {
+        super.validate(value);
+        if (this.min !== undefined && value < this.min)
+            throw new Error(`Invalid value: ${value} is below the minimum, ${this.min}.`);
+        if (this.max !== undefined && value > this.max)
+            throw new Error(`Invalid value: ${value} is above the maximum, ${this.max}.`);
+    }
+    /** Restrict value range. */
+    bound({ min, max }) {
+        return new TlvNumericSchema(this.type, this.lengthProvider, maxValue(min, this.min), minValue(max, this.max));
+    }
+}
+export class TlvNumberSchema extends TlvNumericSchema {
+    constructor(type, lengthProvider, min, max) {
+        super(type, lengthProvider, min, max);
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        const value = super.decodeTlvInternalValue(reader, typeLength);
+        return typeof value === "bigint" ? Number(value) : value;
+    }
+    bound({ min, max }) {
+        return new TlvNumberSchema(this.type, this.lengthProvider, maxValue(min, this.min), minValue(max, this.max));
+    }
+}
+export const TlvLongNumberSchema = (TlvNumericSchema);
+/** Unsigned integer TLV schema. */
+export const TlvFloat = new TlvNumberSchema(10 /* TlvType.Float */, _value => 2 /* TlvLength.FourBytes */, FLOAT32_MIN, FLOAT32_MAX);
+export const TlvDouble = new TlvNumberSchema(10 /* TlvType.Float */, _value => 3 /* TlvLength.EightBytes */);
+export const TlvInt8 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec.getIntTlvLength(value), INT8_MIN, INT8_MAX);
+export const TlvInt16 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec.getIntTlvLength(value), INT16_MIN, INT16_MAX);
+export const TlvInt32 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec.getIntTlvLength(value), INT32_MIN, INT32_MAX);
+export const TlvInt64 = new TlvLongNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec.getIntTlvLength(value), INT64_MIN, INT64_MAX);
+export const TlvUInt8 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec.getUIntTlvLength(value), 0, UINT8_MAX);
+export const TlvUInt16 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec.getUIntTlvLength(value), 0, UINT16_MAX);
+export const TlvUInt32 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec.getUIntTlvLength(value), 0, UINT32_MAX);
+export const TlvUInt64 = new TlvLongNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec.getUIntTlvLength(value), 0, UINT64_MAX);
+export const TlvEnum = () => TlvUInt32;
+export const TlvBitmap = (underlyingSchema, bitSchema) => {
+    const bitmapSchema = BitmapSchema(bitSchema);
+    return new TlvWrapper(underlyingSchema, (bitmapData) => bitmapSchema.encode(bitmapData), value => bitmapSchema.decode(value));
+};

package/dist/tlv/TlvObject.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Merge } from "../util/Type.js";
+import { TlvType, TlvTag, TlvTypeLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+export interface FieldType<T> {
+    id: number;
+    schema: TlvSchema<T>;
+    optional?: boolean;
+}
+export interface OptionalFieldType<T> extends FieldType<T> {
+    optional: true;
+}
+export type TlvFields = {
+    [field: string]: FieldType<any>;
+};
+type MandatoryFieldNames<F extends TlvFields> = {
+    [K in keyof F]: F[K] extends OptionalFieldType<any> ? never : K;
+}[keyof F];
+type OptionalFieldNames<F extends TlvFields> = {
+    [K in keyof F]: F[K] extends OptionalFieldType<any> ? K : never;
+}[keyof F];
+type TypeFromField<F extends FieldType<any>> = F extends FieldType<infer T> ? T : never;
+type TypeForMandatoryFields<F extends TlvFields, MF extends keyof F> = {
+    [K in MF]: TypeFromField<F[K]>;
+};
+type TypeForOptionalFields<F extends TlvFields, MF extends keyof F> = {
+    [K in MF]?: TypeFromField<F[K]>;
+};
+export type TypeFromFields<F extends TlvFields> = Merge<TypeForMandatoryFields<F, MandatoryFieldNames<F>>, TypeForOptionalFields<F, OptionalFieldNames<F>>>;
+/**
+ * Schema to encode an object in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.5.1 and § A.11.4
+ */
+export declare class ObjectSchema<F extends TlvFields> extends TlvSchema<TypeFromFields<F>> {
+    private readonly fieldDefinitions;
+    private readonly type;
+    private readonly fieldById;
+    constructor(fieldDefinitions: F, type?: TlvType.Structure | TlvType.List);
+    encodeTlvInternal(writer: TlvWriter, value: TypeFromFields<F>, tag?: TlvTag): void;
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): TypeFromFields<F>;
+    validate(value: TypeFromFields<F>): void;
+}
+/** Object TLV schema. */
+export declare const TlvObject: <F extends TlvFields>(fields: F) => ObjectSchema<F>;
+/** List TLV schema. */
+export declare const TlvList: <F extends TlvFields>(fields: F) => ObjectSchema<F>;
+/** Object TLV mandatory field. */
+export declare const TlvField: <T>(id: number, schema: TlvSchema<T>) => FieldType<T>;
+/** Object TLV optional field. */
+export declare const TlvOptionalField: <T>(id: number, schema: TlvSchema<T>) => OptionalFieldType<T>;
+export {};

package/dist/tlv/TlvObject.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvSchema } from "./TlvSchema.js";
+;
+/**
+ * Schema to encode an object in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.5.1 and § A.11.4
+ */
+export class ObjectSchema extends TlvSchema {
+    constructor(fieldDefinitions, type = 21 /* TlvType.Structure */) {
+        super();
+        this.fieldDefinitions = fieldDefinitions;
+        this.type = type;
+        this.fieldById = new Array();
+        for (const name in this.fieldDefinitions) {
+            const field = this.fieldDefinitions[name];
+            this.fieldById[field.id] = { name, field };
+        }
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        writer.writeTag({ type: this.type }, tag);
+        for (const name in this.fieldDefinitions) {
+            const { id, schema, optional: isOptional } = this.fieldDefinitions[name];
+            const fieldValue = value[name];
+            if (fieldValue === undefined) {
+                if (!isOptional)
+                    throw new Error(`Missing mandatory field ${name}`);
+                continue;
+            }
+            schema.encodeTlvInternal(writer, fieldValue, { id });
+        }
+        writer.writeTag({ type: 24 /* TlvType.EndOfContainer */ });
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== this.type)
+            throw new Error(`Unexpected type ${typeLength.type}.`);
+        const result = {};
+        while (true) {
+            const { tag: { profile, id } = {}, typeLength: elementTypeLength } = reader.readTagType();
+            if (elementTypeLength.type === 24 /* TlvType.EndOfContainer */)
+                break;
+            if (profile !== undefined)
+                throw new Error("Structure element tags should be context-specific.");
+            if (id === undefined)
+                throw new Error("Structure element tags should have an id.");
+            const fieldName = this.fieldById[id];
+            if (fieldName === undefined)
+                throw new Error(`Unknown field ${id}`);
+            const { field, name } = fieldName;
+            result[name] = field.schema.decodeTlvInternalValue(reader, elementTypeLength);
+        }
+        this.validate(result);
+        return result;
+    }
+    validate(value) {
+        for (const name in this.fieldDefinitions) {
+            if (!this.fieldDefinitions[name].optional && value[name] === undefined)
+                throw new Error(`Missing mandatory field ${name}`);
+        }
+    }
+}
+/** Object TLV schema. */
+export const TlvObject = (fields) => new ObjectSchema(fields, 21 /* TlvType.Structure */);
+/** List TLV schema. */
+export const TlvList = (fields) => new ObjectSchema(fields, 23 /* TlvType.List */);
+/** Object TLV mandatory field. */
+export const TlvField = (id, schema) => ({ id, schema, optional: false });
+/** Object TLV optional field. */
+export const TlvOptionalField = (id, schema) => ({ id, schema, optional: true });

package/dist/tlv/TlvSchema.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray.js";
+import { Schema } from "../schema/Schema.js";
+import { TlvTag, TlvToPrimitive, TlvTypeLength } from "./TlvCodec.js";
+export declare abstract class TlvSchema<T> extends Schema<T, ByteArray> implements TlvSchema<T> {
+    decodeInternal(encoded: ByteArray): T;
+    encodeInternal(value: T): ByteArray;
+    encodeTlv(value: T): TlvStream;
+    decodeTlv(encoded: TlvStream): T;
+    decodeTlvInternal(reader: TlvReader): {
+        value: T;
+        tag?: TlvTag;
+    };
+    abstract decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): T;
+    abstract encodeTlvInternal(writer: TlvWriter, value: T, tag?: TlvTag): void;
+}
+export type TlvStream = TlvElement<any>[];
+export type TlvElement<T extends TlvTypeLength> = {
+    tag?: TlvTag;
+    typeLength: T;
+    value?: TlvToPrimitive[T["type"]];
+};
+export declare class TlvArrayWriter implements TlvWriter {
+    private readonly tlvArray;
+    writeTag(typeLength: TlvTypeLength, tag?: TlvTag): void;
+    writePrimitive<T extends TlvTypeLength>(_typeLength: T, value: TlvToPrimitive[T["type"]]): void;
+    toTlvArray(): TlvElement<any>[];
+}
+export declare class TlvArrayReader implements TlvReader {
+    private readonly tlvElements;
+    private index;
+    constructor(tlvElements: TlvElement<any>[]);
+    readTagType(): TlvElement<any>;
+    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T["type"]]>(_typeLength: T): V;
+}
+/** Type defined by the TLV schema. */
+export type TypeFromSchema<S extends TlvSchema<any>> = S extends TlvSchema<infer T> ? T : never;
+export interface TlvReader {
+    readTagType(): {
+        tag?: TlvTag;
+        typeLength: TlvTypeLength;
+    };
+    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T["type"]]>(typeLength: T): V;
+}
+export interface TlvWriter {
+    writeTag(typeLength: TlvTypeLength, tag?: TlvTag): void;
+    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T["type"]]): void;
+}
+export declare class TlvByteArrayWriter implements TlvWriter {
+    private readonly writer;
+    writeTag(typeLength: TlvTypeLength, tag?: TlvTag): void;
+    writePrimitive<T extends TlvTypeLength>(typeLength: T, value: TlvToPrimitive[T["type"]]): void;
+    toByteArray(): Uint8Array;
+}
+export declare class TlvByteArrayReader implements TlvReader {
+    private readonly reader;
+    constructor(byteArray: ByteArray);
+    readTagType(): {
+        tag?: TlvTag | undefined;
+        typeLength: TlvTypeLength;
+    };
+    readPrimitive<T extends TlvTypeLength, V = TlvToPrimitive[T["type"]]>(typeLength: T): V;
+}