npm - @ledgerhq/device-management-kit - Versions diffs - 0.0.0-legacy-speculos-datasource-20250820121907 → 0.0.0-multisig-20250821134850 - Mend

@ledgerhq/device-management-kit 0.0.0-legacy-speculos-datasource-20250820121907 → 0.0.0-multisig-20250821134850

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/lib/cjs/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/device-management-kit",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "license": "Apache-2.0",
   "exports": {

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var h=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var g=(i,r)=>{for(var t in r)h(i,t,{get:r[t],enumerable:!0})},m=(i,r,t,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of f(r))!y.call(i,e)&&e!==t&&h(i,e,{get:()=>r[e],enumerable:!(a=b(r,e))||a.enumerable});return i};var l=i=>m(h({},"__esModule",{value:!0}),i);var D={};g(D,{ByteArrayBuilder:()=>A});module.exports=l(D);var B=require("../../utils/HexaString"),n=require("./AppBuilderError");const T=4294967295;class A{constructor(r=T){this.maxPayloadSize=r}data=new Uint8Array;errors=[];build=()=>this.data;tryBuild=()=>this.hasErrors()?void 0:this.data;add8BitUIntToData=r=>this.addNumberToData(r,8n,!1,!1);add16BitUIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!1,t);add32BitUIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!1,t);add64BitUIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!1,t);add128BitUIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!1,t);add256BitUIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!1,t);add16BitIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!0,t);add32BitIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!0,t);add64BitIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!0,t);add128BitIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!0,t);add256BitIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!0,t);addBufferToData=r=>this.hasEnoughLengthRemaining(r)?(this.data=Uint8Array.from([...this.data,...r]),this):(this.errors.push(new n.DataOverflowError(r.toString())),this);addHexaStringToData=r=>{const t=(0,B.hexaStringToBuffer)(r);return t===null||t.length===0?(this.errors.push(new n.HexaStringEncodeError(r)),this):(this.addBufferToData(t),this)};addAsciiStringToData=r=>{const t=new TextEncoder().encode(r);return this.addBufferToData(t),this};encodeInLVFromHexa=r=>{const t=(0,B.hexaStringToBuffer)(r);return t===null||t.length===0?(this.errors.push(new n.HexaStringEncodeError(r)),this):this.hasEnoughLengthRemaining(t,!0)?(this.add8BitUIntToData(t.length),this.addBufferToData(t),this):(this.errors.push(new n.DataOverflowError(r)),this)};encodeInLVFromBuffer=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addBufferToData(r),this):(this.errors.push(new n.DataOverflowError(r.toString())),this);encodeInLVFromAscii=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addAsciiStringToData(r),this):(this.errors.push(new n.DataOverflowError(r)),this);encodeInTLVFromHexa=(r,t)=>(this.add8BitUIntToData(r),this.encodeInLVFromHexa(t));encodeInTLVFromBuffer=(r,t)=>(this.add8BitUIntToData(r),this.encodeInLVFromBuffer(t));encodeInTLVFromUInt64=(r,t,a=!0)=>(this.add8BitUIntToData(r),this.add8BitUIntToData(8),this.add64BitUIntToData(t,a));getAvailablePayloadLength=()=>this.maxPayloadSize-this.data.length;getErrors=()=>this.errors;hasErrors=()=>this.errors.length!==0;hasEnoughLengthRemaining=(r,t=!1)=>this.data.length+r.length+(t?1:0)<=this.maxPayloadSize;addNumberToData(r,t,a,e){let o=this.checkBoundsAndConvert(r,t,a);if(o===void 0)return this;const s=Number(t)/8,u=new Uint8Array(s);if(e)for(let d=s-1;d>=0;d--)u[d]=Number(o&0xffn),o>>=8n;else for(let d=0;d<s;d++)u[d]=Number(o&0xffn),o>>=8n;return this.addBufferToData(u)}checkBoundsAndConvert(r,t,a){if(typeof r=="number"){if(!Number.isInteger(r)||r>Number.MAX_SAFE_INTEGER){this.errors.push(new n.ValueOverflowError(r.toString()));return}r=BigInt(r)}if(a){const e=1n<<t-1n;if(r>=e||r<-e){this.errors.push(new n.ValueOverflowError(r.toString(),e-1n));return}if(r<0n){const o=(1n<<t)-1n;r=-r,r=(~r&o)+1n}}else{const e=1n<<t;if(r<0||r>=e){this.errors.push(new n.ValueOverflowError(r.toString(),e-1n));return}}return r}}0&&(module.exports={ByteArrayBuilder});
+"use strict";var h=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var f=(a,t)=>{for(var r in t)h(a,r,{get:t[r],enumerable:!0})},g=(a,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of m(t))!y.call(a,e)&&e!==r&&h(a,e,{get:()=>t[e],enumerable:!(n=b(t,e))||n.enumerable});return a};var l=a=>g(h({},"__esModule",{value:!0}),a);var A={};f(A,{ByteArrayBuilder:()=>D});module.exports=l(A);var B=require("../../utils/HexaString"),i=require("./AppBuilderError");const T=4294967295;class D{constructor(t=T){this.maxPayloadSize=t}data=new Uint8Array;errors=[];build=()=>this.data;tryBuild=()=>this.hasErrors()?void 0:this.data;add8BitUIntToData=t=>this.addNumberToData(t,8n,!1,!1);add16BitUIntToData=(t,r=!0)=>this.addNumberToData(t,16n,!1,r);add32BitUIntToData=(t,r=!0)=>this.addNumberToData(t,32n,!1,r);add64BitUIntToData=(t,r=!0)=>this.addNumberToData(t,64n,!1,r);add128BitUIntToData=(t,r=!0)=>this.addNumberToData(t,128n,!1,r);add256BitUIntToData=(t,r=!0)=>this.addNumberToData(t,256n,!1,r);add16BitIntToData=(t,r=!0)=>this.addNumberToData(t,16n,!0,r);add32BitIntToData=(t,r=!0)=>this.addNumberToData(t,32n,!0,r);add64BitIntToData=(t,r=!0)=>this.addNumberToData(t,64n,!0,r);add128BitIntToData=(t,r=!0)=>this.addNumberToData(t,128n,!0,r);add256BitIntToData=(t,r=!0)=>this.addNumberToData(t,256n,!0,r);addBufferToData=t=>this.hasEnoughLengthRemaining(t)?(this.data=Uint8Array.from([...this.data,...t]),this):(this.errors.push(new i.DataOverflowError(t.toString())),this);addHexaStringToData=t=>{const r=(0,B.hexaStringToBuffer)(t);return r===null||r.length===0?(this.errors.push(new i.HexaStringEncodeError(t)),this):(this.addBufferToData(r),this)};addAsciiStringToData=t=>{const r=new TextEncoder().encode(t);return this.addBufferToData(r),this};encodeInLVFromHexa=t=>{const r=(0,B.hexaStringToBuffer)(t);return r===null||r.length===0?(this.errors.push(new i.HexaStringEncodeError(t)),this):this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addBufferToData(r),this):(this.errors.push(new i.DataOverflowError(t)),this)};encodeInLVFromBuffer=t=>this.hasEnoughLengthRemaining(t,!0)?(this.add8BitUIntToData(t.length),this.addBufferToData(t),this):(this.errors.push(new i.DataOverflowError(t.toString())),this);encodeInLVFromAscii=t=>this.hasEnoughLengthRemaining(t,!0)?(this.add8BitUIntToData(t.length),this.addAsciiStringToData(t),this):(this.errors.push(new i.DataOverflowError(t)),this);encodeInTLVFromAscii=(t,r)=>(this.add8BitUIntToData(t),this.encodeInLVFromAscii(r));encodeInTLVFromHexa=(t,r)=>(this.add8BitUIntToData(t),this.encodeInLVFromHexa(r));encodeInTLVFromBuffer=(t,r)=>(this.add8BitUIntToData(t),this.encodeInLVFromBuffer(r));encodeInTLVFromUInt8=(t,r)=>(this.add8BitUIntToData(t),this.add8BitUIntToData(1),this.add8BitUIntToData(r));encodeInTLVFromUInt16=(t,r,n=!0)=>(this.add8BitUIntToData(t),this.add8BitUIntToData(2),this.add16BitUIntToData(r,n));encodeInTLVFromUInt32=(t,r,n=!0)=>(this.add8BitUIntToData(t),this.add8BitUIntToData(4),this.add32BitUIntToData(r,n));encodeInTLVFromUInt64=(t,r,n=!0)=>(this.add8BitUIntToData(t),this.add8BitUIntToData(8),this.add64BitUIntToData(r,n));getAvailablePayloadLength=()=>this.maxPayloadSize-this.data.length;getErrors=()=>this.errors;hasErrors=()=>this.errors.length!==0;hasEnoughLengthRemaining=(t,r=!1)=>this.data.length+t.length+(r?1:0)<=this.maxPayloadSize;addNumberToData(t,r,n,e){let o=this.checkBoundsAndConvert(t,r,n);if(o===void 0)return this;const u=Number(r)/8,s=new Uint8Array(u);if(e)for(let d=u-1;d>=0;d--)s[d]=Number(o&0xffn),o>>=8n;else for(let d=0;d<u;d++)s[d]=Number(o&0xffn),o>>=8n;return this.addBufferToData(s)}checkBoundsAndConvert(t,r,n){if(typeof t=="number"){if(!Number.isInteger(t)||t>Number.MAX_SAFE_INTEGER){this.errors.push(new i.ValueOverflowError(t.toString()));return}t=BigInt(t)}if(n){const e=1n<<r-1n;if(t>=e||t<-e){this.errors.push(new i.ValueOverflowError(t.toString(),e-1n));return}if(t<0n){const o=(1n<<r)-1n;t=-t,t=(~t&o)+1n}}else{const e=1n<<r;if(t<0||t>=e){this.errors.push(new i.ValueOverflowError(t.toString(),e-1n));return}}return t}}0&&(module.exports={ByteArrayBuilder});
 //# sourceMappingURL=ByteArrayBuilder.js.map

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport {\n  type AppBuilderError,\n  DataOverflowError,\n  HexaStringEncodeError,\n  ValueOverflowError,\n} from \"./AppBuilderError\";\n\nconst MAX_32_BIT_UINT = 0xffffffff;\n\n/**\n * ByteArrayBuilder is a utility class to help build APDU payloads.\n * It allows to easily add data to the payload of an APDU command\n * and to encode this data in different formats.\n *\n * @example\n * ```\n * const builder = new ByteArrayBuilder(255)\n *  .add8BitUIntToData(0x05)\n *  .add16BitUIntToData(0x0607)\n *  .addHexaStringToData(\"0x0809\")\n *  .addAsciiStringToData(\"hello\")\n *\n * const payload = builder.build();\n * const builderErrors = builder.getErrors();\n * ```\n */\nexport class ByteArrayBuilder {\n  private data: Uint8Array = new Uint8Array();\n  private readonly errors: AppBuilderError[] = []; // Custom Error\n\n  constructor(private maxPayloadSize: number = MAX_32_BIT_UINT) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Build a new payload instance with the current state of the builder\n   * @returns {payload} - Returns a new payload instance\n   */\n  build = (): Uint8Array => this.data;\n\n  /**\n   * Try to build a new payload instance with the current state of the builder\n   * if the builder don't contain any error.\n   * @returns {payload | undefined} - Returns a new payload instance or undefined\n   */\n  tryBuild = (): Uint8Array | undefined => {\n    return this.hasErrors() ? undefined : this.data;\n  };\n\n  /**\n   * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)\n   * @param value: number | bigint - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add8BitUIntToData = (value: number | bigint): ByteArrayBuilder => {\n    return this.addNumberToData(value, 8n, false, false);\n  };\n\n  /**\n   * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, false, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, false, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, false, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, false, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, false, bigEndian);\n  };\n\n  /**\n   * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, true, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, true, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, true, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, true, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, true, bigEndian);\n  };\n\n  /**\n   * Add a Uint8Array to the payload if it has enough remaining space\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addBufferToData = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.data = Uint8Array.from([...this.data, ...value]);\n    return this;\n  };\n\n  /**\n   * Add a string to the payload if it has enough remaining space\n   * and it can be formatted as a hexadecimal string\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addHexaStringToData = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add an ascii string to the data field if it has enough remaining space\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addAsciiStringToData = (value: string): ByteArrayBuilder => {\n    const bytes = new TextEncoder().encode(value);\n    this.addBufferToData(bytes);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromHexa = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n\n    if (!this.hasEnoughLengthRemaining(result, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n    // values are always being well formatted at this point\n    // therefore no status test is needed\n    this.add8BitUIntToData(result.length);\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded buffer to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromBuffer = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addBufferToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded ascii string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromAscii = (value: string): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addAsciiStringToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromHexa = (tag: number, value: string): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    return this.encodeInLVFromHexa(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: Uint8Array - The buffer to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromBuffer = (\n    tag: number,\n    value: Uint8Array,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    return this.encodeInLVFromBuffer(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded uint64 to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: number | bigint - The number to add\n   * @param bigEndian: boolean - Endianness used to encode the number\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromUInt64 = (\n    tag: number,\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    this.add8BitUIntToData(8);\n    return this.add64BitUIntToData(value, bigEndian);\n  };\n\n  /**\n   * Returns the remaining payload length\n   * @returns {number}\n   */\n  getAvailablePayloadLength = (): number => {\n    return this.maxPayloadSize - this.data.length;\n  };\n\n  /**\n   * Returns the current errors\n   * @returns {AppBuilderError[]} - Returns an array of errors\n   */\n  getErrors = (): AppBuilderError[] => this.errors;\n\n  /**\n   * Verifies if the builder contains errors\n   * @returns {boolean} - Returns wether the builder contains errors or not\n   */\n  hasErrors = (): boolean => this.errors.length !== 0;\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check if there is enough space to add a value to the data field\n   * @param value {string | Uint8Array | number[]} - Value to add to the data\n   * @param hasLv {boolean} - Length-Value encoding flag\n   * @returns {boolean} - Returns true if there is enough space to add the value\n   */\n  private hasEnoughLengthRemaining = (\n    value: string | Uint8Array | number[],\n    hasLv: boolean = false,\n  ): boolean => {\n    return (\n      this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize\n    );\n  };\n\n  /**\n   * Add a number to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - Whether the value is signed or unsigned.\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  private addNumberToData(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): ByteArrayBuilder {\n    // Convert the number to two's complement and check its bounds\n    let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);\n    if (converted === undefined) {\n      return this;\n    }\n\n    // Compute the buffer\n    const sizeInBytes = Number(sizeInBits) / 8;\n    const buffer = new Uint8Array(sizeInBytes);\n    if (bigEndian) {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    } else {\n      for (let i = 0; i < sizeInBytes; i++) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    }\n    return this.addBufferToData(buffer);\n  }\n\n  /**\n   * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.\n   * @param value The value to check and convert.\n   * @param sizeInBits The size of the value in bits.\n   * @param signed Whether the value is signed or unsigned.\n   * @returns The converted value, or null if the value is out of bounds.\n   */\n  private checkBoundsAndConvert(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n  ): bigint | undefined {\n    // Normalize the value to a bigint\n    if (typeof value === \"number\") {\n      if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {\n        this.errors.push(new ValueOverflowError(value.toString()));\n        return;\n      }\n      value = BigInt(value);\n    }\n\n    if (!signed) {\n      // Check if the value is within the bounds of an unsigned integer\n      const limit = 1n << sizeInBits;\n      if (value < 0 || value >= limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n    } else {\n      // Check if the value is within the bounds of a signed integer\n      const limit = 1n << (sizeInBits - 1n);\n      if (value >= limit || value < -limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n\n      // Convert the value to two's complement if it is negative\n      // https://en.wikipedia.org/wiki/Two%27s_complement\n      if (value < 0n) {\n        const mask = (1n << sizeInBits) - 1n;\n        value = -value;\n        value = (~value & mask) + 1n;\n      }\n    }\n    return value;\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport {\n  type AppBuilderError,\n  DataOverflowError,\n  HexaStringEncodeError,\n  ValueOverflowError,\n} from \"./AppBuilderError\";\n\nconst MAX_32_BIT_UINT = 0xffffffff;\n\n/**\n * ByteArrayBuilder is a utility class to help build APDU payloads.\n * It allows to easily add data to the payload of an APDU command\n * and to encode this data in different formats.\n *\n * @example\n * ```\n * const builder = new ByteArrayBuilder(255)\n *  .add8BitUIntToData(0x05)\n *  .add16BitUIntToData(0x0607)\n *  .addHexaStringToData(\"0x0809\")\n *  .addAsciiStringToData(\"hello\")\n *\n * const payload = builder.build();\n * const builderErrors = builder.getErrors();\n * ```\n */\nexport class ByteArrayBuilder {\n  private data: Uint8Array = new Uint8Array();\n  private readonly errors: AppBuilderError[] = []; // Custom Error\n\n  constructor(private maxPayloadSize: number = MAX_32_BIT_UINT) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Build a new payload instance with the current state of the builder\n   * @returns {payload} - Returns a new payload instance\n   */\n  build = (): Uint8Array => this.data;\n\n  /**\n   * Try to build a new payload instance with the current state of the builder\n   * if the builder don't contain any error.\n   * @returns {payload | undefined} - Returns a new payload instance or undefined\n   */\n  tryBuild = (): Uint8Array | undefined => {\n    return this.hasErrors() ? undefined : this.data;\n  };\n\n  /**\n   * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)\n   * @param value: number | bigint - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add8BitUIntToData = (value: number | bigint): ByteArrayBuilder => {\n    return this.addNumberToData(value, 8n, false, false);\n  };\n\n  /**\n   * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, false, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, false, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, false, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, false, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, false, bigEndian);\n  };\n\n  /**\n   * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, true, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, true, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, true, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, true, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, true, bigEndian);\n  };\n\n  /**\n   * Add a Uint8Array to the payload if it has enough remaining space\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addBufferToData = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.data = Uint8Array.from([...this.data, ...value]);\n    return this;\n  };\n\n  /**\n   * Add a string to the payload if it has enough remaining space\n   * and it can be formatted as a hexadecimal string\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addHexaStringToData = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add an ascii string to the data field if it has enough remaining space\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addAsciiStringToData = (value: string): ByteArrayBuilder => {\n    const bytes = new TextEncoder().encode(value);\n    this.addBufferToData(bytes);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromHexa = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n\n    if (!this.hasEnoughLengthRemaining(result, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n    // values are always being well formatted at this point\n    // therefore no status test is needed\n    this.add8BitUIntToData(result.length);\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded buffer to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromBuffer = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addBufferToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded ascii string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromAscii = (value: string): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addAsciiStringToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded ascii string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromAscii = (tag: number, value: string): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    return this.encodeInLVFromAscii(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromHexa = (tag: number, value: string): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    return this.encodeInLVFromHexa(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: Uint8Array - The buffer to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromBuffer = (\n    tag: number,\n    value: Uint8Array,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    return this.encodeInLVFromBuffer(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded uint8 to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: number - The number to add\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromUInt8 = (tag: number, value: number): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    this.add8BitUIntToData(1);\n    return this.add8BitUIntToData(value);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded uint16 to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: number | bigint - The number to add\n   * @param bigEndian: boolean - Endianness used to encode the number\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromUInt16 = (\n    tag: number,\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    this.add8BitUIntToData(2);\n    return this.add16BitUIntToData(value, bigEndian);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded uint32 to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: number | bigint - The number to add\n   * @param bigEndian: boolean - Endianness used to encode the number\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromUInt32 = (\n    tag: number,\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    this.add8BitUIntToData(4);\n    return this.add32BitUIntToData(value, bigEndian);\n  };\n\n  /**\n   * Add a Tag-Length-Value encoded uint64 to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param tag: number - The tag to add to the data\n   * @param value: number | bigint - The number to add\n   * @param bigEndian: boolean - Endianness used to encode the number\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInTLVFromUInt64 = (\n    tag: number,\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    this.add8BitUIntToData(tag);\n    this.add8BitUIntToData(8);\n    return this.add64BitUIntToData(value, bigEndian);\n  };\n\n  /**\n   * Returns the remaining payload length\n   * @returns {number}\n   */\n  getAvailablePayloadLength = (): number => {\n    return this.maxPayloadSize - this.data.length;\n  };\n\n  /**\n   * Returns the current errors\n   * @returns {AppBuilderError[]} - Returns an array of errors\n   */\n  getErrors = (): AppBuilderError[] => this.errors;\n\n  /**\n   * Verifies if the builder contains errors\n   * @returns {boolean} - Returns wether the builder contains errors or not\n   */\n  hasErrors = (): boolean => this.errors.length !== 0;\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check if there is enough space to add a value to the data field\n   * @param value {string | Uint8Array | number[]} - Value to add to the data\n   * @param hasLv {boolean} - Length-Value encoding flag\n   * @returns {boolean} - Returns true if there is enough space to add the value\n   */\n  private hasEnoughLengthRemaining = (\n    value: string | Uint8Array | number[],\n    hasLv: boolean = false,\n  ): boolean => {\n    return (\n      this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize\n    );\n  };\n\n  /**\n   * Add a number to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - Whether the value is signed or unsigned.\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  private addNumberToData(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): ByteArrayBuilder {\n    // Convert the number to two's complement and check its bounds\n    let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);\n    if (converted === undefined) {\n      return this;\n    }\n\n    // Compute the buffer\n    const sizeInBytes = Number(sizeInBits) / 8;\n    const buffer = new Uint8Array(sizeInBytes);\n    if (bigEndian) {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    } else {\n      for (let i = 0; i < sizeInBytes; i++) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    }\n    return this.addBufferToData(buffer);\n  }\n\n  /**\n   * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.\n   * @param value The value to check and convert.\n   * @param sizeInBits The size of the value in bits.\n   * @param signed Whether the value is signed or unsigned.\n   * @returns The converted value, or null if the value is out of bounds.\n   */\n  private checkBoundsAndConvert(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n  ): bigint | undefined {\n    // Normalize the value to a bigint\n    if (typeof value === \"number\") {\n      if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {\n        this.errors.push(new ValueOverflowError(value.toString()));\n        return;\n      }\n      value = BigInt(value);\n    }\n\n    if (!signed) {\n      // Check if the value is within the bounds of an unsigned integer\n      const limit = 1n << sizeInBits;\n      if (value < 0 || value >= limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n    } else {\n      // Check if the value is within the bounds of a signed integer\n      const limit = 1n << (sizeInBits - 1n);\n      if (value >= limit || value < -limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n\n      // Convert the value to two's complement if it is negative\n      // https://en.wikipedia.org/wiki/Two%27s_complement\n      if (value < 0n) {\n        const mask = (1n << sizeInBits) - 1n;\n        value = -value;\n        value = (~value & mask) + 1n;\n      }\n    }\n    return value;\n  }\n}\n"],
+  "mappings": "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",
   "names": ["ByteArrayBuilder_exports", "__export", "ByteArrayBuilder", "__toCommonJS", "import_HexaString", "import_AppBuilderError", "MAX_32_BIT_UINT", "maxPayloadSize", "value", "bigEndian", "result", "bytes", "tag", "hasLv", "sizeInBits", "signed", "converted", "sizeInBytes", "buffer", "i", "limit", "mask"]
 }

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var c=require("../../utils/HexaString"),a=require("./ApduBuilder"),r=require("./AppBuilderError"),l=require("./ByteArrayBuilder");const d=new Uint8Array([]),g=new Uint8Array([1]),y=new Uint8Array([128,129,130,131,132]),A=new Uint8Array([133,134,135,136]),p=new Uint8Array([3,161,162,163]),E=new Uint8Array([5,109,97,109,97,110]),b=new Uint8Array([2,240,241]),h=new Uint8Array([1,51,2,1,35,69,103,128,129,130,131,132,133,134,135,136,3,161,162,163,5,109,97,109,97,110,2,240,241]),x=new Uint8Array([...Array(255).fill(170)]),s=new Uint8Array([...Array(254).fill(170)]);let e;describe("ByteArrayBuilder",()=>{const i=(f,t,o,n)=>{if(n)switch(o){case 2:e.add16BitIntToData(f,t);break;case 4:e.add32BitIntToData(f,t);break;case 8:e.add64BitIntToData(f,t);break;case 16:e.add128BitIntToData(f,t);break;case 32:e.add256BitIntToData(f,t);break}else switch(o){case 2:e.add16BitUIntToData(f,t);break;case 4:e.add32BitUIntToData(f,t);break;case 8:e.add64BitUIntToData(f,t);break;case 16:e.add128BitUIntToData(f,t);break;case 32:e.add256BitUIntToData(f,t);break}};describe("clean",()=>{beforeEach(()=>{e=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should create an instance",()=>{expect(e).toBeDefined(),expect(e).toBeInstanceOf(l.ByteArrayBuilder)})}),describe("simple",()=>{beforeEach(()=>{e=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with an empty body",()=>{expect(e.build()).toEqual(d)}),it("should serialize with an single byte body",()=>{e=new l.ByteArrayBuilder(1),e.add8BitUIntToData(1),expect(e.build()).toEqual(g),expect(e.getErrors()).toEqual([])}),it.each([[2,!1,!0,13058,"3302"],[2,!1,!1,0x3302n,"0233"],[2,!0,!0,4200n,"1068"],[2,!0,!0,-4200n,"ef98"],[2,!0,!1,4200,"6810"],[2,!0,!1,-4200,"98ef"],[4,!1,!0,0x01234567n,"01234567"],[4,!1,!1,0x01234567n,"67452301"],[4,!0,!0,123456789,"075bcd15"],[4,!0,!0,-123456789,"f8a432eb"],[4,!0,!1,123456789,"15cd5b07"],[4,!0,!1,-123456789,"eb32a4f8"],[8,!1,!0,14147778004927559n,"0032435442584447"],[8,!1,!1,14147778004927559n,"4744584254433200"],[8,!0,!0,14147778004927559n,"0032435442584447"],[8,!0,!0,-14147778004927559n,"ffcdbcabbda7bbb9"],[8,!0,!1,14147778004927559n,"4744584254433200"],[8,!0,!1,-14147778004927559n,"b9bba7bdabbccdff"],[16,!1,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!1,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!0,!0,-0x00324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[16,!0,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!1,-0x00324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdff"],[32,!1,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!1,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!0,!0,-0x0032435442584447003243544258444700324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[32,!0,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!1,-0x0032435442584447003243544258444700324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff"]])("serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s",(f,t,o,n,u)=>{e=new l.ByteArrayBuilder(f),i(n,o,f,t),expect(e.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(e.getErrors()).toEqual([]),e=new l.ByteArrayBuilder(f-1),i(n,o,f,t),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it.each([[2,!1,!0,0xffffn,"ffff"],[2,!0,!0,0x7fffn,"7fff"],[2,!0,!0,-0x8000n,"8000"],[4,!1,!0,0xffffffffn,"ffffffff"],[4,!0,!0,0x7fffffffn,"7fffffff"],[4,!0,!0,-0x80000000n,"80000000"],[8,!1,!0,0xffffffffffffffffn,"ffffffffffffffff"],[8,!0,!0,0x7fffffffffffffffn,"7fffffffffffffff"],[8,!0,!0,-0x8000000000000000n,"8000000000000000"],[16,!1,!0,0xffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffff"],[16,!0,!0,0x7fffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffff"],[16,!0,!0,-0x80000000000000000000000000000000n,"80000000000000000000000000000000"],[32,!1,!0,0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,-0x8000000000000000000000000000000000000000000000000000000000000000n,"8000000000000000000000000000000000000000000000000000000000000000"]])("serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s",(f,t,o,n,u)=>{e=new l.ByteArrayBuilder(f),i(n,o,f,t),expect(e.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(e.getErrors()).toEqual([])}),it("Serialize from float to bigint",()=>{e=new l.ByteArrayBuilder(4),e.add32BitIntToData(1234567893e-1,!1),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it("should serialize with an 5 byte body from an hexastring",()=>{e.addHexaStringToData("0x8081828384"),expect(e.build()).toEqual(y),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body from an hexastring without '0x'",()=>{e.addHexaStringToData("85868788"),expect(e.build()).toEqual(A),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an hexastring",()=>{e.encodeInLVFromHexa("0xA1A2A3"),expect(e.build()).toEqual(p),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an ascci string",()=>{e.encodeInLVFromAscii("maman"),expect(e.build()).toEqual(E),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const f=new Uint8Array([240,241]);e.encodeInLVFromBuffer(f),expect(e.build()).toEqual(b),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const f=new Uint8Array([240,241]);e.encodeInLVFromBuffer(f),expect(e.build()).toEqual(b),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an hexastring",()=>{e.encodeInTLVFromHexa(5,"0xA1A2A3"),expect(e.build()).toEqual(Uint8Array.from([5,3,161,162,163])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from a buffer",()=>{e.encodeInTLVFromBuffer(6,Uint8Array.from([161,162,163,164])),expect(e.build()).toEqual(Uint8Array.from([6,4,161,162,163,164])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an uint64",()=>{e.encodeInTLVFromUInt64(6,95075813176406),expect(e.build()).toEqual(Uint8Array.from([6,8,0,0,86,120,144,18,52,86])),expect(e.getErrors()).toEqual([])}),it("should serialize with an complete body of 0xAA",()=>{const f=new Uint8Array(255).fill(170,0,255);e.addBufferToData(f),expect(e.build()).toEqual(x),expect(e.getErrors()).toEqual([])})}),describe("mixed",()=>{beforeEach(()=>{e=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with all previous field",()=>{let f=a.APDU_MAX_PAYLOAD;e.add8BitUIntToData(1),f--,expect(e.getAvailablePayloadLength()).toBe(f),e.add16BitUIntToData(13058),f-=2,expect(e.getAvailablePayloadLength()).toBe(f),e.add32BitUIntToData(19088743),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.addHexaStringToData("0x8081828384"),f-=5,expect(e.getAvailablePayloadLength()).toBe(f),e.addHexaStringToData("85868788"),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.encodeInLVFromHexa("0xA1A2A3"),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.encodeInLVFromAscii("maman"),f-=6,expect(e.getAvailablePayloadLength()).toBe(f);const t=new Uint8Array([240,241]);e.encodeInLVFromBuffer(t),f-=3,expect(e.getAvailablePayloadLength()).toBe(f),expect(e.build()).toEqual(h)})}),describe("error",()=>{beforeEach(()=>{e=new l.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it.each([[2,!1,!0,0x10000n],[2,!0,!0,0x8000n],[2,!0,!0,-0x8001n],[4,!1,!0,0x100000000n],[4,!0,!0,0x80000000n],[4,!0,!0,-0x80000001n],[8,!1,!0,0x10000000000000000n],[8,!0,!0,0x8000000000000000n],[8,!0,!0,-0x8000000000000001n]])("serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i",(f,t,o,n)=>{e=new l.ByteArrayBuilder(f),i(n,o,f,t),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it("error due to a string not well coded",()=>{e.addHexaStringToData(":08081828384").addHexaStringToData("80818n8384").addHexaStringToData("808182838z"),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.HexaStringEncodeError(":08081828384"),new r.HexaStringEncodeError("80818n8384"),new r.HexaStringEncodeError("808182838z")])}),it("error due direct overflow",()=>{const f=new Uint8Array(256).fill(170,0,256);e.addBufferToData(f),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.DataOverflowError(f.toString())])}),it("error due to subsequent overflow with 1-byte array",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0);const t=new Uint8Array(1);t.set([255],0),e.addBufferToData(t),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError(t.toString())])}),it("error due to subsequent overflow with 1-char ascii",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0);const t="a";e.addAsciiStringToData(t),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError(new TextEncoder().encode(t).toString())])}),it("error due to subsequent overflow with 1-char hexastring",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0),e.addHexaStringToData("0xB4").addHexaStringToData("e1"),expect(e.build()).toEqual(x),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError("180"),new r.DataOverflowError("225")])}),it("error due to empty values",()=>{const f="";e.addHexaStringToData(f).encodeInLVFromHexa(f),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.HexaStringEncodeError(f),new r.HexaStringEncodeError(f)])}),it("error due to subsequent overflow with 1-char LV",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD-1).fill(170,0,a.APDU_MAX_PAYLOAD-1);e.addBufferToData(f),expect(e.build()).toEqual(s),expect(e.getAvailablePayloadLength()).toBe(1);const t="n",o="e1",n=new Uint8Array(1);n.set([255],0),e.encodeInLVFromAscii(t).encodeInLVFromHexa(o).encodeInLVFromBuffer(n),expect(e.build()).toEqual(s),expect(e.getAvailablePayloadLength()).toBe(1),expect(e.getErrors()).toEqual([new r.DataOverflowError(t),new r.DataOverflowError(o),new r.DataOverflowError(n.toString())])})})});
+"use strict";var c=require("../../utils/HexaString"),a=require("./ApduBuilder"),r=require("./AppBuilderError"),x=require("./ByteArrayBuilder");const d=new Uint8Array([]),g=new Uint8Array([1]),y=new Uint8Array([128,129,130,131,132]),A=new Uint8Array([133,134,135,136]),E=new Uint8Array([3,161,162,163]),p=new Uint8Array([5,109,97,109,97,110]),b=new Uint8Array([2,240,241]),h=new Uint8Array([1,51,2,1,35,69,103,128,129,130,131,132,133,134,135,136,3,161,162,163,5,109,97,109,97,110,2,240,241]),l=new Uint8Array([...Array(255).fill(170)]),s=new Uint8Array([...Array(254).fill(170)]);let e;describe("ByteArrayBuilder",()=>{const i=(f,t,o,n)=>{if(n)switch(o){case 2:e.add16BitIntToData(f,t);break;case 4:e.add32BitIntToData(f,t);break;case 8:e.add64BitIntToData(f,t);break;case 16:e.add128BitIntToData(f,t);break;case 32:e.add256BitIntToData(f,t);break}else switch(o){case 2:e.add16BitUIntToData(f,t);break;case 4:e.add32BitUIntToData(f,t);break;case 8:e.add64BitUIntToData(f,t);break;case 16:e.add128BitUIntToData(f,t);break;case 32:e.add256BitUIntToData(f,t);break}};describe("clean",()=>{beforeEach(()=>{e=new x.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should create an instance",()=>{expect(e).toBeDefined(),expect(e).toBeInstanceOf(x.ByteArrayBuilder)})}),describe("simple",()=>{beforeEach(()=>{e=new x.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with an empty body",()=>{expect(e.build()).toEqual(d)}),it("should serialize with an single byte body",()=>{e=new x.ByteArrayBuilder(1),e.add8BitUIntToData(1),expect(e.build()).toEqual(g),expect(e.getErrors()).toEqual([])}),it.each([[2,!1,!0,13058,"3302"],[2,!1,!1,0x3302n,"0233"],[2,!0,!0,4200n,"1068"],[2,!0,!0,-4200n,"ef98"],[2,!0,!1,4200,"6810"],[2,!0,!1,-4200,"98ef"],[4,!1,!0,0x01234567n,"01234567"],[4,!1,!1,0x01234567n,"67452301"],[4,!0,!0,123456789,"075bcd15"],[4,!0,!0,-123456789,"f8a432eb"],[4,!0,!1,123456789,"15cd5b07"],[4,!0,!1,-123456789,"eb32a4f8"],[8,!1,!0,14147778004927559n,"0032435442584447"],[8,!1,!1,14147778004927559n,"4744584254433200"],[8,!0,!0,14147778004927559n,"0032435442584447"],[8,!0,!0,-14147778004927559n,"ffcdbcabbda7bbb9"],[8,!0,!1,14147778004927559n,"4744584254433200"],[8,!0,!1,-14147778004927559n,"b9bba7bdabbccdff"],[16,!1,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!1,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!0,!0,-0x00324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[16,!0,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!1,-0x00324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdff"],[32,!1,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!1,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!0,!0,-0x0032435442584447003243544258444700324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[32,!0,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!1,-0x0032435442584447003243544258444700324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff"]])("serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s",(f,t,o,n,u)=>{e=new x.ByteArrayBuilder(f),i(n,o,f,t),expect(e.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(e.getErrors()).toEqual([]),e=new x.ByteArrayBuilder(f-1),i(n,o,f,t),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it.each([[2,!1,!0,0xffffn,"ffff"],[2,!0,!0,0x7fffn,"7fff"],[2,!0,!0,-0x8000n,"8000"],[4,!1,!0,0xffffffffn,"ffffffff"],[4,!0,!0,0x7fffffffn,"7fffffff"],[4,!0,!0,-0x80000000n,"80000000"],[8,!1,!0,0xffffffffffffffffn,"ffffffffffffffff"],[8,!0,!0,0x7fffffffffffffffn,"7fffffffffffffff"],[8,!0,!0,-0x8000000000000000n,"8000000000000000"],[16,!1,!0,0xffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffff"],[16,!0,!0,0x7fffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffff"],[16,!0,!0,-0x80000000000000000000000000000000n,"80000000000000000000000000000000"],[32,!1,!0,0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,-0x8000000000000000000000000000000000000000000000000000000000000000n,"8000000000000000000000000000000000000000000000000000000000000000"]])("serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s",(f,t,o,n,u)=>{e=new x.ByteArrayBuilder(f),i(n,o,f,t),expect(e.build()).toEqual((0,c.hexaStringToBuffer)(u)),expect(e.getErrors()).toEqual([])}),it("Serialize from float to bigint",()=>{e=new x.ByteArrayBuilder(4),e.add32BitIntToData(1234567893e-1,!1),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it("should serialize with an 5 byte body from an hexastring",()=>{e.addHexaStringToData("0x8081828384"),expect(e.build()).toEqual(y),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body from an hexastring without '0x'",()=>{e.addHexaStringToData("85868788"),expect(e.build()).toEqual(A),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an hexastring",()=>{e.encodeInLVFromHexa("0xA1A2A3"),expect(e.build()).toEqual(E),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an ascci string",()=>{e.encodeInLVFromAscii("maman"),expect(e.build()).toEqual(p),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const f=new Uint8Array([240,241]);e.encodeInLVFromBuffer(f),expect(e.build()).toEqual(b),expect(e.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const f=new Uint8Array([240,241]);e.encodeInLVFromBuffer(f),expect(e.build()).toEqual(b),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an ascii string",()=>{e.encodeInTLVFromAscii(5,"coucou"),expect(e.build()).toEqual(Uint8Array.from([5,6,99,111,117,99,111,117])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an hexastring",()=>{e.encodeInTLVFromHexa(5,"0xA1A2A3"),expect(e.build()).toEqual(Uint8Array.from([5,3,161,162,163])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from a buffer",()=>{e.encodeInTLVFromBuffer(6,Uint8Array.from([161,162,163,164])),expect(e.build()).toEqual(Uint8Array.from([6,4,161,162,163,164])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an uint8",()=>{e.encodeInTLVFromUInt8(6,86),expect(e.build()).toEqual(Uint8Array.from([6,1,86])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an uint16",()=>{e.encodeInTLVFromUInt16(6,13398),expect(e.build()).toEqual(Uint8Array.from([6,2,52,86])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an uint32",()=>{e.encodeInTLVFromUInt32(6,2417112150),expect(e.build()).toEqual(Uint8Array.from([6,4,144,18,52,86])),expect(e.getErrors()).toEqual([])}),it("should serialize with an TLV encoded from an uint64",()=>{e.encodeInTLVFromUInt64(6,95075813176406),expect(e.build()).toEqual(Uint8Array.from([6,8,0,0,86,120,144,18,52,86])),expect(e.getErrors()).toEqual([])}),it("should serialize with an complete body of 0xAA",()=>{const f=new Uint8Array(255).fill(170,0,255);e.addBufferToData(f),expect(e.build()).toEqual(l),expect(e.getErrors()).toEqual([])})}),describe("mixed",()=>{beforeEach(()=>{e=new x.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it("should serialize with all previous field",()=>{let f=a.APDU_MAX_PAYLOAD;e.add8BitUIntToData(1),f--,expect(e.getAvailablePayloadLength()).toBe(f),e.add16BitUIntToData(13058),f-=2,expect(e.getAvailablePayloadLength()).toBe(f),e.add32BitUIntToData(19088743),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.addHexaStringToData("0x8081828384"),f-=5,expect(e.getAvailablePayloadLength()).toBe(f),e.addHexaStringToData("85868788"),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.encodeInLVFromHexa("0xA1A2A3"),f-=4,expect(e.getAvailablePayloadLength()).toBe(f),e.encodeInLVFromAscii("maman"),f-=6,expect(e.getAvailablePayloadLength()).toBe(f);const t=new Uint8Array([240,241]);e.encodeInLVFromBuffer(t),f-=3,expect(e.getAvailablePayloadLength()).toBe(f),expect(e.build()).toEqual(h)})}),describe("error",()=>{beforeEach(()=>{e=new x.ByteArrayBuilder(a.APDU_MAX_PAYLOAD)}),it.each([[2,!1,!0,0x10000n],[2,!0,!0,0x8000n],[2,!0,!0,-0x8001n],[4,!1,!0,0x100000000n],[4,!0,!0,0x80000000n],[4,!0,!0,-0x80000001n],[8,!1,!0,0x10000000000000000n],[8,!0,!0,0x8000000000000000n],[8,!0,!0,-0x8000000000000001n]])("serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i",(f,t,o,n)=>{e=new x.ByteArrayBuilder(f),i(n,o,f,t),expect(e.getErrors().length).toEqual(1),expect(e.build()).toEqual(Uint8Array.from([]))}),it("error due to a string not well coded",()=>{e.addHexaStringToData(":08081828384").addHexaStringToData("80818n8384").addHexaStringToData("808182838z"),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.HexaStringEncodeError(":08081828384"),new r.HexaStringEncodeError("80818n8384"),new r.HexaStringEncodeError("808182838z")])}),it("error due direct overflow",()=>{const f=new Uint8Array(256).fill(170,0,256);e.addBufferToData(f),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.DataOverflowError(f.toString())])}),it("error due to subsequent overflow with 1-byte array",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0);const t=new Uint8Array(1);t.set([255],0),e.addBufferToData(t),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError(t.toString())])}),it("error due to subsequent overflow with 1-char ascii",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0);const t="a";e.addAsciiStringToData(t),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError(new TextEncoder().encode(t).toString())])}),it("error due to subsequent overflow with 1-char hexastring",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD).fill(170,0,a.APDU_MAX_PAYLOAD);e.addBufferToData(f),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0),e.addHexaStringToData("0xB4").addHexaStringToData("e1"),expect(e.build()).toEqual(l),expect(e.getAvailablePayloadLength()).toBe(0),expect(e.getErrors()).toEqual([new r.DataOverflowError("180"),new r.DataOverflowError("225")])}),it("error due to empty values",()=>{const f="";e.addHexaStringToData(f).encodeInLVFromHexa(f),expect(e.build()).toEqual(d),expect(e.getAvailablePayloadLength()).toBe(a.APDU_MAX_PAYLOAD),expect(e.getErrors()).toEqual([new r.HexaStringEncodeError(f),new r.HexaStringEncodeError(f)])}),it("error due to subsequent overflow with 1-char LV",()=>{const f=new Uint8Array(a.APDU_MAX_PAYLOAD-1).fill(170,0,a.APDU_MAX_PAYLOAD-1);e.addBufferToData(f),expect(e.build()).toEqual(s),expect(e.getAvailablePayloadLength()).toBe(1);const t="n",o="e1",n=new Uint8Array(1);n.set([255],0),e.encodeInLVFromAscii(t).encodeInLVFromHexa(o).encodeInLVFromBuffer(n),expect(e.build()).toEqual(s),expect(e.getAvailablePayloadLength()).toBe(1),expect(e.getErrors()).toEqual([new r.DataOverflowError(t),new r.DataOverflowError(o),new r.DataOverflowError(n.toString())])})})});
 //# sourceMappingURL=ByteArrayBuilder.test.js.map

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an hexastring\", () => {\n      builder.encodeInTLVFromHexa(0x05, \"0xA1A2A3\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x03, 0xa1, 0xa2, 0xa3]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from a buffer\", () => {\n      builder.encodeInTLVFromBuffer(\n        0x06,\n        Uint8Array.from([0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint64\", () => {\n      builder.encodeInTLVFromUInt64(0x06, 0x567890123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([\n          0x06, 0x08, 0x00, 0x00, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,\n        ]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an ascii string\", () => {\n      builder.encodeInTLVFromAscii(0x05, \"coucou\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x06, 0x63, 0x6f, 0x75, 0x63, 0x6f, 0x75]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an hexastring\", () => {\n      builder.encodeInTLVFromHexa(0x05, \"0xA1A2A3\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x03, 0xa1, 0xa2, 0xa3]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from a buffer\", () => {\n      builder.encodeInTLVFromBuffer(\n        0x06,\n        Uint8Array.from([0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint8\", () => {\n      builder.encodeInTLVFromUInt8(0x06, 0x56);\n      expect(builder.build()).toEqual(Uint8Array.from([0x06, 0x01, 0x56]));\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint16\", () => {\n      builder.encodeInTLVFromUInt16(0x06, 0x3456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x02, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint32\", () => {\n      builder.encodeInTLVFromUInt32(0x06, 0x90123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0x90, 0x12, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint64\", () => {\n      builder.encodeInTLVFromUInt64(0x06, 0x567890123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([\n          0x06, 0x08, 0x00, 0x00, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,\n        ]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_HexaString", "import_ApduBuilder", "import_AppBuilderError", "import_ByteArrayBuilder", "COMMAND_NO_BODY", "COMMAND_BODY_SINGLE", "COMMAND_BODY_HEXA1", "COMMAND_BODY_HEXA2", "COMMAND_BODY_LV_HEXA", "COMMAND_BODY_LV_ASCII", "COMMAND_BODY_LV_ARRAY", "COMMAND_BODY_COMBINED", "COMMAND_BODY_MAX", "COMMAND_BODY_NEARLY", "builder", "builderAddNumber", "num", "bigEndian", "sizeInBits", "signed", "input", "output", "myarray", "available", "mybuffer", "mystring", "firstString", "secondString"]
 }

package/lib/cjs/src/api/device-action/xstate-utils/XStateDeviceAction.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var s=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var x=(n,e)=>{for(var r in e)s(n,r,{get:e[r],enumerable:!0})},D=(n,e,r,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of v(e))!A.call(n,t)&&t!==r&&s(n,t,{get:()=>e[t],enumerable:!(a=b(e,t))||a.enumerable});return n};var E=n=>D(s({},"__esModule",{value:!0}),n);var V={};x(V,{XStateDeviceAction:()=>M});module.exports=E(V);var i=require("rxjs"),d=require("xstate"),o=require("../../device-action/model/DeviceActionState");class M{input;inspect=!1;constructor(e){this.input=e.input,this.inspect=!!e.inspect}_execute(e){const r=this.makeStateMachine(e),a=(0,d.createActor)(r,{input:this.input}),t=new i.ReplaySubject,l=c=>{const{context:u,status:h,output:I,error:y}=c;switch(h){case"active":t.next({status:o.DeviceActionStatus.Pending,intermediateValue:u.intermediateValue});break;case"done":I.caseOf({Left:p=>{t.next({status:o.DeviceActionStatus.Error,error:p})},Right:p=>{t.next({status:o.DeviceActionStatus.Completed,output:p})}}),t.complete();break;case"error":t.error(y),t.complete();break;case"stopped":t.next({status:o.DeviceActionStatus.Stopped}),t.complete();break;default:this._exhaustiveMatchingGuard(h)}},S=new i.Observable(c=>{const u=t.subscribe(c);return()=>{m.unsubscribe(),u.unsubscribe(),a.stop()}}),m=a.subscribe(l);return a.start(),{observable:S.pipe((0,i.share)()),cancel:()=>{a.stop(),m.unsubscribe(),l(a.getSnapshot())}}}_exhaustiveMatchingGuard(e){throw console.log("_exhaustiveMatchingGuard status",e),new Error(`Unhandled status: ${e}`)}}0&&(module.exports={XStateDeviceAction});
+"use strict";var s=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var A=(a,e)=>{for(var t in e)s(a,t,{get:e[t],enumerable:!0})},E=(a,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of y(e))!v.call(a,r)&&r!==t&&s(a,r,{get:()=>e[r],enumerable:!(n=b(e,r))||n.enumerable});return a};var x=a=>E(s({},"__esModule",{value:!0}),a);var M={};A(M,{XStateDeviceAction:()=>D});module.exports=x(M);var i=require("rxjs"),h=require("xstate"),c=require("../../device-action/model/DeviceActionState");class D{input;inspect=!1;constructor(e){this.input=e.input,this.inspect=!!e.inspect}_execute(e){const t=this.makeStateMachine(e);return this._subscribeToStateMachine(t)}_subscribeToStateMachine(e){const t=(0,h.createActor)(e,{input:this.input}),n=new i.ReplaySubject,r=o=>{const{context:u,status:m,output:S,error:I}=o;switch(m){case"active":n.next({status:c.DeviceActionStatus.Pending,intermediateValue:u.intermediateValue});break;case"done":S.caseOf({Left:p=>{n.next({status:c.DeviceActionStatus.Error,error:p})},Right:p=>{n.next({status:c.DeviceActionStatus.Completed,output:p})}}),n.complete();break;case"error":n.error(I),n.complete();break;case"stopped":n.next({status:c.DeviceActionStatus.Stopped}),n.complete();break;default:this._exhaustiveMatchingGuard(m)}},d=new i.Observable(o=>{const u=n.subscribe(o);return()=>{l.unsubscribe(),u.unsubscribe(),t.stop()}}),l=t.subscribe(r);return t.start(),{observable:d.pipe((0,i.share)()),cancel:()=>{t.stop(),l.unsubscribe(),r(t.getSnapshot())}}}_exhaustiveMatchingGuard(e){throw console.log("_exhaustiveMatchingGuard status",e),new Error(`Unhandled status: ${e}`)}}0&&(module.exports={XStateDeviceAction});
 //# sourceMappingURL=XStateDeviceAction.js.map

package/lib/cjs/src/api/device-action/xstate-utils/XStateDeviceAction.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/device-action/xstate-utils/XStateDeviceAction.ts"],
-  "sourcesContent": ["// import { createBrowserInspector } from \"@statelyai/inspect\";\nimport { Observable, ReplaySubject, share } from \"rxjs\";\nimport {\n  createActor,\n  type SnapshotFrom,\n  type StateMachine,\n  type StateSchema,\n} from \"xstate\";\n\nimport {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type ExecuteDeviceActionReturnType,\n  type InternalApi,\n} from \"@api/device-action/DeviceAction\";\nimport {\n  type DeviceActionState,\n  DeviceActionStatus,\n} from \"@api/device-action/model/DeviceActionState\";\nimport { type DmkError } from \"@api/Error\";\n\nimport { type StateMachineTypes } from \"./StateMachineTypes\";\n\nexport type DeviceActionStateMachine<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n  InternalState,\n> = StateMachine<\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"context\"], // context\n  /**\n   * The following usages `any` are OK because this is just a wrapper around the\n   * state machine and we are not directly going to use these types.\n   */\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  any, // event\n  any, // children\n  any, // actor\n  any, // action\n  any, // guard\n  any, // delay\n  any, // state value\n  any, // tag\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"input\"],\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"output\"],\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  any,\n  any,\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  StateSchema\n>;\n\n/**\n * A DeviceAction that uses an XState state machine to execute.\n * It maps the state machine snapshots to the DeviceActionState.\n * This class is abstract and should be extended to implement the state machine.\n */\nexport abstract class XStateDeviceAction<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n  InternalState,\n> implements DeviceAction<Output, Input, Error, IntermediateValue>\n{\n  readonly input: Input;\n  readonly inspect: boolean = false;\n\n  /**\n   *\n   * @param input The input for the DeviceAction\n   * @param inspect If true, the state machine will be inspected in the browser\n   */\n  constructor(args: { input: Input; inspect?: boolean }) {\n    this.input = args.input;\n    this.inspect = Boolean(args.inspect);\n  }\n\n  protected abstract makeStateMachine(\n    internalAPI: InternalApi,\n  ): DeviceActionStateMachine<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >;\n\n  _execute(\n    internalApi: InternalApi,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> {\n    const stateMachine = this.makeStateMachine(internalApi);\n\n    const actor = createActor(stateMachine, {\n      input: this.input,\n      // optional inspector for debugging\n      // inspect: this.inspect ? createBrowserInspector().inspect : undefined,\n    });\n\n    /**\n     * Using a ReplaySubject is important because the first snapshots might be\n     * emitted before the observable is subscribed (if the machine goes through\n     * those states fully synchronously).\n     * This way, we ensure that the subscriber always receives the latest snapshot.\n     * */\n    const subject = new ReplaySubject<\n      DeviceActionState<Output, Error, IntermediateValue>\n    >();\n\n    const handleActorSnapshot = (\n      snapshot: SnapshotFrom<typeof stateMachine>,\n    ) => {\n      const { context, status, output, error } = snapshot;\n      switch (status) {\n        case \"active\":\n          subject.next({\n            status: DeviceActionStatus.Pending,\n            intermediateValue: context.intermediateValue,\n          });\n          break;\n        case \"done\":\n          output.caseOf({\n            Left: (err) => {\n              subject.next({\n                status: DeviceActionStatus.Error,\n                error: err,\n              });\n            },\n            Right: (result) => {\n              subject.next({\n                status: DeviceActionStatus.Completed,\n                output: result,\n              });\n            },\n          });\n          subject.complete();\n          break;\n        case \"error\":\n          // this is an error in the execution of the state machine, it should not happen\n          subject.error(error);\n          subject.complete();\n          break;\n        case \"stopped\":\n          subject.next({\n            status: DeviceActionStatus.Stopped,\n          });\n          subject.complete();\n          break;\n        default:\n          this._exhaustiveMatchingGuard(status);\n      }\n    };\n\n    const observable = new Observable<\n      DeviceActionState<Output, Error, IntermediateValue>\n    >((subscriber) => {\n      const subjectSubscription = subject.subscribe(subscriber);\n      return () => {\n        actorSubscription.unsubscribe();\n        subjectSubscription.unsubscribe();\n        actor.stop(); // stop the actor when the observable is unsubscribed\n      };\n    });\n\n    const actorSubscription = actor.subscribe(handleActorSnapshot);\n    actor.start();\n\n    return {\n      observable: observable.pipe(share()), // share to garantee that once there is no more observer, the actor is stopped\n      cancel: () => {\n        actor.stop();\n        actorSubscription.unsubscribe();\n        handleActorSnapshot(actor.getSnapshot());\n      },\n    };\n  }\n\n  private _exhaustiveMatchingGuard(status: never): never {\n    console.log(\"_exhaustiveMatchingGuard status\", status);\n    throw new Error(`Unhandled status: ${status}`);\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GACA,IAAAI,EAAiD,gBACjDC,EAKO,kBAQPC,EAGO,sDA2DA,MAAeJ,CAOtB,CACW,MACA,QAAmB,GAO5B,YAAYK,EAA2C,CACrD,KAAK,MAAQA,EAAK,MAClB,KAAK,QAAU,EAAQA,EAAK,OAC9B,CAYA,SACEC,EACiE,CACjE,MAAMC,EAAe,KAAK,iBAAiBD,CAAW,EAEhDE,KAAQ,eAAYD,EAAc,CACtC,MAAO,KAAK,KAGd,CAAC,EAQKE,EAAU,IAAI,gBAIdC,EACJC,GACG,CACH,KAAM,CAAE,QAAAC,EAAS,OAAAC,EAAQ,OAAAC,EAAQ,MAAAC,CAAM,EAAIJ,EAC3C,OAAQE,EAAQ,CACd,IAAK,SACHJ,EAAQ,KAAK,CACX,OAAQ,qBAAmB,QAC3B,kBAAmBG,EAAQ,iBAC7B,CAAC,EACD,MACF,IAAK,OACHE,EAAO,OAAO,CACZ,KAAOE,GAAQ,CACbP,EAAQ,KAAK,CACX,OAAQ,qBAAmB,MAC3B,MAAOO,CACT,CAAC,CACH,EACA,MAAQC,GAAW,CACjBR,EAAQ,KAAK,CACX,OAAQ,qBAAmB,UAC3B,OAAQQ,CACV,CAAC,CACH,CACF,CAAC,EACDR,EAAQ,SAAS,EACjB,MACF,IAAK,QAEHA,EAAQ,MAAMM,CAAK,EACnBN,EAAQ,SAAS,EACjB,MACF,IAAK,UACHA,EAAQ,KAAK,CACX,OAAQ,qBAAmB,OAC7B,CAAC,EACDA,EAAQ,SAAS,EACjB,MACF,QACE,KAAK,yBAAyBI,CAAM,CACxC,CACF,EAEMK,EAAa,IAAI,aAEpBC,GAAe,CAChB,MAAMC,EAAsBX,EAAQ,UAAUU,CAAU,EACxD,MAAO,IAAM,CACXE,EAAkB,YAAY,EAC9BD,EAAoB,YAAY,EAChCZ,EAAM,KAAK,CACb,CACF,CAAC,EAEKa,EAAoBb,EAAM,UAAUE,CAAmB,EAC7D,OAAAF,EAAM,MAAM,EAEL,CACL,WAAYU,EAAW,QAAK,SAAM,CAAC,EACnC,OAAQ,IAAM,CACZV,EAAM,KAAK,EACXa,EAAkB,YAAY,EAC9BX,EAAoBF,EAAM,YAAY,CAAC,CACzC,CACF,CACF,CAEQ,yBAAyBK,EAAsB,CACrD,cAAQ,IAAI,kCAAmCA,CAAM,EAC/C,IAAI,MAAM,qBAAqBA,CAAM,EAAE,CAC/C,CACF",
+  "sourcesContent": ["// import { createBrowserInspector } from \"@statelyai/inspect\";\nimport { Observable, ReplaySubject, share } from \"rxjs\";\nimport {\n  createActor,\n  type SnapshotFrom,\n  type StateMachine,\n  type StateSchema,\n} from \"xstate\";\n\nimport {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type ExecuteDeviceActionReturnType,\n  type InternalApi,\n} from \"@api/device-action/DeviceAction\";\nimport {\n  type DeviceActionState,\n  DeviceActionStatus,\n} from \"@api/device-action/model/DeviceActionState\";\nimport { type DmkError } from \"@api/Error\";\n\nimport { type StateMachineTypes } from \"./StateMachineTypes\";\n\nexport type DeviceActionStateMachine<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n  InternalState,\n> = StateMachine<\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"context\"], // context\n  /**\n   * The following usages `any` are OK because this is just a wrapper around the\n   * state machine and we are not directly going to use these types.\n   */\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  any, // event\n  any, // children\n  any, // actor\n  any, // action\n  any, // guard\n  any, // delay\n  any, // state value\n  any, // tag\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"input\"],\n  StateMachineTypes<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >[\"output\"],\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  any,\n  any,\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  StateSchema\n>;\n\n/**\n * A DeviceAction that uses an XState state machine to execute.\n * It maps the state machine snapshots to the DeviceActionState.\n * This class is abstract and should be extended to implement the state machine.\n */\nexport abstract class XStateDeviceAction<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n  InternalState,\n> implements DeviceAction<Output, Input, Error, IntermediateValue>\n{\n  readonly input: Input;\n  readonly inspect: boolean = false;\n\n  /**\n   *\n   * @param input The input for the DeviceAction\n   * @param inspect If true, the state machine will be inspected in the browser\n   */\n  constructor(args: { input: Input; inspect?: boolean }) {\n    this.input = args.input;\n    this.inspect = Boolean(args.inspect);\n  }\n\n  protected abstract makeStateMachine(\n    internalAPI: InternalApi,\n  ): DeviceActionStateMachine<\n    Output,\n    Input,\n    Error,\n    IntermediateValue,\n    InternalState\n  >;\n\n  _execute(\n    internalApi: InternalApi,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> {\n    const stateMachine = this.makeStateMachine(internalApi);\n    return this._subscribeToStateMachine(stateMachine);\n  }\n\n  protected _subscribeToStateMachine(\n    stateMachine: DeviceActionStateMachine<\n      Output,\n      Input,\n      Error,\n      IntermediateValue,\n      InternalState\n    >,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> {\n    const actor = createActor(stateMachine, {\n      input: this.input,\n      // optional inspector for debugging\n      // inspect: this.inspect ? createBrowserInspector().inspect : undefined,\n    });\n\n    /**\n     * Using a ReplaySubject is important because the first snapshots might be\n     * emitted before the observable is subscribed (if the machine goes through\n     * those states fully synchronously).\n     * This way, we ensure that the subscriber always receives the latest snapshot.\n     * */\n    const subject = new ReplaySubject<\n      DeviceActionState<Output, Error, IntermediateValue>\n    >();\n\n    const handleActorSnapshot = (\n      snapshot: SnapshotFrom<typeof stateMachine>,\n    ) => {\n      const { context, status, output, error } = snapshot;\n      switch (status) {\n        case \"active\":\n          subject.next({\n            status: DeviceActionStatus.Pending,\n            intermediateValue: context.intermediateValue,\n          });\n          break;\n        case \"done\":\n          output.caseOf({\n            Left: (err) => {\n              subject.next({\n                status: DeviceActionStatus.Error,\n                error: err,\n              });\n            },\n            Right: (result) => {\n              subject.next({\n                status: DeviceActionStatus.Completed,\n                output: result,\n              });\n            },\n          });\n          subject.complete();\n          break;\n        case \"error\":\n          // this is an error in the execution of the state machine, it should not happen\n          subject.error(error);\n          subject.complete();\n          break;\n        case \"stopped\":\n          subject.next({\n            status: DeviceActionStatus.Stopped,\n          });\n          subject.complete();\n          break;\n        default:\n          this._exhaustiveMatchingGuard(status);\n      }\n    };\n\n    const observable = new Observable<\n      DeviceActionState<Output, Error, IntermediateValue>\n    >((subscriber) => {\n      const subjectSubscription = subject.subscribe(subscriber);\n      return () => {\n        actorSubscription.unsubscribe();\n        subjectSubscription.unsubscribe();\n        actor.stop(); // stop the actor when the observable is unsubscribed\n      };\n    });\n\n    const actorSubscription = actor.subscribe(handleActorSnapshot);\n    actor.start();\n\n    return {\n      observable: observable.pipe(share()), // share to garantee that once there is no more observer, the actor is stopped\n      cancel: () => {\n        actor.stop();\n        actorSubscription.unsubscribe();\n        handleActorSnapshot(actor.getSnapshot());\n      },\n    };\n  }\n\n  private _exhaustiveMatchingGuard(status: never): never {\n    console.log(\"_exhaustiveMatchingGuard status\", status);\n    throw new Error(`Unhandled status: ${status}`);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GACA,IAAAI,EAAiD,gBACjDC,EAKO,kBAQPC,EAGO,sDA2DA,MAAeJ,CAOtB,CACW,MACA,QAAmB,GAO5B,YAAYK,EAA2C,CACrD,KAAK,MAAQA,EAAK,MAClB,KAAK,QAAU,EAAQA,EAAK,OAC9B,CAYA,SACEC,EACiE,CACjE,MAAMC,EAAe,KAAK,iBAAiBD,CAAW,EACtD,OAAO,KAAK,yBAAyBC,CAAY,CACnD,CAEU,yBACRA,EAOiE,CACjE,MAAMC,KAAQ,eAAYD,EAAc,CACtC,MAAO,KAAK,KAGd,CAAC,EAQKE,EAAU,IAAI,gBAIdC,EACJC,GACG,CACH,KAAM,CAAE,QAAAC,EAAS,OAAAC,EAAQ,OAAAC,EAAQ,MAAAC,CAAM,EAAIJ,EAC3C,OAAQE,EAAQ,CACd,IAAK,SACHJ,EAAQ,KAAK,CACX,OAAQ,qBAAmB,QAC3B,kBAAmBG,EAAQ,iBAC7B,CAAC,EACD,MACF,IAAK,OACHE,EAAO,OAAO,CACZ,KAAOE,GAAQ,CACbP,EAAQ,KAAK,CACX,OAAQ,qBAAmB,MAC3B,MAAOO,CACT,CAAC,CACH,EACA,MAAQC,GAAW,CACjBR,EAAQ,KAAK,CACX,OAAQ,qBAAmB,UAC3B,OAAQQ,CACV,CAAC,CACH,CACF,CAAC,EACDR,EAAQ,SAAS,EACjB,MACF,IAAK,QAEHA,EAAQ,MAAMM,CAAK,EACnBN,EAAQ,SAAS,EACjB,MACF,IAAK,UACHA,EAAQ,KAAK,CACX,OAAQ,qBAAmB,OAC7B,CAAC,EACDA,EAAQ,SAAS,EACjB,MACF,QACE,KAAK,yBAAyBI,CAAM,CACxC,CACF,EAEMK,EAAa,IAAI,aAEpBC,GAAe,CAChB,MAAMC,EAAsBX,EAAQ,UAAUU,CAAU,EACxD,MAAO,IAAM,CACXE,EAAkB,YAAY,EAC9BD,EAAoB,YAAY,EAChCZ,EAAM,KAAK,CACb,CACF,CAAC,EAEKa,EAAoBb,EAAM,UAAUE,CAAmB,EAC7D,OAAAF,EAAM,MAAM,EAEL,CACL,WAAYU,EAAW,QAAK,SAAM,CAAC,EACnC,OAAQ,IAAM,CACZV,EAAM,KAAK,EACXa,EAAkB,YAAY,EAC9BX,EAAoBF,EAAM,YAAY,CAAC,CACzC,CACF,CACF,CAEQ,yBAAyBK,EAAsB,CACrD,cAAQ,IAAI,kCAAmCA,CAAM,EAC/C,IAAI,MAAM,qBAAqBA,CAAM,EAAE,CAC/C,CACF",
   "names": ["XStateDeviceAction_exports", "__export", "XStateDeviceAction", "__toCommonJS", "import_rxjs", "import_xstate", "import_DeviceActionState", "args", "internalApi", "stateMachine", "actor", "subject", "handleActorSnapshot", "snapshot", "context", "status", "output", "error", "err", "result", "observable", "subscriber", "subjectSubscription", "actorSubscription"]
 }

package/lib/cjs/src/api/device-model/data/StaticDeviceModelDataSource.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var l=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var I=(o,e,d)=>e in o?l(o,e,{enumerable:!0,configurable:!0,writable:!0,value:d}):o[e]=d;var a=(o,e)=>{for(var d in e)l(o,d,{get:e[d],enumerable:!0})},x=(o,e,d,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of f(e))!y.call(o,r)&&r!==d&&l(o,r,{get:()=>e[r],enumerable:!(t=m(e,r))||t.enumerable});return o};var N=o=>x(l({},"__esModule",{value:!0}),o),b=(o,e,d,t)=>{for(var r=t>1?void 0:t?m(e,d):e,c=o.length-1,n;c>=0;c--)(n=o[c])&&(r=(t?n(e,d,r):n(r))||r);return t&&r&&l(e,d,r),r};var v=(o,e,d)=>I(o,typeof e!="symbol"?e+"":e,d);var P={};a(P,{StaticDeviceModelDataSource:()=>s});module.exports=N(P);var U=require("inversify"),i=require("../../device/DeviceModel"),p=require("../../device-model/model/BleDeviceInfos"),u=require("../../device-model/model/DeviceModel");let s=class{getAllDeviceModels(){return Object.values(s.deviceModelByIds)}getDeviceModel(e){return s.deviceModelByIds[e.id]}filterDeviceModels(e){return this.getAllDeviceModels().filter(d=>Object.entries(e).every(([t,r])=>d[t]===r))}getBluetoothServicesInfos(){return Object.values(s.deviceModelByIds).reduce((e,d)=>{const{bluetoothSpec:t}=d;return t?{...e,...t.reduce((r,c)=>({...r,[c.serviceUuid]:new p.BleDeviceInfos(d,c.serviceUuid,c.writeUuid,c.writeCmdUuid,c.notifyUuid)}),{})}:e},{})}getBluetoothServices(){return Object.values(s.deviceModelByIds).map(e=>(e.bluetoothSpec||[]).map(d=>d.serviceUuid)).flat().filter(e=>!!e)}};v(s,"deviceModelByIds",{[i.DeviceModelId.APEX]:new u.TransportDeviceModel({id:i.DeviceModelId.APEX,productName:"Ledger Apex",usbProductId:128,bootloaderUsbProductId:8,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[859832320],bluetoothSpec:[{serviceUuid:"13d63400-2c97-6004-0000-4c6564676572",notifyUuid:"13d63400-2c97-6004-0001-4c6564676572",writeUuid:"13d63400-2c97-6004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-6004-0003-4c6564676572"}]}),[i.DeviceModelId.NANO_S]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_S,productName:"Ledger Nano S",usbProductId:16,bootloaderUsbProductId:1,usbOnly:!0,memorySize:320*1024,blockSize:4*1024,masks:[823132160]}),[i.DeviceModelId.NANO_SP]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_SP,productName:"Ledger Nano S Plus",usbProductId:80,bootloaderUsbProductId:5,usbOnly:!0,memorySize:1533*1024,blockSize:32,masks:[856686592]}),[i.DeviceModelId.NANO_X]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_X,productName:"Ledger Nano X",usbProductId:64,bootloaderUsbProductId:4,usbOnly:!1,memorySize:2*1024*1024,blockSize:4*1024,masks:[855638016],bluetoothSpec:[{serviceUuid:"13d63400-2c97-0004-0000-4c6564676572",notifyUuid:"13d63400-2c97-0004-0001-4c6564676572",writeUuid:"13d63400-2c97-0004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-0004-0003-4c6564676572"}]}),[i.DeviceModelId.STAX]:new u.TransportDeviceModel({id:i.DeviceModelId.STAX,productName:"Ledger Stax",usbProductId:96,bootloaderUsbProductId:6,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[857735168],bluetoothSpec:[{serviceUuid:"13d63400-2c97-6004-0000-4c6564676572",notifyUuid:"13d63400-2c97-6004-0001-4c6564676572",writeUuid:"13d63400-2c97-6004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-6004-0003-4c6564676572"}]}),[i.DeviceModelId.FLEX]:new u.TransportDeviceModel({id:i.DeviceModelId.FLEX,productName:"Ledger Flex",usbProductId:112,bootloaderUsbProductId:7,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[858783744],bluetoothSpec:[{serviceUuid:"13d63400-2c97-3004-0000-4c6564676572",notifyUuid:"13d63400-2c97-3004-0001-4c6564676572",writeUuid:"13d63400-2c97-3004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-3004-0003-4c6564676572"}]})}),s=b([(0,U.injectable)()],s);0&&(module.exports={StaticDeviceModelDataSource});
+"use strict";var l=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var I=(o,e,d)=>e in o?l(o,e,{enumerable:!0,configurable:!0,writable:!0,value:d}):o[e]=d;var a=(o,e)=>{for(var d in e)l(o,d,{get:e[d],enumerable:!0})},x=(o,e,d,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of f(e))!y.call(o,r)&&r!==d&&l(o,r,{get:()=>e[r],enumerable:!(t=m(e,r))||t.enumerable});return o};var N=o=>x(l({},"__esModule",{value:!0}),o),b=(o,e,d,t)=>{for(var r=t>1?void 0:t?m(e,d):e,c=o.length-1,n;c>=0;c--)(n=o[c])&&(r=(t?n(e,d,r):n(r))||r);return t&&r&&l(e,d,r),r};var v=(o,e,d)=>I(o,typeof e!="symbol"?e+"":e,d);var P={};a(P,{StaticDeviceModelDataSource:()=>s});module.exports=N(P);var U=require("inversify"),i=require("../../device/DeviceModel"),p=require("../../device-model/model/BleDeviceInfos"),u=require("../../device-model/model/DeviceModel");let s=class{getAllDeviceModels(){return Object.values(s.deviceModelByIds)}getDeviceModel(e){return s.deviceModelByIds[e.id]}filterDeviceModels(e){return this.getAllDeviceModels().filter(d=>Object.entries(e).every(([t,r])=>d[t]===r))}getBluetoothServicesInfos(){return Object.values(s.deviceModelByIds).reduce((e,d)=>{const{bluetoothSpec:t}=d;return t?{...e,...t.reduce((r,c)=>({...r,[c.serviceUuid]:new p.BleDeviceInfos(d,c.serviceUuid,c.writeUuid,c.writeCmdUuid,c.notifyUuid)}),{})}:e},{})}getBluetoothServices(){return Object.values(s.deviceModelByIds).map(e=>(e.bluetoothSpec||[]).map(d=>d.serviceUuid)).flat().filter(e=>!!e)}};v(s,"deviceModelByIds",{[i.DeviceModelId.NANO_S]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_S,productName:"Ledger Nano S",usbProductId:16,bootloaderUsbProductId:1,usbOnly:!0,memorySize:320*1024,blockSize:4*1024,masks:[823132160]}),[i.DeviceModelId.NANO_SP]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_SP,productName:"Ledger Nano S Plus",usbProductId:80,bootloaderUsbProductId:5,usbOnly:!0,memorySize:1533*1024,blockSize:32,masks:[856686592]}),[i.DeviceModelId.NANO_X]:new u.TransportDeviceModel({id:i.DeviceModelId.NANO_X,productName:"Ledger Nano X",usbProductId:64,bootloaderUsbProductId:4,usbOnly:!1,memorySize:2*1024*1024,blockSize:4*1024,masks:[855638016],bluetoothSpec:[{serviceUuid:"13d63400-2c97-0004-0000-4c6564676572",notifyUuid:"13d63400-2c97-0004-0001-4c6564676572",writeUuid:"13d63400-2c97-0004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-0004-0003-4c6564676572"}]}),[i.DeviceModelId.STAX]:new u.TransportDeviceModel({id:i.DeviceModelId.STAX,productName:"Ledger Stax",usbProductId:96,bootloaderUsbProductId:6,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[857735168],bluetoothSpec:[{serviceUuid:"13d63400-2c97-6004-0000-4c6564676572",notifyUuid:"13d63400-2c97-6004-0001-4c6564676572",writeUuid:"13d63400-2c97-6004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-6004-0003-4c6564676572"}]}),[i.DeviceModelId.FLEX]:new u.TransportDeviceModel({id:i.DeviceModelId.FLEX,productName:"Ledger Flex",usbProductId:112,bootloaderUsbProductId:7,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[858783744],bluetoothSpec:[{serviceUuid:"13d63400-2c97-3004-0000-4c6564676572",notifyUuid:"13d63400-2c97-3004-0001-4c6564676572",writeUuid:"13d63400-2c97-3004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-3004-0003-4c6564676572"}]}),[i.DeviceModelId.APEX]:new u.TransportDeviceModel({id:i.DeviceModelId.APEX,productName:"Ledger Apex",usbProductId:128,bootloaderUsbProductId:8,usbOnly:!1,memorySize:1533*1024,blockSize:32,masks:[859832320],bluetoothSpec:[{serviceUuid:"13d63400-2c97-8004-0000-4c6564676572",notifyUuid:"13d63400-2c97-8004-0001-4c6564676572",writeUuid:"13d63400-2c97-8004-0002-4c6564676572",writeCmdUuid:"13d63400-2c97-8004-0003-4c6564676572"}]})}),s=b([(0,U.injectable)()],s);0&&(module.exports={StaticDeviceModelDataSource});
 //# sourceMappingURL=StaticDeviceModelDataSource.js.map

package/lib/cjs/src/api/device-model/data/StaticDeviceModelDataSource.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/device-model/data/StaticDeviceModelDataSource.ts"],
-  "sourcesContent": ["import { injectable } from \"inversify\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { DeviceModelDataSource } from \"@api/device-model/data/DeviceModelDataSource\";\nimport { BleDeviceInfos } from \"@api/device-model/model/BleDeviceInfos\";\nimport { TransportDeviceModel } from \"@api/device-model/model/DeviceModel\";\n\n/**\n * Static/in memory implementation of the device model data source\n */\n@injectable()\nexport class StaticDeviceModelDataSource implements DeviceModelDataSource {\n  private static deviceModelByIds: {\n    [_key in DeviceModelId]: TransportDeviceModel;\n  } = {\n    [DeviceModelId.APEX]: new TransportDeviceModel({\n      id: DeviceModelId.APEX,\n      productName: \"Ledger Apex\",\n      usbProductId: 0x80,\n      bootloaderUsbProductId: 0x0008,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33400000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-6004-0000-4c6564676572\", // WILL CHANGE, for now same as Stax\n          notifyUuid: \"13d63400-2c97-6004-0001-4c6564676572\", // WILL CHANGE, for now same as Stax\n          writeUuid: \"13d63400-2c97-6004-0002-4c6564676572\", // WILL CHANGE, for now same as Stax\n          writeCmdUuid: \"13d63400-2c97-6004-0003-4c6564676572\", // WILL CHANGE, for now same as Stax\n        },\n      ],\n    }),\n    [DeviceModelId.NANO_S]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_S,\n      productName: \"Ledger Nano S\",\n      usbProductId: 0x10,\n      bootloaderUsbProductId: 0x0001,\n      usbOnly: true,\n      memorySize: 320 * 1024,\n      blockSize: 4 * 1024,\n      masks: [0x31100000],\n    }),\n    [DeviceModelId.NANO_SP]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_SP,\n      productName: \"Ledger Nano S Plus\",\n      usbProductId: 0x50,\n      bootloaderUsbProductId: 0x0005,\n      usbOnly: true,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33100000],\n    }),\n    [DeviceModelId.NANO_X]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_X,\n      productName: \"Ledger Nano X\",\n      usbProductId: 0x40,\n      bootloaderUsbProductId: 0x0004,\n      usbOnly: false,\n      memorySize: 2 * 1024 * 1024,\n      blockSize: 4 * 1024,\n      masks: [0x33000000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-0004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-0004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-0004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-0004-0003-4c6564676572\",\n        },\n      ],\n    }),\n    [DeviceModelId.STAX]: new TransportDeviceModel({\n      id: DeviceModelId.STAX,\n      productName: \"Ledger Stax\",\n      usbProductId: 0x60,\n      bootloaderUsbProductId: 0x0006,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33200000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-6004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-6004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-6004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-6004-0003-4c6564676572\",\n        },\n      ],\n    }),\n    [DeviceModelId.FLEX]: new TransportDeviceModel({\n      id: DeviceModelId.FLEX,\n      productName: \"Ledger Flex\",\n      usbProductId: 0x70,\n      bootloaderUsbProductId: 0x0007,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33300000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-3004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-3004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-3004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-3004-0003-4c6564676572\",\n        },\n      ],\n    }),\n  };\n\n  getAllDeviceModels(): TransportDeviceModel[] {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds);\n  }\n\n  getDeviceModel(params: { id: DeviceModelId }): TransportDeviceModel {\n    return StaticDeviceModelDataSource.deviceModelByIds[params.id];\n  }\n\n  /**\n   * Returns the list of device models that match all the given parameters\n   */\n  filterDeviceModels(\n    params: Partial<TransportDeviceModel>,\n  ): TransportDeviceModel[] {\n    return this.getAllDeviceModels().filter((deviceModel) => {\n      return Object.entries(params).every(([key, value]) => {\n        return deviceModel[key as keyof TransportDeviceModel] === value;\n      });\n    });\n  }\n\n  getBluetoothServicesInfos(): Record<string, BleDeviceInfos> {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds).reduce<\n      Record<string, BleDeviceInfos>\n    >((acc, deviceModel) => {\n      const { bluetoothSpec } = deviceModel;\n      if (bluetoothSpec) {\n        return {\n          ...acc,\n          ...bluetoothSpec.reduce<Record<string, BleDeviceInfos>>(\n            (serviceToModel, bleSpec) => ({\n              ...serviceToModel,\n              [bleSpec.serviceUuid]: new BleDeviceInfos(\n                deviceModel,\n                bleSpec.serviceUuid,\n                bleSpec.writeUuid,\n                bleSpec.writeCmdUuid,\n                bleSpec.notifyUuid,\n              ),\n            }),\n            {},\n          ),\n        };\n      }\n      return acc;\n    }, {});\n  }\n\n  getBluetoothServices(): string[] {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds)\n      .map((deviceModel) =>\n        (deviceModel.bluetoothSpec || []).map((spec) => spec.serviceUuid),\n      )\n      .flat()\n      .filter((uuid) => !!uuid);\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { injectable } from \"inversify\";\n\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { DeviceModelDataSource } from \"@api/device-model/data/DeviceModelDataSource\";\nimport { BleDeviceInfos } from \"@api/device-model/model/BleDeviceInfos\";\nimport { TransportDeviceModel } from \"@api/device-model/model/DeviceModel\";\n\n/**\n * Static/in memory implementation of the device model data source\n */\n@injectable()\nexport class StaticDeviceModelDataSource implements DeviceModelDataSource {\n  private static deviceModelByIds: {\n    [_key in DeviceModelId]: TransportDeviceModel;\n  } = {\n    [DeviceModelId.NANO_S]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_S,\n      productName: \"Ledger Nano S\",\n      usbProductId: 0x10,\n      bootloaderUsbProductId: 0x0001,\n      usbOnly: true,\n      memorySize: 320 * 1024,\n      blockSize: 4 * 1024,\n      masks: [0x31100000],\n    }),\n    [DeviceModelId.NANO_SP]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_SP,\n      productName: \"Ledger Nano S Plus\",\n      usbProductId: 0x50,\n      bootloaderUsbProductId: 0x0005,\n      usbOnly: true,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33100000],\n    }),\n    [DeviceModelId.NANO_X]: new TransportDeviceModel({\n      id: DeviceModelId.NANO_X,\n      productName: \"Ledger Nano X\",\n      usbProductId: 0x40,\n      bootloaderUsbProductId: 0x0004,\n      usbOnly: false,\n      memorySize: 2 * 1024 * 1024,\n      blockSize: 4 * 1024,\n      masks: [0x33000000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-0004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-0004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-0004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-0004-0003-4c6564676572\",\n        },\n      ],\n    }),\n    [DeviceModelId.STAX]: new TransportDeviceModel({\n      id: DeviceModelId.STAX,\n      productName: \"Ledger Stax\",\n      usbProductId: 0x60,\n      bootloaderUsbProductId: 0x0006,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33200000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-6004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-6004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-6004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-6004-0003-4c6564676572\",\n        },\n      ],\n    }),\n    [DeviceModelId.FLEX]: new TransportDeviceModel({\n      id: DeviceModelId.FLEX,\n      productName: \"Ledger Flex\",\n      usbProductId: 0x70,\n      bootloaderUsbProductId: 0x0007,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33300000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-3004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-3004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-3004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-3004-0003-4c6564676572\",\n        },\n      ],\n    }),\n    [DeviceModelId.APEX]: new TransportDeviceModel({\n      id: DeviceModelId.APEX,\n      productName: \"Ledger Apex\",\n      usbProductId: 0x80,\n      bootloaderUsbProductId: 0x0008,\n      usbOnly: false,\n      memorySize: 1533 * 1024,\n      blockSize: 32,\n      masks: [0x33400000],\n      bluetoothSpec: [\n        {\n          serviceUuid: \"13d63400-2c97-8004-0000-4c6564676572\",\n          notifyUuid: \"13d63400-2c97-8004-0001-4c6564676572\",\n          writeUuid: \"13d63400-2c97-8004-0002-4c6564676572\",\n          writeCmdUuid: \"13d63400-2c97-8004-0003-4c6564676572\",\n        },\n      ],\n    }),\n  };\n\n  getAllDeviceModels(): TransportDeviceModel[] {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds);\n  }\n\n  getDeviceModel(params: { id: DeviceModelId }): TransportDeviceModel {\n    return StaticDeviceModelDataSource.deviceModelByIds[params.id];\n  }\n\n  /**\n   * Returns the list of device models that match all the given parameters\n   */\n  filterDeviceModels(\n    params: Partial<TransportDeviceModel>,\n  ): TransportDeviceModel[] {\n    return this.getAllDeviceModels().filter((deviceModel) => {\n      return Object.entries(params).every(([key, value]) => {\n        return deviceModel[key as keyof TransportDeviceModel] === value;\n      });\n    });\n  }\n\n  getBluetoothServicesInfos(): Record<string, BleDeviceInfos> {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds).reduce<\n      Record<string, BleDeviceInfos>\n    >((acc, deviceModel) => {\n      const { bluetoothSpec } = deviceModel;\n      if (bluetoothSpec) {\n        return {\n          ...acc,\n          ...bluetoothSpec.reduce<Record<string, BleDeviceInfos>>(\n            (serviceToModel, bleSpec) => ({\n              ...serviceToModel,\n              [bleSpec.serviceUuid]: new BleDeviceInfos(\n                deviceModel,\n                bleSpec.serviceUuid,\n                bleSpec.writeUuid,\n                bleSpec.writeCmdUuid,\n                bleSpec.notifyUuid,\n              ),\n            }),\n            {},\n          ),\n        };\n      }\n      return acc;\n    }, {});\n  }\n\n  getBluetoothServices(): string[] {\n    return Object.values(StaticDeviceModelDataSource.deviceModelByIds)\n      .map((deviceModel) =>\n        (deviceModel.bluetoothSpec || []).map((spec) => spec.serviceUuid),\n      )\n      .flat()\n      .filter((uuid) => !!uuid);\n  }\n}\n"],
+  "mappings": "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",
   "names": ["StaticDeviceModelDataSource_exports", "__export", "StaticDeviceModelDataSource", "__toCommonJS", "import_inversify", "import_DeviceModel", "import_BleDeviceInfos", "StaticDeviceModelDataSource", "params", "deviceModel", "key", "value", "acc", "bluetoothSpec", "serviceToModel", "bleSpec", "spec", "uuid", "__publicField", "__decorateClass"]
 }

package/lib/cjs/src/api/device-model/data/StaticDeviceModelDataSource.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var e=require("../../device/DeviceModel"),a=require("../../device-model/model/BleDeviceInfos"),i=require("./StaticDeviceModelDataSource");describe("StaticDeviceModelDataSource",()=>{describe("getAllDeviceModels",()=>{it("should return all device models",()=>{const c=new i.StaticDeviceModelDataSource().getAllDeviceModels();expect(c.length).toEqual(6),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.APEX})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.STAX})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.FLEX}))})}),describe("getDeviceModel",()=>{it("should return the associated device model",()=>{const t=new i.StaticDeviceModelDataSource,c=t.getDeviceModel({id:e.DeviceModelId.NANO_S});expect(c).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const o=t.getDeviceModel({id:e.DeviceModelId.NANO_SP});expect(o).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const d=t.getDeviceModel({id:e.DeviceModelId.NANO_X});expect(d).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const n=t.getDeviceModel({id:e.DeviceModelId.STAX});expect(n).toEqual(expect.objectContaining({id:e.DeviceModelId.STAX}));const l=t.getDeviceModel({id:e.DeviceModelId.FLEX});expect(l).toEqual(expect.objectContaining({id:e.DeviceModelId.FLEX}))})}),describe("filterDeviceModels",()=>{it("should return the device models that match the given single parameter",()=>{const t=new i.StaticDeviceModelDataSource,c=t.filterDeviceModels({usbOnly:!0});expect(c.length).toEqual(2),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const o=t.filterDeviceModels({usbProductId:16});expect(o.length).toEqual(1),expect(o[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const d=t.filterDeviceModels({usbProductId:64});expect(d.length).toEqual(1),expect(d[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const n=t.filterDeviceModels({usbProductId:80});expect(n.length).toEqual(1),expect(n[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const l=t.filterDeviceModels({usbProductId:96});expect(l.length).toEqual(1),expect(l[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.STAX}));const s=t.filterDeviceModels({usbProductId:0});expect(s.length).toEqual(0)}),it("should return the device models that match the given multiple parameters",()=>{const t=new i.StaticDeviceModelDataSource,c=t.filterDeviceModels({usbOnly:!1,usbProductId:64});expect(c.length).toEqual(1),expect(c[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const o=t.filterDeviceModels({usbOnly:!0,usbProductId:80});expect(o.length).toEqual(1),expect(o[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const d=t.filterDeviceModels({usbOnly:!1,usbProductId:16});expect(d.length).toEqual(0)})}),describe("getBluetoothServicesInfos",()=>{it("should return the ble service infos record",()=>{const t=new i.StaticDeviceModelDataSource,c=t.getBluetoothServicesInfos();expect(c).toStrictEqual({"13d63400-2c97-0004-0000-4c6564676572":new a.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.NANO_X}),"13d63400-2c97-0004-0000-4c6564676572","13d63400-2c97-0004-0002-4c6564676572","13d63400-2c97-0004-0003-4c6564676572","13d63400-2c97-0004-0001-4c6564676572"),"13d63400-2c97-6004-0000-4c6564676572":new a.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.STAX}),"13d63400-2c97-6004-0000-4c6564676572","13d63400-2c97-6004-0002-4c6564676572","13d63400-2c97-6004-0003-4c6564676572","13d63400-2c97-6004-0001-4c6564676572"),"13d63400-2c97-3004-0000-4c6564676572":new a.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.FLEX}),"13d63400-2c97-3004-0000-4c6564676572","13d63400-2c97-3004-0002-4c6564676572","13d63400-2c97-3004-0003-4c6564676572","13d63400-2c97-3004-0001-4c6564676572")})})}),describe("getBluetoothServices",()=>{it("should return the bluetooth services",()=>{const c=new i.StaticDeviceModelDataSource().getBluetoothServices();expect(c).toStrictEqual(["13d63400-2c97-6004-0000-4c6564676572","13d63400-2c97-0004-0000-4c6564676572","13d63400-2c97-6004-0000-4c6564676572","13d63400-2c97-3004-0000-4c6564676572"])})})});
+"use strict";var e=require("../../device/DeviceModel"),n=require("../../device-model/model/BleDeviceInfos"),i=require("./StaticDeviceModelDataSource");describe("StaticDeviceModelDataSource",()=>{describe("getAllDeviceModels",()=>{it("should return all device models",()=>{const c=new i.StaticDeviceModelDataSource().getAllDeviceModels();expect(c.length).toEqual(6),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.APEX})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.STAX})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.FLEX}))})}),describe("getDeviceModel",()=>{it("should return the associated device model",()=>{const t=new i.StaticDeviceModelDataSource,c=t.getDeviceModel({id:e.DeviceModelId.NANO_S});expect(c).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const o=t.getDeviceModel({id:e.DeviceModelId.NANO_SP});expect(o).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const d=t.getDeviceModel({id:e.DeviceModelId.NANO_X});expect(d).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const l=t.getDeviceModel({id:e.DeviceModelId.STAX});expect(l).toEqual(expect.objectContaining({id:e.DeviceModelId.STAX}));const a=t.getDeviceModel({id:e.DeviceModelId.FLEX});expect(a).toEqual(expect.objectContaining({id:e.DeviceModelId.FLEX}))})}),describe("filterDeviceModels",()=>{it("should return the device models that match the given single parameter",()=>{const t=new i.StaticDeviceModelDataSource,c=t.filterDeviceModels({usbOnly:!0});expect(c.length).toEqual(2),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP})),expect(c).toContainEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const o=t.filterDeviceModels({usbProductId:16});expect(o.length).toEqual(1),expect(o[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_S}));const d=t.filterDeviceModels({usbProductId:64});expect(d.length).toEqual(1),expect(d[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const l=t.filterDeviceModels({usbProductId:80});expect(l.length).toEqual(1),expect(l[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const a=t.filterDeviceModels({usbProductId:96});expect(a.length).toEqual(1),expect(a[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.STAX}));const s=t.filterDeviceModels({usbProductId:0});expect(s.length).toEqual(0)}),it("should return the device models that match the given multiple parameters",()=>{const t=new i.StaticDeviceModelDataSource,c=t.filterDeviceModels({usbOnly:!1,usbProductId:64});expect(c.length).toEqual(1),expect(c[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_X}));const o=t.filterDeviceModels({usbOnly:!0,usbProductId:80});expect(o.length).toEqual(1),expect(o[0]).toEqual(expect.objectContaining({id:e.DeviceModelId.NANO_SP}));const d=t.filterDeviceModels({usbOnly:!1,usbProductId:16});expect(d.length).toEqual(0)})}),describe("getBluetoothServicesInfos",()=>{it("should return the ble service infos record",()=>{const t=new i.StaticDeviceModelDataSource,c=t.getBluetoothServicesInfos();expect(c).toStrictEqual({"13d63400-2c97-0004-0000-4c6564676572":new n.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.NANO_X}),"13d63400-2c97-0004-0000-4c6564676572","13d63400-2c97-0004-0002-4c6564676572","13d63400-2c97-0004-0003-4c6564676572","13d63400-2c97-0004-0001-4c6564676572"),"13d63400-2c97-6004-0000-4c6564676572":new n.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.STAX}),"13d63400-2c97-6004-0000-4c6564676572","13d63400-2c97-6004-0002-4c6564676572","13d63400-2c97-6004-0003-4c6564676572","13d63400-2c97-6004-0001-4c6564676572"),"13d63400-2c97-3004-0000-4c6564676572":new n.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.FLEX}),"13d63400-2c97-3004-0000-4c6564676572","13d63400-2c97-3004-0002-4c6564676572","13d63400-2c97-3004-0003-4c6564676572","13d63400-2c97-3004-0001-4c6564676572"),"13d63400-2c97-8004-0000-4c6564676572":new n.BleDeviceInfos(t.getDeviceModel({id:e.DeviceModelId.APEX}),"13d63400-2c97-8004-0000-4c6564676572","13d63400-2c97-8004-0002-4c6564676572","13d63400-2c97-8004-0003-4c6564676572","13d63400-2c97-8004-0001-4c6564676572")})})}),describe("getBluetoothServices",()=>{it("should return the bluetooth services",()=>{const c=new i.StaticDeviceModelDataSource().getBluetoothServices();expect(c).toStrictEqual(["13d63400-2c97-0004-0000-4c6564676572","13d63400-2c97-6004-0000-4c6564676572","13d63400-2c97-3004-0000-4c6564676572","13d63400-2c97-8004-0000-4c6564676572"])})})});
 //# sourceMappingURL=StaticDeviceModelDataSource.test.js.map