@2702rebels/wpidata 1.0.0

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, FRC Team 2702 (Rebels)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,5 @@
+# 🤖 2702 Rebels — Parsers and tools for FRC WPILIB data sources
+
+Implements data transformers for parsing FRC WPILIB specific data encodings used with NetworkTables and WPILOG
+protocols. Provides a generic data sink to be used at a receiving end of the data pipeline that supports
+transformations, in-memory data retention.

package/dist/abstractions.d.cts

@@ -0,0 +1,246 @@
+//#region src/abstractions.d.ts
+type DataType = "boolean" | "string" | "number" | "booleanArray" | "stringArray" | "numberArray" | "json" | "binary" | "composite";
+type DataTypeImpl = boolean | string | number | Array<boolean> | Array<string> | Array<number> | Record<string, unknown> | Array<Record<string, unknown>> | Uint8Array;
+interface StructuredTypeDescriptor {
+  /**
+   * **Type name**
+   *
+   * Typically the name represents the original type name without any adorners.
+   * For example, `struct:Pose3d`, `struct:Pose3d[]` would be represented
+   * as `Pose3d`, and `proto:wpi.proto.ProtobufPose3d` as `wpi.proto.ProtobufPose3d`.
+   *
+   * To determine if the parsed value is an array, consult `array` indicator and
+   * use `Array.isArray` method.
+   */
+  readonly name: string;
+  /**
+   * **Type format**
+   *
+   * Represents the origin (protocol) of the deserialized data.
+   *
+   * Due to WPILIB idiosyncrasies deserialized JSON representation of the same
+   * structured type may differ across various serialization protocols.
+   */
+  readonly format: "protobuf" | "struct" | "composite";
+  /**
+   * **Array indicator**
+   *
+   * Indicates that the value contains a top-level array of type.
+   */
+  readonly isArray?: boolean;
+}
+interface DataChannelRecord<T extends DataTypeImpl = DataTypeImpl> {
+  /**
+   * **Timestamp (microseconds)**
+   *
+   * Timestamp of the record in microseconds. Typically represents robot time.
+   */
+  readonly timestamp: number;
+  /**
+   * **Value**
+   *
+   * Record value. Depends on the {@link DataChannel.dataType}.
+   */
+  value: T;
+}
+interface DataChannelBase<T extends DataTypeImpl = DataTypeImpl> {
+  /**
+   * **Channel source**
+   *
+   * For example, `nt` or `wpilog`. This field is considered opaque.
+   */
+  readonly source: string;
+  /**
+   * **Channel identifier**
+   *
+   * Must be unique within the data source.
+   * NT4 — topic name
+   * WPILOG — data channel identifier
+   */
+  readonly id: string;
+  /**
+   * **Data representation type**
+   *
+   * This type indicates the processed data representation in the Javascript world.
+   * For example, NT4 source may differentiate between numeric types, such as
+   * 32-bit integer and 64-bit float, yet both are stored as `number`.
+   *
+   * Complex types are typically serialized using JSON, msgpack, struct or protobuf
+   * protocols and require a corresponding data transformer to be registered in
+   * the pipeline to unpack them. If no transformer is present the raw `binary`
+   * representation is used where data is stored in a byte array buffer.
+   */
+  readonly dataType: DataType;
+  /**
+   * **Raw data type**
+   *
+   * Raw data type string to be used for publishing. Retains original type specifics
+   * that cannot be represented in the JavaScript world, such as differences between
+   * various numeric types.
+   */
+  readonly publishedDataType: string;
+  /**
+   * **Protocol transformer**
+   *
+   * Unpacks raw binary data into JSON object according to the serialization protocol.
+   */
+  readonly transformer?: DataTransformer;
+  /**
+   * **Structured type descriptor**
+   *
+   * Applicable to complex types, serialized as struct or protobuf. Must be set
+   * by the corresponding transformer.
+   */
+  structuredType?: StructuredTypeDescriptor;
+  /**
+   * **Channel metadata**
+   *
+   * For NT4 metadata is extracted from topic properties beyond the default set.
+   * For WPILOG metadata is read and attempted to be parsed as JSON object first
+   * and stored as string otherwise.
+   *
+   * This field represents the most recently seen values as published by the source.
+   */
+  metadata?: Record<string, unknown> | string;
+  /**
+   * **Timestamped records**
+   *
+   * Timestamps are provided by the data source. The array is sorted by the timestamp
+   * in ascending order, earlier records have smaller indices.
+   */
+  records?: Array<DataChannelRecord<T>>;
+  /**
+   * **Timestamped dead-letter queue**
+   *
+   * Records that cannot be yet unpacked due to missing type descriptors.
+   *
+   * Timestamps are provided by the data source. The array is sorted by the timestamp
+   * in ascending order, earlier records have smaller indices.
+   */
+  dlq?: Array<DataChannelRecord<Uint8Array>>;
+  /**
+   * **Composite channel container**
+   *
+   * Returns the container composite channel for sub-channels that are part of it.
+   */
+  composite?: CompositeDataChannel;
+  /**
+   * **Publishes value to the channel**
+   *
+   * @param value value to publish
+   * @param path optional path to the sub-channel
+   * @param options additional publisher options
+   */
+  publish?: (value: unknown, path?: ReadonlyArray<string>, options?: DataChannelPublisherOptions) => void;
+}
+interface BooleanDataChannel extends DataChannelBase<boolean> {
+  readonly dataType: "boolean";
+}
+interface StringDataChannel extends DataChannelBase<string> {
+  readonly dataType: "string";
+}
+interface NumberDataChannel extends DataChannelBase<number> {
+  readonly dataType: "number";
+}
+interface BooleanArrayDataChannel extends DataChannelBase<Array<boolean>> {
+  readonly dataType: "booleanArray";
+}
+interface StringArrayDataChannel extends DataChannelBase<Array<string>> {
+  readonly dataType: "stringArray";
+}
+interface NumberArrayDataChannel extends DataChannelBase<Array<number>> {
+  readonly dataType: "numberArray";
+}
+interface JsonDataChannel extends DataChannelBase<Record<string, unknown>> {
+  readonly dataType: "json";
+}
+interface BinaryDataChannel extends DataChannelBase<Uint8Array> {
+  readonly dataType: "binary";
+}
+interface CompositeDataChannel extends DataChannelBase<Record<string, unknown>> {
+  readonly dataType: "composite";
+  /**
+   * **Sub-channel identifiers and record paths**
+   *
+   * Identifiers of individual data channels that comprise this composite channel
+   * and their respective paths for the data to be written in the JSON record.
+   */
+  channels: Map<string, Array<string>>;
+}
+/**
+ * Represents an abstract data channel extracted from one of the supported data sources,
+ * such as NetworkTables or WPILOG.
+ *
+ * A channel tracks one or more data values as a set of timestamped records.
+ */
+type DataChannel = BooleanDataChannel | StringDataChannel | NumberDataChannel | BooleanArrayDataChannel | StringArrayDataChannel | NumberArrayDataChannel | JsonDataChannel | BinaryDataChannel | CompositeDataChannel;
+/**
+ * Represents a transformer in the data pipeline.
+ *
+ * Transformers enable conversion of raw binary data into one of the supported
+ * {@link DataType} formats. For example, unpacking `struct`, `protobuf` or `msgpack`
+ * binary data requires a corresponding transformer.
+ *
+ * Some transforms, e.g. `struct` or `protobuf` may require schema, transported
+ * separately from the data block entries.
+ */
+interface DataTransformer {
+  /**
+   * Inspects a channel to determine whether it represents a schema or a data channel
+   * that must run through this transformer.
+   *
+   * This method must return either a {@link DataChannel} instance indicating a data
+   * channel, which must have {@link DataChannel.transformer} field set, or a string
+   * containing the schema type name indicating a schema channel. Otherwise,
+   * a value of `undefined` must be returned.
+   *
+   * @param source source
+   * @param name channel name
+   * @param type channel type
+   * @param metadata channel metadata
+   * @returns data channel, schema type name or `undefined`
+   */
+  inspect(source: string, name: string, type: string, metadata?: Record<string, unknown> | string): DataChannel | string | undefined;
+  /**
+   * Ingests raw schema data for the specified type name. This method will be invoked
+   * when the data arrives on a schema channel previously identified by {@link inspect}.
+   *
+   * @param typeName schema type name previously returned by {@link inspect}
+   * @param value raw schema data
+   */
+  schema(typeName: string, value: unknown): void;
+  /**
+   * Deserializes raw data. If the data cannot be transformed yet due to missing
+   * schema dependencies, this method must return `undefined` and the data will
+   * stored in the dead-letter queue to retry automatically at a later time.
+   *
+   * @param value raw value to deserialize
+   * @param type an optional {@link DataChannel.structuredType} descriptor
+   * @returns a deserialized value on success or `undefined` otherwise
+   */
+  deserialize(value: unknown, type?: StructuredTypeDescriptor): DataTypeImpl | undefined;
+  /**
+   * Serializes data into a raw format for publishing.
+   *
+   * @param value value to serialize
+   * @param type an optional {@link DataChannel.structuredType} descriptor
+   * @returns a serialized representation of the value
+   */
+  serialize(value: unknown, type?: StructuredTypeDescriptor): string | Uint8Array;
+  /**
+   * Determines whether data with the specified `type` can be transformed.
+   *
+   * The transformer may not be able to transform certain types if it is missing
+   * corresponding type descriptors yet to arrive via schema channel.
+   *
+   * @param type type name
+   */
+  canTransform(type: string): boolean;
+}
+interface DataChannelPublisherOptions {
+  /** Published structured type */
+  structuredType?: StructuredTypeDescriptor;
+}
+//#endregion
+export { BinaryDataChannel, BooleanArrayDataChannel, BooleanDataChannel, CompositeDataChannel, DataChannel, DataChannelBase, DataChannelPublisherOptions, DataChannelRecord, DataTransformer, DataType, DataTypeImpl, JsonDataChannel, NumberArrayDataChannel, NumberDataChannel, StringArrayDataChannel, StringDataChannel, StructuredTypeDescriptor };
+//# sourceMappingURL=abstractions.d.cts.map

package/dist/abstractions.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions.d.cts","names":[],"sources":["../src/abstractions.ts"],"sourcesContent":[],"mappings":";KAAY,QAAA;AAAA,KAWA,YAAA,GAXQ,OAAA,GAAA,MAAA,GAAA,MAAA,GAehB,KAfgB,CAAA,OAAA,CAAA,GAgBhB,KAhBgB,CAAA,MAAA,CAAA,GAiBhB,KAjBgB,CAAA,MAAA,CAAA,GAkBhB,MAlBgB,CAAA,MAAA,EAAA,OAAA,CAAA,GAmBhB,KAnBgB,CAmBV,MAnBU,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAoBhB,UApBgB;AAWR,UAWK,wBAAA,CAXO;EAIpB;;;;;;;;AAOJ;AA+BA;EAA6C,SAAA,IAAA,EAAA,MAAA;EAAe;;;AAgB5D;;;;;EAqDmB,SAAA,MAAA,EAAA,UAAA,GAAA,QAAA,GAAA,WAAA;EAWN;;;;;EAkBC,SAAA,OAAA,CAAA,EAAA,OAAA;;AAOA,UAzGG,iBAyGH,CAAA,UAzG+B,YAyG/B,GAzG8C,YAyG9C,CAAA,CAAA;EASsB;;;AAGpC;AAIA;EAIiB,SAAA,SAAA,EAAkB,MAAA;EAIlB;AAIjB;AAIA;AAIA;AAIA;EAIiB,KAAA,EAxIR,CAwIQ;;AASO,UA9IP,eA8IO,CAAA,UA9ImB,YA8InB,GA9IkC,YA8IlC,CAAA,CAAA;EAAZ;;;AASZ;;EAEI,SAAA,MAAA,EAAA,MAAA;EACA;;;;;;;EAMoB,SAAA,EAAA,EAAA,MAAA;EAYP;;;;;;;;AA+DjB;;;;qBA9MqB;;;;;;;;;;;;;;yBAgBI;;;;;;;mBAQN;;;;;;;;;;aAWN;;;;;;;YAQD,MAAM,kBAAkB;;;;;;;;;QAU5B,MAAM,kBAAkB;;;;;;cAOlB;;;;;;;;oCASsB,iCAAiC;;UAGpD,kBAAA,SAA2B;;;UAI3B,iBAAA,SAA0B;;;UAI1B,iBAAA,SAA0B;;;UAI1B,uBAAA,SAAgC,gBAAgB;;;UAIhD,sBAAA,SAA+B,gBAAgB;;;UAI/C,sBAAA,SAA+B,gBAAgB;;;UAI/C,eAAA,SAAwB,gBAAgB;;;UAIxC,iBAAA,SAA0B,gBAAgB;;;UAI1C,oBAAA,SAA6B,gBAAgB;;;;;;;;YASlD,YAAY;;;;;;;;KASZ,WAAA,GACR,qBACA,oBACA,oBACA,0BACA,yBACA,yBACA,kBACA,oBACA;;;;;;;;;;;UAYa,eAAA;;;;;;;;;;;;;;;;iEAoBF,mCACV;;;;;;;;;;;;;;;;;;qCAoBgC,2BAA2B;;;;;;;;mCAS7B,oCAAoC;;;;;;;;;;;UAatD,2BAAA;;mBAEE"}

package/dist/abstractions.d.mts

@@ -0,0 +1,246 @@
+//#region src/abstractions.d.ts
+type DataType = "boolean" | "string" | "number" | "booleanArray" | "stringArray" | "numberArray" | "json" | "binary" | "composite";
+type DataTypeImpl = boolean | string | number | Array<boolean> | Array<string> | Array<number> | Record<string, unknown> | Array<Record<string, unknown>> | Uint8Array;
+interface StructuredTypeDescriptor {
+  /**
+   * **Type name**
+   *
+   * Typically the name represents the original type name without any adorners.
+   * For example, `struct:Pose3d`, `struct:Pose3d[]` would be represented
+   * as `Pose3d`, and `proto:wpi.proto.ProtobufPose3d` as `wpi.proto.ProtobufPose3d`.
+   *
+   * To determine if the parsed value is an array, consult `array` indicator and
+   * use `Array.isArray` method.
+   */
+  readonly name: string;
+  /**
+   * **Type format**
+   *
+   * Represents the origin (protocol) of the deserialized data.
+   *
+   * Due to WPILIB idiosyncrasies deserialized JSON representation of the same
+   * structured type may differ across various serialization protocols.
+   */
+  readonly format: "protobuf" | "struct" | "composite";
+  /**
+   * **Array indicator**
+   *
+   * Indicates that the value contains a top-level array of type.
+   */
+  readonly isArray?: boolean;
+}
+interface DataChannelRecord<T extends DataTypeImpl = DataTypeImpl> {
+  /**
+   * **Timestamp (microseconds)**
+   *
+   * Timestamp of the record in microseconds. Typically represents robot time.
+   */
+  readonly timestamp: number;
+  /**
+   * **Value**
+   *
+   * Record value. Depends on the {@link DataChannel.dataType}.
+   */
+  value: T;
+}
+interface DataChannelBase<T extends DataTypeImpl = DataTypeImpl> {
+  /**
+   * **Channel source**
+   *
+   * For example, `nt` or `wpilog`. This field is considered opaque.
+   */
+  readonly source: string;
+  /**
+   * **Channel identifier**
+   *
+   * Must be unique within the data source.
+   * NT4 — topic name
+   * WPILOG — data channel identifier
+   */
+  readonly id: string;
+  /**
+   * **Data representation type**
+   *
+   * This type indicates the processed data representation in the Javascript world.
+   * For example, NT4 source may differentiate between numeric types, such as
+   * 32-bit integer and 64-bit float, yet both are stored as `number`.
+   *
+   * Complex types are typically serialized using JSON, msgpack, struct or protobuf
+   * protocols and require a corresponding data transformer to be registered in
+   * the pipeline to unpack them. If no transformer is present the raw `binary`
+   * representation is used where data is stored in a byte array buffer.
+   */
+  readonly dataType: DataType;
+  /**
+   * **Raw data type**
+   *
+   * Raw data type string to be used for publishing. Retains original type specifics
+   * that cannot be represented in the JavaScript world, such as differences between
+   * various numeric types.
+   */
+  readonly publishedDataType: string;
+  /**
+   * **Protocol transformer**
+   *
+   * Unpacks raw binary data into JSON object according to the serialization protocol.
+   */
+  readonly transformer?: DataTransformer;
+  /**
+   * **Structured type descriptor**
+   *
+   * Applicable to complex types, serialized as struct or protobuf. Must be set
+   * by the corresponding transformer.
+   */
+  structuredType?: StructuredTypeDescriptor;
+  /**
+   * **Channel metadata**
+   *
+   * For NT4 metadata is extracted from topic properties beyond the default set.
+   * For WPILOG metadata is read and attempted to be parsed as JSON object first
+   * and stored as string otherwise.
+   *
+   * This field represents the most recently seen values as published by the source.
+   */
+  metadata?: Record<string, unknown> | string;
+  /**
+   * **Timestamped records**
+   *
+   * Timestamps are provided by the data source. The array is sorted by the timestamp
+   * in ascending order, earlier records have smaller indices.
+   */
+  records?: Array<DataChannelRecord<T>>;
+  /**
+   * **Timestamped dead-letter queue**
+   *
+   * Records that cannot be yet unpacked due to missing type descriptors.
+   *
+   * Timestamps are provided by the data source. The array is sorted by the timestamp
+   * in ascending order, earlier records have smaller indices.
+   */
+  dlq?: Array<DataChannelRecord<Uint8Array>>;
+  /**
+   * **Composite channel container**
+   *
+   * Returns the container composite channel for sub-channels that are part of it.
+   */
+  composite?: CompositeDataChannel;
+  /**
+   * **Publishes value to the channel**
+   *
+   * @param value value to publish
+   * @param path optional path to the sub-channel
+   * @param options additional publisher options
+   */
+  publish?: (value: unknown, path?: ReadonlyArray<string>, options?: DataChannelPublisherOptions) => void;
+}
+interface BooleanDataChannel extends DataChannelBase<boolean> {
+  readonly dataType: "boolean";
+}
+interface StringDataChannel extends DataChannelBase<string> {
+  readonly dataType: "string";
+}
+interface NumberDataChannel extends DataChannelBase<number> {
+  readonly dataType: "number";
+}
+interface BooleanArrayDataChannel extends DataChannelBase<Array<boolean>> {
+  readonly dataType: "booleanArray";
+}
+interface StringArrayDataChannel extends DataChannelBase<Array<string>> {
+  readonly dataType: "stringArray";
+}
+interface NumberArrayDataChannel extends DataChannelBase<Array<number>> {
+  readonly dataType: "numberArray";
+}
+interface JsonDataChannel extends DataChannelBase<Record<string, unknown>> {
+  readonly dataType: "json";
+}
+interface BinaryDataChannel extends DataChannelBase<Uint8Array> {
+  readonly dataType: "binary";
+}
+interface CompositeDataChannel extends DataChannelBase<Record<string, unknown>> {
+  readonly dataType: "composite";
+  /**
+   * **Sub-channel identifiers and record paths**
+   *
+   * Identifiers of individual data channels that comprise this composite channel
+   * and their respective paths for the data to be written in the JSON record.
+   */
+  channels: Map<string, Array<string>>;
+}
+/**
+ * Represents an abstract data channel extracted from one of the supported data sources,
+ * such as NetworkTables or WPILOG.
+ *
+ * A channel tracks one or more data values as a set of timestamped records.
+ */
+type DataChannel = BooleanDataChannel | StringDataChannel | NumberDataChannel | BooleanArrayDataChannel | StringArrayDataChannel | NumberArrayDataChannel | JsonDataChannel | BinaryDataChannel | CompositeDataChannel;
+/**
+ * Represents a transformer in the data pipeline.
+ *
+ * Transformers enable conversion of raw binary data into one of the supported
+ * {@link DataType} formats. For example, unpacking `struct`, `protobuf` or `msgpack`
+ * binary data requires a corresponding transformer.
+ *
+ * Some transforms, e.g. `struct` or `protobuf` may require schema, transported
+ * separately from the data block entries.
+ */
+interface DataTransformer {
+  /**
+   * Inspects a channel to determine whether it represents a schema or a data channel
+   * that must run through this transformer.
+   *
+   * This method must return either a {@link DataChannel} instance indicating a data
+   * channel, which must have {@link DataChannel.transformer} field set, or a string
+   * containing the schema type name indicating a schema channel. Otherwise,
+   * a value of `undefined` must be returned.
+   *
+   * @param source source
+   * @param name channel name
+   * @param type channel type
+   * @param metadata channel metadata
+   * @returns data channel, schema type name or `undefined`
+   */
+  inspect(source: string, name: string, type: string, metadata?: Record<string, unknown> | string): DataChannel | string | undefined;
+  /**
+   * Ingests raw schema data for the specified type name. This method will be invoked
+   * when the data arrives on a schema channel previously identified by {@link inspect}.
+   *
+   * @param typeName schema type name previously returned by {@link inspect}
+   * @param value raw schema data
+   */
+  schema(typeName: string, value: unknown): void;
+  /**
+   * Deserializes raw data. If the data cannot be transformed yet due to missing
+   * schema dependencies, this method must return `undefined` and the data will
+   * stored in the dead-letter queue to retry automatically at a later time.
+   *
+   * @param value raw value to deserialize
+   * @param type an optional {@link DataChannel.structuredType} descriptor
+   * @returns a deserialized value on success or `undefined` otherwise
+   */
+  deserialize(value: unknown, type?: StructuredTypeDescriptor): DataTypeImpl | undefined;
+  /**
+   * Serializes data into a raw format for publishing.
+   *
+   * @param value value to serialize
+   * @param type an optional {@link DataChannel.structuredType} descriptor
+   * @returns a serialized representation of the value
+   */
+  serialize(value: unknown, type?: StructuredTypeDescriptor): string | Uint8Array;
+  /**
+   * Determines whether data with the specified `type` can be transformed.
+   *
+   * The transformer may not be able to transform certain types if it is missing
+   * corresponding type descriptors yet to arrive via schema channel.
+   *
+   * @param type type name
+   */
+  canTransform(type: string): boolean;
+}
+interface DataChannelPublisherOptions {
+  /** Published structured type */
+  structuredType?: StructuredTypeDescriptor;
+}
+//#endregion
+export { BinaryDataChannel, BooleanArrayDataChannel, BooleanDataChannel, CompositeDataChannel, DataChannel, DataChannelBase, DataChannelPublisherOptions, DataChannelRecord, DataTransformer, DataType, DataTypeImpl, JsonDataChannel, NumberArrayDataChannel, NumberDataChannel, StringArrayDataChannel, StringDataChannel, StructuredTypeDescriptor };
+//# sourceMappingURL=abstractions.d.mts.map

package/dist/abstractions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions.d.mts","names":[],"sources":["../src/abstractions.ts"],"sourcesContent":[],"mappings":";KAAY,QAAA;AAAA,KAWA,YAAA,GAXQ,OAAA,GAAA,MAAA,GAAA,MAAA,GAehB,KAfgB,CAAA,OAAA,CAAA,GAgBhB,KAhBgB,CAAA,MAAA,CAAA,GAiBhB,KAjBgB,CAAA,MAAA,CAAA,GAkBhB,MAlBgB,CAAA,MAAA,EAAA,OAAA,CAAA,GAmBhB,KAnBgB,CAmBV,MAnBU,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAoBhB,UApBgB;AAWR,UAWK,wBAAA,CAXO;EAIpB;;;;;;;;AAOJ;AA+BA;EAA6C,SAAA,IAAA,EAAA,MAAA;EAAe;;;AAgB5D;;;;;EAqDmB,SAAA,MAAA,EAAA,UAAA,GAAA,QAAA,GAAA,WAAA;EAWN;;;;;EAkBC,SAAA,OAAA,CAAA,EAAA,OAAA;;AAOA,UAzGG,iBAyGH,CAAA,UAzG+B,YAyG/B,GAzG8C,YAyG9C,CAAA,CAAA;EASsB;;;AAGpC;AAIA;EAIiB,SAAA,SAAA,EAAkB,MAAA;EAIlB;AAIjB;AAIA;AAIA;AAIA;EAIiB,KAAA,EAxIR,CAwIQ;;AASO,UA9IP,eA8IO,CAAA,UA9ImB,YA8InB,GA9IkC,YA8IlC,CAAA,CAAA;EAAZ;;;AASZ;;EAEI,SAAA,MAAA,EAAA,MAAA;EACA;;;;;;;EAMoB,SAAA,EAAA,EAAA,MAAA;EAYP;;;;;;;;AA+DjB;;;;qBA9MqB;;;;;;;;;;;;;;yBAgBI;;;;;;;mBAQN;;;;;;;;;;aAWN;;;;;;;YAQD,MAAM,kBAAkB;;;;;;;;;QAU5B,MAAM,kBAAkB;;;;;;cAOlB;;;;;;;;oCASsB,iCAAiC;;UAGpD,kBAAA,SAA2B;;;UAI3B,iBAAA,SAA0B;;;UAI1B,iBAAA,SAA0B;;;UAI1B,uBAAA,SAAgC,gBAAgB;;;UAIhD,sBAAA,SAA+B,gBAAgB;;;UAI/C,sBAAA,SAA+B,gBAAgB;;;UAI/C,eAAA,SAAwB,gBAAgB;;;UAIxC,iBAAA,SAA0B,gBAAgB;;;UAI1C,oBAAA,SAA6B,gBAAgB;;;;;;;;YASlD,YAAY;;;;;;;;KASZ,WAAA,GACR,qBACA,oBACA,oBACA,0BACA,yBACA,yBACA,kBACA,oBACA;;;;;;;;;;;UAYa,eAAA;;;;;;;;;;;;;;;;iEAoBF,mCACV;;;;;;;;;;;;;;;;;;qCAoBgC,2BAA2B;;;;;;;;mCAS7B,oCAAoC;;;;;;;;;;;UAatD,2BAAA;;mBAEE"}

package/dist/abstractions.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/formats/json.cjs

@@ -0,0 +1,32 @@
+const require_utils = require('../utils.cjs');
+
+//#region src/formats/json.ts
+const utf8decoder = new TextDecoder("utf-8", { fatal: true });
+/** Implements {@link DataTransformer} interface for the `json` serialization protocol. */
+var JsonDataTransformer = class {
+	inspect(source, name, type, metadata) {
+		if (type === "json") return {
+			source,
+			id: name,
+			dataType: "json",
+			publishedDataType: type,
+			transformer: this,
+			metadata
+		};
+	}
+	schema() {}
+	deserialize(value) {
+		if (typeof value === "string") return value ? JSON.parse(value) : {};
+		return JSON.parse(utf8decoder.decode(require_utils.toUint8Array(value)));
+	}
+	serialize(value) {
+		if (value == null || typeof value !== "object") throw new Error("Only JSON objects can be serialized");
+		return JSON.stringify(value);
+	}
+	canTransform() {
+		return true;
+	}
+};
+
+//#endregion
+exports.JsonDataTransformer = JsonDataTransformer;

package/dist/formats/json.d.cts

@@ -0,0 +1,14 @@
+import { DataChannel, DataTransformer, DataTypeImpl } from "../abstractions.cjs";
+
+//#region src/formats/json.d.ts
+/** Implements {@link DataTransformer} interface for the `json` serialization protocol. */
+declare class JsonDataTransformer implements DataTransformer {
+  inspect(source: string, name: string, type: string, metadata?: string | Record<string, unknown>): DataChannel | string | undefined;
+  schema(): void;
+  deserialize(value: unknown): DataTypeImpl | undefined;
+  serialize(value: unknown): string | Uint8Array;
+  canTransform(): boolean;
+}
+//#endregion
+export { JsonDataTransformer };
+//# sourceMappingURL=json.d.cts.map

package/dist/formats/json.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.cts","names":[],"sources":["../../src/formats/json.ts"],"sourcesContent":[],"mappings":";;;;cAUa,mBAAA,YAA+B;EAA/B,OAAA,CAAA,MAAA,EAAA,MAAoB,EAAA,IAAA,EAAA,MAAA,EAAA,IAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EAAA,MAAA,GAKT,MALS,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAM5B,WAN4B,GAAA,MAAA,GAAA,SAAA;EAKT,MAAA,CAAA,CAAA,EAAA,IAAA;EACnB,WAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAiBiC,YAjBjC,GAAA,SAAA;EAiBiC,SAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA,GAQO,UARP;EAQO,YAAA,CAAA,CAAA,EAAA,OAAA"}

package/dist/formats/json.d.mts

@@ -0,0 +1,14 @@
+import { DataChannel, DataTransformer, DataTypeImpl } from "../abstractions.mjs";
+
+//#region src/formats/json.d.ts
+/** Implements {@link DataTransformer} interface for the `json` serialization protocol. */
+declare class JsonDataTransformer implements DataTransformer {
+  inspect(source: string, name: string, type: string, metadata?: string | Record<string, unknown>): DataChannel | string | undefined;
+  schema(): void;
+  deserialize(value: unknown): DataTypeImpl | undefined;
+  serialize(value: unknown): string | Uint8Array;
+  canTransform(): boolean;
+}
+//#endregion
+export { JsonDataTransformer };
+//# sourceMappingURL=json.d.mts.map

package/dist/formats/json.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.mts","names":[],"sources":["../../src/formats/json.ts"],"sourcesContent":[],"mappings":";;;;cAUa,mBAAA,YAA+B;EAA/B,OAAA,CAAA,MAAA,EAAA,MAAoB,EAAA,IAAA,EAAA,MAAA,EAAA,IAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EAAA,MAAA,GAKT,MALS,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAM5B,WAN4B,GAAA,MAAA,GAAA,SAAA;EAKT,MAAA,CAAA,CAAA,EAAA,IAAA;EACnB,WAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAiBiC,YAjBjC,GAAA,SAAA;EAiBiC,SAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA,GAQO,UARP;EAQO,YAAA,CAAA,CAAA,EAAA,OAAA"}

package/dist/formats/json.mjs

@@ -0,0 +1,33 @@
+import { toUint8Array } from "../utils.mjs";
+
+//#region src/formats/json.ts
+const utf8decoder = new TextDecoder("utf-8", { fatal: true });
+/** Implements {@link DataTransformer} interface for the `json` serialization protocol. */
+var JsonDataTransformer = class {
+	inspect(source, name, type, metadata) {
+		if (type === "json") return {
+			source,
+			id: name,
+			dataType: "json",
+			publishedDataType: type,
+			transformer: this,
+			metadata
+		};
+	}
+	schema() {}
+	deserialize(value) {
+		if (typeof value === "string") return value ? JSON.parse(value) : {};
+		return JSON.parse(utf8decoder.decode(toUint8Array(value)));
+	}
+	serialize(value) {
+		if (value == null || typeof value !== "object") throw new Error("Only JSON objects can be serialized");
+		return JSON.stringify(value);
+	}
+	canTransform() {
+		return true;
+	}
+};
+
+//#endregion
+export { JsonDataTransformer };
+//# sourceMappingURL=json.mjs.map

package/dist/formats/json.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.mjs","names":[],"sources":["../../src/formats/json.ts"],"sourcesContent":["import { toUint8Array } from \"../utils\";\n\nimport type { DataChannel, DataTransformer, DataTypeImpl } from \"../abstractions\";\n\nconst utf8decoder = new TextDecoder(\"utf-8\", {\n  // throw TypeError on invalid data instead of silent substitution\n  fatal: true,\n});\n\n/** Implements {@link DataTransformer} interface for the `json` serialization protocol. */\nexport class JsonDataTransformer implements DataTransformer {\n  public inspect(\n    source: string,\n    name: string,\n    type: string,\n    metadata?: string | Record<string, unknown>\n  ): DataChannel | string | undefined {\n    if (type === \"json\") {\n      return {\n        source,\n        id: name,\n        dataType: \"json\",\n        publishedDataType: type,\n        transformer: this,\n        metadata,\n      };\n    }\n\n    return undefined;\n  }\n\n  public schema() {}\n\n  public deserialize(value: unknown): DataTypeImpl | undefined {\n    if (typeof value === \"string\") {\n      return value ? JSON.parse(value) : {};\n    }\n\n    return JSON.parse(utf8decoder.decode(toUint8Array(value)));\n  }\n\n  public serialize(value: unknown): string | Uint8Array {\n    if (value == null || typeof value !== \"object\") {\n      throw new Error(\"Only JSON objects can be serialized\");\n    }\n\n    return JSON.stringify(value);\n  }\n\n  public canTransform(): boolean {\n    return true;\n  }\n}\n"],"mappings":";;;AAIA,MAAM,cAAc,IAAI,YAAY,SAAS,EAE3C,OAAO,MACR,CAAC;;AAGF,IAAa,sBAAb,MAA4D;CAC1D,AAAO,QACL,QACA,MACA,MACA,UACkC;AAClC,MAAI,SAAS,OACX,QAAO;GACL;GACA,IAAI;GACJ,UAAU;GACV,mBAAmB;GACnB,aAAa;GACb;GACD;;CAML,AAAO,SAAS;CAEhB,AAAO,YAAY,OAA0C;AAC3D,MAAI,OAAO,UAAU,SACnB,QAAO,QAAQ,KAAK,MAAM,MAAM,GAAG,EAAE;AAGvC,SAAO,KAAK,MAAM,YAAY,OAAO,aAAa,MAAM,CAAC,CAAC;;CAG5D,AAAO,UAAU,OAAqC;AACpD,MAAI,SAAS,QAAQ,OAAO,UAAU,SACpC,OAAM,IAAI,MAAM,sCAAsC;AAGxD,SAAO,KAAK,UAAU,MAAM;;CAG9B,AAAO,eAAwB;AAC7B,SAAO"}