@dwn-protocol/id-sdk 0.2.5 → 0.2.6

package/src/common/convert.ts

@@ -1,424 +0,0 @@
-import type { Multibase } from 'multiformats';
-
-import { base58btc } from 'multiformats/bases/base58';
-import { base64url } from 'multiformats/bases/base64';
-
-import { isAsyncIterable, isArrayBufferSlice, universalTypeOf } from './type-utils.js';
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-export class Convert {
-  data: any;
-  format: string;
-
-  constructor(data: any, format: string) {
-    this.data = data;
-    this.format = format;
-  }
-
-  static arrayBuffer(data: ArrayBuffer): Convert {
-    return new Convert(data, 'ArrayBuffer');
-  }
-
-  static asyncIterable(data: AsyncIterable<any>): Convert {
-    if (!isAsyncIterable(data)) {
-      throw new TypeError('Input must be of type AsyncIterable.');
-    }
-    return new Convert(data, 'AsyncIterable');
-  }
-
-  static base58Btc(data: string): Convert {
-    return new Convert(data, 'Base58Btc');
-  }
-
-  static base64Url(data: string): Convert {
-    return new Convert(data, 'Base64Url');
-  }
-
-  /**
-   * Reference:
-   * The BufferSource type is a TypeScript type that represents an ArrayBuffer
-   * or one of the ArrayBufferView types, such a TypedArray (e.g., Uint8Array)
-   * or a DataView.
-   */
-  static bufferSource(data: BufferSource): Convert {
-    return new Convert(data, 'BufferSource');
-  }
-
-  static hex(data: string): Convert {
-    if (typeof data !== 'string') {
-      throw new TypeError('Hex input must be a string.');
-    }
-    if (data.length % 2 !== 0) {
-      throw new TypeError('Hex input must have an even number of characters.');
-    }
-    return new Convert(data, 'Hex');
-  }
-
-  static multibase(data: string): Convert {
-    return new Convert(data, 'Multibase');
-  }
-
-  static object(data: Record<string, any>): Convert {
-    return new Convert(data, 'Object');
-  }
-
-  static string(data: string): Convert {
-    return new Convert(data, 'String');
-  }
-
-  static uint8Array(data: Uint8Array): Convert {
-    return new Convert(data, 'Uint8Array');
-  }
-
-  toArrayBuffer(): ArrayBuffer {
-    switch (this.format) {
-
-      case 'Base58Btc': {
-        return base58btc.baseDecode(this.data).buffer;
-      }
-
-      case 'Base64Url': {
-        return base64url.baseDecode(this.data).buffer;
-      }
-
-      case 'BufferSource': {
-        const dataType = universalTypeOf(this.data);
-        if (dataType === 'ArrayBuffer') {
-          // Data is already an ArrayBuffer, No conversion is necessary.
-          return this.data;
-        } else if (ArrayBuffer.isView(this.data)) {
-          // Data is a DataView or a different TypedArray (e.g., Uint16Array).
-          if (isArrayBufferSlice(this.data)) {
-            // Data is a slice of an ArrayBuffer. Return a new ArrayBuffer or ArrayBufferView of the same slice.
-            return this.data.buffer.slice(this.data.byteOffset, this.data.byteOffset + this.data.byteLength);
-          } else {
-            // Data is a whole ArrayBuffer viewed as a different TypedArray or DataView. Return the whole ArrayBuffer.
-            return this.data.buffer;
-          }
-        } else {
-          throw new TypeError(`${this.format} value is not of type: ArrayBuffer, DataView, or TypedArray.`);
-        }
-      }
-
-      case 'Hex': {
-        return this.toUint8Array().buffer;
-      }
-
-      case 'String': {
-        return this.toUint8Array().buffer;
-      }
-
-      case 'Uint8Array': {
-        return this.data.buffer;
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to ArrayBuffer is not supported.`);
-    }
-  }
-
-  async toArrayBufferAsync(): Promise<ArrayBuffer> {
-    switch (this.format) {
-      case 'AsyncIterable': {
-        const blob = await this.toBlobAsync();
-        return await blob.arrayBuffer();
-      }
-
-      default:
-        throw new TypeError(`Asynchronous conversion from ${this.format} to ArrayBuffer is not supported.`);
-    }
-  }
-
-  toBase58Btc(): string {
-    switch (this.format) {
-
-      case 'ArrayBuffer': {
-        const u8a = new Uint8Array(this.data);
-        return base58btc.baseEncode(u8a);
-      }
-
-      case 'Multibase': {
-        return this.data.substring(1);
-      }
-
-      case 'Uint8Array': {
-        return base58btc.baseEncode(this.data);
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Base58Btc is not supported.`);
-    }
-  }
-
-  toBase64Url(): string {
-    switch (this.format) {
-
-      case 'ArrayBuffer': {
-        const u8a = new Uint8Array(this.data);
-        return base64url.baseEncode(u8a);
-      }
-
-      case 'BufferSource': {
-        const u8a = this.toUint8Array();
-        return base64url.baseEncode(u8a);
-      }
-
-      case 'Object': {
-        const string = JSON.stringify(this.data);
-        const u8a = textEncoder.encode(string);
-        return base64url.baseEncode(u8a);
-      }
-
-      case 'String': {
-        const u8a = textEncoder.encode(this.data);
-        return base64url.baseEncode(u8a);
-      }
-
-      case 'Uint8Array': {
-        return base64url.baseEncode(this.data);
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Base64Url is not supported.`);
-    }
-  }
-
-  async toBlobAsync(): Promise<Blob> {
-    switch (this.format) {
-      case 'AsyncIterable': {
-        // Initialize an array to hold the chunks from the AsyncIterable.
-        const chunks = [];
-
-        // Asynchronously iterate over each chunk in the AsyncIterable.
-        for await (const chunk of (this.data as AsyncIterable<any>)) {
-          // Append each chunk to the chunks array. These chunks can be of any type, typically binary data or text.
-          chunks.push(chunk);
-        }
-
-        // Create a new Blob from the aggregated chunks.
-        // The Blob constructor combines these chunks into a single Blob object.
-        const blob = new Blob(chunks);
-
-        return blob;
-      }
-
-      default:
-        throw new TypeError(`Asynchronous conversion from ${this.format} to Blob is not supported.`);
-    }
-  }
-
-  toHex(): string {
-    // pre-calculating Hex values improves runtime by 6-10x.
-    const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-
-    switch (this.format) {
-
-      case 'ArrayBuffer': {
-        const u8a = this.toUint8Array();
-        return Convert.uint8Array(u8a).toHex();
-      }
-
-      case 'Base64Url': {
-        const u8a = this.toUint8Array();
-        return Convert.uint8Array(u8a).toHex();
-      }
-
-      case 'Uint8Array': {
-        let hex = '';
-        for (let i = 0; i < this.data.length; i++) {
-          hex += hexes[this.data[i]];
-        }
-        return hex;
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Hex is not supported.`);
-    }
-  }
-
-  toMultibase(): Multibase<any> {
-    switch (this.format) {
-      case 'Base58Btc': {
-        return `z${this.data}`;
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Multibase is not supported.`);
-    }
-  }
-
-  toObject(): object {
-    switch (this.format) {
-
-      case 'Base64Url': {
-        const u8a = base64url.baseDecode(this.data);
-        const text = textDecoder.decode(u8a);
-        return JSON.parse(text);
-      }
-
-      case 'String': {
-        return JSON.parse(this.data);
-      }
-
-      case 'Uint8Array': {
-        const text = textDecoder.decode(this.data);
-        return JSON.parse(text);
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Object is not supported.`);
-    }
-  }
-
-  async toObjectAsync(): Promise<any> {
-    switch (this.format) {
-      case 'AsyncIterable': {
-        // Convert the AsyncIterable to a String.
-        const text = await this.toStringAsync();
-
-        // Parse the string as JSON. This step assumes that the string represents a valid JSON structure.
-        // JSON.parse() will convert the string into a corresponding JavaScript object.
-        const json = JSON.parse(text);
-
-        // Return the parsed JavaScript object. The type of this object will depend on the structure
-        // of the JSON in the stream. It could be an object, array, string, number, etc.
-        return json;
-      }
-
-      default:
-        throw new TypeError(`Asynchronous conversion from ${this.format} to Object is not supported.`);
-    }
-  }
-
-  toString(): string {
-    switch (this.format) {
-
-      case 'ArrayBuffer': {
-        return textDecoder.decode(this.data);
-      }
-
-      case 'Base64Url': {
-        const u8a = base64url.baseDecode(this.data);
-        return textDecoder.decode(u8a);
-      }
-
-      case 'Object': {
-        return JSON.stringify(this.data);
-      }
-
-      case 'Uint8Array': {
-        return textDecoder.decode(this.data);
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to String is not supported.`);
-    }
-  }
-
-  async toStringAsync(): Promise<string> {
-    switch (this.format) {
-      case 'AsyncIterable': {
-        // Initialize an empty string to accumulate the decoded text.
-        let str = '';
-
-        // Iterate over the chunks from the AsyncIterable.
-        for await (const chunk of (this.data as AsyncIterable<any>)) {
-          // If the chunk is already a string, concatenate it directly.
-          if (typeof chunk === 'string')
-            str += chunk;
-          else
-          // If the chunk is a Uint8Array or similar, use the decoder to convert it to a string.
-          // The `stream: true` option lets the decoder handle multi-byte characters spanning
-          // multiple chunks.
-            str += textDecoder.decode(chunk, { stream: true });
-        }
-
-        // Finalize the decoding process to handle any remaining bytes and signal the end of the stream.
-        // The `stream: false` option flushes the decoder's internal state.
-        str += textDecoder.decode(undefined, { stream: false });
-
-        // Return the accumulated string.
-        return str;
-      }
-
-      default:
-        throw new TypeError(`Asynchronous conversion from ${this.format} to String is not supported.`);
-    }
-  }
-
-  toUint8Array(): Uint8Array {
-    switch (this.format) {
-
-      case 'ArrayBuffer': {
-        // Çreate Uint8Array as a view on the ArrayBuffer.
-        // Note: The Uint8Array shares the same memory as the ArrayBuffer, so this operation is very efficient.
-        return new Uint8Array(this.data);
-      }
-
-      case 'Base58Btc': {
-        return base58btc.baseDecode(this.data);
-      }
-
-      case 'Base64Url': {
-        return base64url.baseDecode(this.data);
-      }
-
-      case 'BufferSource': {
-        const dataType = universalTypeOf(this.data);
-        if (dataType === 'Uint8Array') {
-          // Data is already a Uint8Array. No conversion is necessary.
-          // Note: Uint8Array is a type of BufferSource.
-          return this.data;
-        } else if (dataType === 'ArrayBuffer') {
-          // Data is an ArrayBuffer, create Uint8Array as a view on the ArrayBuffer.
-          // Note: The Uint8Array shares the same memory as the ArrayBuffer, so this operation is very efficient.
-          return new Uint8Array(this.data);
-        } else if (ArrayBuffer.isView(this.data)) {
-          // Data is a DataView or a different TypedArray (e.g., Uint16Array).
-          return new Uint8Array(this.data.buffer, this.data.byteOffset, this.data.byteLength);
-        } else {
-          throw new TypeError(`${this.format} value is not of type: ArrayBuffer, DataView, or TypedArray.`);
-        }
-      }
-
-      case 'Hex': {
-        const u8a = new Uint8Array(this.data.length / 2);
-        for (let i = 0; i < this.data.length; i += 2) {
-          const byteValue = parseInt(this.data.substring(i, i + 2), 16);
-          if (isNaN(byteValue)) {
-            throw new TypeError('Input is not a valid hexadecimal string.');
-          }
-          u8a[i / 2] = byteValue;
-        }
-        return u8a;
-      }
-
-      case 'Object': {
-        const string = JSON.stringify(this.data);
-        return textEncoder.encode(string);
-      }
-
-      case 'String': {
-        return textEncoder.encode(this.data);
-      }
-
-      default:
-        throw new TypeError(`Conversion from ${this.format} to Uint8Array is not supported.`);
-    }
-  }
-
-  async toUint8ArrayAsync(): Promise<Uint8Array> {
-    switch (this.format) {
-      case 'AsyncIterable': {
-        const arrayBuffer = await this.toArrayBufferAsync();
-        return new Uint8Array(arrayBuffer);
-      }
-
-      default:
-        throw new TypeError(`Asynchronous conversion from ${this.format} to Uint8Array is not supported.`);
-    }
-  }
-
-}

package/src/common/index.ts

@@ -1,9 +0,0 @@
-export type * from './types.js';
-
-export * from './convert.js';
-export * from './multicodec.js';
-export * from './object.js';
-export * from './stores.js';
-export * from './stream.js';
-export * from './stream-node.js';
-export * from './type-utils.js';

package/src/common/multicodec.ts

@@ -1,176 +0,0 @@
-import { varint } from 'multiformats';
-
-export type MulticodecCode = number;
-
-export type MulticodecDefinition<MulticodecCode> = {
-  code: MulticodecCode;
-  // codeBytes: Uint8Array;
-  name: string;
-}
-
-/**
- * The `Multicodec` class provides an interface to prepend binary data
- * with a prefix that identifies the data that follows.
- * https://github.com/multiformats/multicodec/blob/master/table.csv
- *
- * Multicodec is a self-describing multiformat, it wraps other formats with
- * a tiny bit of self-description. A multicodec identifier is a
- * varint (variable integer) that indicates the format of the data.
- *
- * The canonical table of multicodecs can be access at the following URL:
- * https://github.com/multiformats/multicodec/blob/master/table.csv
- *
- * Example usage:
- *
- * ```ts
- * Multicodec.registerCodec({ code: 0xed, name: 'ed25519-pub' });
- * const prefixedData = Multicodec.addPrefix({ code: 0xed, data: new Uint8Array(32) });
- * ```
- */
-export class Multicodec {
-  /**
-   * A static field containing a map of codec codes to their corresponding names.
-   */
-  static codeToName = new Map<MulticodecCode, string>();
-
-  /**
-   * A static field containing a map of codec names to their corresponding codes.
-   */
-  static nameToCode = new Map<string, MulticodecCode>();
-
-  /**
-   * Adds a multicodec prefix to input data.
-   *
-   * @param options - The options for adding a prefix.
-   * @param options.code - The codec code. Either the code or name must be provided.
-   * @param options.name - The codec name. Either the code or name must be provided.
-   * @param options.data - The data to be prefixed.
-   * @returns The data with the added prefix as a Uint8Array.
-   */
-  public static addPrefix(options: {
-    code?: MulticodecCode,
-    data: Uint8Array,
-    name?: string,
-  }): Uint8Array {
-    let { code, data, name } = options;
-
-    if (!(name ? !code : code)) {
-      throw new Error(`Either 'name' or 'code' must be defined, but not both.`);
-    }
-
-    // If code was given, confirm it exists, or lookup code by name.
-    code = Multicodec.codeToName.has(code!) ? code : Multicodec.nameToCode.get(name!);
-
-    // Throw error if a registered Codec wasn't found.
-    if (code === undefined) {
-      throw new Error(`Unsupported multicodec: ${options.name ?? options.code}`);
-    }
-
-    // Create a new array to store the prefix and input data.
-    const prefixLength = varint.encodingLength(code);
-    const dataWithPrefix = new Uint8Array(prefixLength + data.byteLength);
-    dataWithPrefix.set(data, prefixLength);
-
-    // Prepend the prefix.
-    varint.encodeTo(code, dataWithPrefix);
-
-    return dataWithPrefix;
-  }
-
-  /**
-   * Get the Multicodec code from given prefixed data.
-   *
-   * @param options - The options for getting the codec code.
-   * @param options.prefixedData - The data to extract the codec code from.
-   * @returns - The Multicodec code as a number.
-   */
-  public static getCodeFromData(options: {
-    prefixedData: Uint8Array
-  }): MulticodecCode {
-    const { prefixedData } = options;
-    const [code, _] = varint.decode(prefixedData);
-
-    return code;
-  }
-
-  /**
-   * Get the Multicodec code from given Multicodec name.
-   *
-   * @param options - The options for getting the codec code.
-   * @param options.name - The name to lookup.
-   * @returns - The Multicodec code as a number.
-   */
-  public static getCodeFromName(options: {
-    name: string
-  }): MulticodecCode {
-    const { name } = options;
-
-    // Throw error if a registered Codec wasn't found.
-    const code = Multicodec.nameToCode.get(name);
-    if (code === undefined) {
-      throw new Error(`Unsupported multicodec: ${name}`);
-    }
-
-    return code;
-  }
-
-  /**
-   * Get the Multicodec name from given Multicodec code.
-   *
-   * @param options - The options for getting the codec name.
-   * @param options.name - The code to lookup.
-   * @returns - The Multicodec name as a string.
-   */
-  public static getNameFromCode(options: {
-    code: MulticodecCode
-  }): string {
-    const { code } = options;
-
-    // Throw error if a registered Codec wasn't found.
-    const name = Multicodec.codeToName.get(code);
-    if (name === undefined) {
-      throw new Error(`Unsupported multicodec: ${code}`);
-    }
-
-    return name;
-  }
-
-  /**
-   * Registers a new codec in the Multicodec class.
-   *
-   * @param codec - The codec to be registered.
-   */
-  public static registerCodec(codec: MulticodecDefinition<MulticodecCode>) {
-    Multicodec.codeToName.set(codec.code, codec.name);
-    Multicodec.nameToCode.set(codec.name, codec.code);
-  }
-
-  /**
-   * Returns the data with the Multicodec prefix removed.
-   *
-   * @param refixedData - The data to extract the codec code from.
-   * @returns {Uint8Array}
-   */
-  public static removePrefix(options: {
-    prefixedData: Uint8Array
-  }): { code: MulticodecCode, name: string, data: Uint8Array } {
-    const { prefixedData } = options;
-    const [code, codeByteLength] = varint.decode(prefixedData);
-
-    // Throw error if a registered Codec wasn't found.
-    const name = Multicodec.codeToName.get(code);
-    if (name === undefined) {
-      throw new Error(`Unsupported multicodec: ${code}`);
-    }
-
-    return { code, data: prefixedData.slice(codeByteLength), name };
-  }
-}
-
-// Pre-defined registered codecs:
-Multicodec.registerCodec({ code: 0xed, name: 'ed25519-pub' });
-Multicodec.registerCodec({ code: 0x1300, name: 'ed25519-priv' });
-Multicodec.registerCodec({ code: 0xec, name: 'x25519-pub' });
-Multicodec.registerCodec({ code: 0x1302, name: 'x25519-priv' });
-Multicodec.registerCodec({ code: 0xe7, name: 'secp256k1-pub' });
-Multicodec.registerCodec({ code: 0x1301, name: 'secp256k1-priv' });

package/src/common/object.ts

@@ -1,43 +0,0 @@
-/**
- * Checks whether the given object has any properties.
- */
-export function isEmptyObject(obj: unknown): boolean {
-  if (typeof obj !== 'object' || obj === null) {
-    return false;
-  }
-
-  if (Object.getOwnPropertySymbols(obj).length > 0) {
-    return false;
-  }
-
-  return Object.keys(obj).length === 0;
-}
-
-/**
- * Recursively removes all properties with an empty object or array as its value from the given object.
- */
-export function removeEmptyObjects(obj: Record<string, unknown>): void {
-  Object.keys(obj).forEach(key => {
-    if (typeof(obj[key]) === 'object') {
-      // recursive remove empty object or array properties in nested objects
-      removeEmptyObjects(obj[key] as Record<string, unknown>);
-    }
-
-    if (isEmptyObject(obj[key])) {
-      delete obj[key];
-    }
-  });
-}
-
-/**
- * Recursively removes all properties with `undefined` as its value from the given object.
- */
-export function removeUndefinedProperties(obj: Record<string, unknown>): void {
-  Object.keys(obj).forEach(key => {
-    if (obj[key] === undefined) {
-      delete obj[key];
-    } else if (typeof(obj[key]) === 'object') {
-      removeUndefinedProperties(obj[key] as Record<string, unknown>); // recursive remove `undefined` properties in nested objects
-    }
-  });
-}