@sd-jwt/utils 0.6.0 → 0.6.1-next.6

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { DisclosureData, HasherAndAlg, HasherAndAlgSync } from '@sd-jwt/types';
 
-declare const Base64urlEncode: (src: string) => string;
-declare const Base64urlDecode: (src: string) => string;
-declare const Uint8ArrayToBase64Url: (input: Uint8Array) => string;
+declare const base64urlEncode: (src: string) => string;
+declare const base64urlDecode: (src: string) => string;
+declare const uint8ArrayToBase64Url: (input: Uint8Array) => string;
 
 declare class SDJWTException extends Error {
     details?: unknown;
@@ -32,4 +32,4 @@ declare class Disclosure<T = unknown> {
     digestSync(hash: HasherAndAlgSync): string;
 }
 
-export { Base64urlDecode, Base64urlEncode, Disclosure, SDJWTException, Uint8ArrayToBase64Url };
+export { Disclosure, SDJWTException, base64urlDecode, base64urlEncode, uint8ArrayToBase64Url };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { DisclosureData, HasherAndAlg, HasherAndAlgSync } from '@sd-jwt/types';
 
-declare const Base64urlEncode: (src: string) => string;
-declare const Base64urlDecode: (src: string) => string;
-declare const Uint8ArrayToBase64Url: (input: Uint8Array) => string;
+declare const base64urlEncode: (src: string) => string;
+declare const base64urlDecode: (src: string) => string;
+declare const uint8ArrayToBase64Url: (input: Uint8Array) => string;
 
 declare class SDJWTException extends Error {
     details?: unknown;
@@ -32,4 +32,4 @@ declare class Disclosure<T = unknown> {
     digestSync(hash: HasherAndAlgSync): string;
 }
 
-export { Base64urlDecode, Base64urlEncode, Disclosure, SDJWTException, Uint8ArrayToBase64Url };
+export { Disclosure, SDJWTException, base64urlDecode, base64urlEncode, uint8ArrayToBase64Url };

package/dist/index.js

@@ -40,19 +40,19 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Base64urlDecode: () => Base64urlDecode,
-  Base64urlEncode: () => Base64urlEncode,
   Disclosure: () => Disclosure,
   SDJWTException: () => SDJWTException,
-  Uint8ArrayToBase64Url: () => Uint8ArrayToBase64Url
+  base64urlDecode: () => base64urlDecode,
+  base64urlEncode: () => base64urlEncode,
+  uint8ArrayToBase64Url: () => uint8ArrayToBase64Url
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/base64url.ts
 var import_js_base64 = require("js-base64");
-var Base64urlEncode = import_js_base64.Base64.encodeURI;
-var Base64urlDecode = import_js_base64.Base64.decode;
-var Uint8ArrayToBase64Url = (input) => import_js_base64.Base64.fromUint8Array(input, true);
+var base64urlEncode = import_js_base64.Base64.encodeURI;
+var base64urlDecode = import_js_base64.Base64.decode;
+var uint8ArrayToBase64Url = (input) => import_js_base64.Base64.fromUint8Array(input, true);
 
 // src/error.ts
 var SDJWTException = class _SDJWTException extends Error {
@@ -92,16 +92,16 @@ var Disclosure = class _Disclosure {
     return __async(this, null, function* () {
       const { hasher, alg } = hash;
       const digest = yield hasher(s, alg);
-      const digestStr = Uint8ArrayToBase64Url(digest);
-      const item = JSON.parse(Base64urlDecode(s));
+      const digestStr = uint8ArrayToBase64Url(digest);
+      const item = JSON.parse(base64urlDecode(s));
       return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
     });
   }
   static fromEncodeSync(s, hash) {
     const { hasher, alg } = hash;
     const digest = hasher(s, alg);
-    const digestStr = Uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(Base64urlDecode(s));
+    const digestStr = uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(base64urlDecode(s));
     return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
   }
   static fromArray(item, _meta) {
@@ -109,7 +109,7 @@ var Disclosure = class _Disclosure {
   }
   encode() {
     if (!this._encoded) {
-      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+      this._encoded = base64urlEncode(JSON.stringify(this.decode()));
     }
     return this._encoded;
   }
@@ -121,7 +121,7 @@ var Disclosure = class _Disclosure {
       const { hasher, alg } = hash;
       if (!this._digest) {
         const hash2 = yield hasher(this.encode(), alg);
-        this._digest = Uint8ArrayToBase64Url(hash2);
+        this._digest = uint8ArrayToBase64Url(hash2);
       }
       return this._digest;
     });
@@ -130,16 +130,16 @@ var Disclosure = class _Disclosure {
     const { hasher, alg } = hash;
     if (!this._digest) {
       const hash2 = hasher(this.encode(), alg);
-      this._digest = Uint8ArrayToBase64Url(hash2);
+      this._digest = uint8ArrayToBase64Url(hash2);
     }
     return this._digest;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Base64urlDecode,
-  Base64urlEncode,
   Disclosure,
   SDJWTException,
-  Uint8ArrayToBase64Url
+  base64urlDecode,
+  base64urlEncode,
+  uint8ArrayToBase64Url
 });

package/dist/index.mjs

@@ -21,9 +21,9 @@ var __async = (__this, __arguments, generator) => {
 
 // src/base64url.ts
 import { Base64 } from "js-base64";
-var Base64urlEncode = Base64.encodeURI;
-var Base64urlDecode = Base64.decode;
-var Uint8ArrayToBase64Url = (input) => Base64.fromUint8Array(input, true);
+var base64urlEncode = Base64.encodeURI;
+var base64urlDecode = Base64.decode;
+var uint8ArrayToBase64Url = (input) => Base64.fromUint8Array(input, true);
 
 // src/error.ts
 var SDJWTException = class _SDJWTException extends Error {
@@ -63,16 +63,16 @@ var Disclosure = class _Disclosure {
     return __async(this, null, function* () {
       const { hasher, alg } = hash;
       const digest = yield hasher(s, alg);
-      const digestStr = Uint8ArrayToBase64Url(digest);
-      const item = JSON.parse(Base64urlDecode(s));
+      const digestStr = uint8ArrayToBase64Url(digest);
+      const item = JSON.parse(base64urlDecode(s));
       return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
     });
   }
   static fromEncodeSync(s, hash) {
     const { hasher, alg } = hash;
     const digest = hasher(s, alg);
-    const digestStr = Uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(Base64urlDecode(s));
+    const digestStr = uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(base64urlDecode(s));
     return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
   }
   static fromArray(item, _meta) {
@@ -80,7 +80,7 @@ var Disclosure = class _Disclosure {
   }
   encode() {
     if (!this._encoded) {
-      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+      this._encoded = base64urlEncode(JSON.stringify(this.decode()));
     }
     return this._encoded;
   }
@@ -92,7 +92,7 @@ var Disclosure = class _Disclosure {
       const { hasher, alg } = hash;
       if (!this._digest) {
         const hash2 = yield hasher(this.encode(), alg);
-        this._digest = Uint8ArrayToBase64Url(hash2);
+        this._digest = uint8ArrayToBase64Url(hash2);
       }
       return this._digest;
     });
@@ -101,15 +101,15 @@ var Disclosure = class _Disclosure {
     const { hasher, alg } = hash;
     if (!this._digest) {
       const hash2 = hasher(this.encode(), alg);
-      this._digest = Uint8ArrayToBase64Url(hash2);
+      this._digest = uint8ArrayToBase64Url(hash2);
     }
     return this._digest;
   }
 };
 export {
-  Base64urlDecode,
-  Base64urlEncode,
   Disclosure,
   SDJWTException,
-  Uint8ArrayToBase64Url
+  base64urlDecode,
+  base64urlEncode,
+  uint8ArrayToBase64Url
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sd-jwt/utils",
-  "version": "0.6.0",
+  "version": "0.6.1-next.6+f8db275",
   "description": "sd-jwt draft 7 implementation in typescript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -38,10 +38,10 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@sd-jwt/crypto-nodejs": "0.6.0"
+    "@sd-jwt/crypto-nodejs": "0.6.1-next.6+f8db275"
   },
   "dependencies": {
-    "@sd-jwt/types": "0.6.0",
+    "@sd-jwt/types": "0.6.1-next.6+f8db275",
     "js-base64": "^3.7.6"
   },
   "publishConfig": {
@@ -60,5 +60,5 @@
       "esm"
     ]
   },
-  "gitHead": "a26955a3fa8995bee7dc9daa04b16c501d4c87bd"
+  "gitHead": "f8db275690dab88000a039838680a3478b3b61ec"
 }

package/src/base64url.ts

@@ -1,8 +1,8 @@
 import { Base64 } from 'js-base64';
 
-export const Base64urlEncode = Base64.encodeURI;
+export const base64urlEncode = Base64.encodeURI;
 
-export const Base64urlDecode = Base64.decode;
+export const base64urlDecode = Base64.decode;
 
-export const Uint8ArrayToBase64Url = (input: Uint8Array): string =>
+export const uint8ArrayToBase64Url = (input: Uint8Array): string =>
   Base64.fromUint8Array(input, true);

package/src/disclosure.ts

@@ -1,7 +1,7 @@
 import {
-  Uint8ArrayToBase64Url,
-  Base64urlDecode,
-  Base64urlEncode,
+  uint8ArrayToBase64Url,
+  base64urlDecode,
+  base64urlEncode,
 } from './base64url';
 import { SDJWTException } from './error';
 import type {
@@ -45,16 +45,16 @@ export class Disclosure<T = unknown> {
   public static async fromEncode<T>(s: string, hash: HasherAndAlg) {
     const { hasher, alg } = hash;
     const digest = await hasher(s, alg);
-    const digestStr = Uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(Base64urlDecode(s)) as DisclosureData<T>;
+    const digestStr = uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(base64urlDecode(s)) as DisclosureData<T>;
     return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
   }
 
   public static fromEncodeSync<T>(s: string, hash: HasherAndAlgSync) {
     const { hasher, alg } = hash;
     const digest = hasher(s, alg);
-    const digestStr = Uint8ArrayToBase64Url(digest);
-    const item = JSON.parse(Base64urlDecode(s)) as DisclosureData<T>;
+    const digestStr = uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(base64urlDecode(s)) as DisclosureData<T>;
     return Disclosure.fromArray<T>(item, { digest: digestStr, encoded: s });
   }
 
@@ -69,7 +69,7 @@ export class Disclosure<T = unknown> {
     if (!this._encoded) {
       // we use JSON.stringify to encode the data
       // It's the most reliable and universal way to encode JSON object
-      this._encoded = Base64urlEncode(JSON.stringify(this.decode()));
+      this._encoded = base64urlEncode(JSON.stringify(this.decode()));
     }
     return this._encoded;
   }
@@ -84,7 +84,7 @@ export class Disclosure<T = unknown> {
     const { hasher, alg } = hash;
     if (!this._digest) {
       const hash = await hasher(this.encode(), alg);
-      this._digest = Uint8ArrayToBase64Url(hash);
+      this._digest = uint8ArrayToBase64Url(hash);
     }
 
     return this._digest;
@@ -94,7 +94,7 @@ export class Disclosure<T = unknown> {
     const { hasher, alg } = hash;
     if (!this._digest) {
       const hash = hasher(this.encode(), alg);
-      this._digest = Uint8ArrayToBase64Url(hash);
+      this._digest = uint8ArrayToBase64Url(hash);
     }
 
     return this._digest;

package/src/test/base64url.spec.ts

@@ -1,26 +1,26 @@
 import { describe, expect, test } from 'vitest';
 import {
-  Base64urlDecode,
-  Base64urlEncode,
-  Uint8ArrayToBase64Url,
+  base64urlDecode,
+  base64urlEncode,
+  uint8ArrayToBase64Url,
 } from '../base64url';
 
 describe('Base64url', () => {
   const raw = 'abcdefghijklmnopqrstuvwxyz';
   const encoded = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo';
   test('Encode', () => {
-    expect(Base64urlEncode(raw)).toStrictEqual(encoded);
+    expect(base64urlEncode(raw)).toStrictEqual(encoded);
   });
   test('Decode', () => {
-    expect(Base64urlDecode(encoded)).toStrictEqual(raw);
+    expect(base64urlDecode(encoded)).toStrictEqual(raw);
   });
   test('Encode and decode', () => {
     const str = 'hello world';
-    expect(Base64urlDecode(Base64urlEncode(str))).toStrictEqual(str);
+    expect(base64urlDecode(base64urlEncode(str))).toStrictEqual(str);
   });
   test('Uint8Array', () => {
     const str = 'hello world';
     const uint8 = new TextEncoder().encode(str);
-    expect(Uint8ArrayToBase64Url(uint8)).toStrictEqual(Base64urlEncode(str));
+    expect(uint8ArrayToBase64Url(uint8)).toStrictEqual(base64urlEncode(str));
   });
 });

package/src/test/disclosure.spec.ts

@@ -1,7 +1,7 @@
 import { generateSalt, digest as hasher } from '@sd-jwt/crypto-nodejs';
 import { Disclosure } from '../disclosure';
 import { describe, expect, test } from 'vitest';
-import { Base64urlEncode, type SDJWTException } from '../index';
+import { base64urlEncode, type SDJWTException } from '../index';
 
 const hash = { alg: 'SHA256', hasher };
 
@@ -144,7 +144,7 @@ describe('Disclosure', () => {
   });
 
   test('digest disclosure #3', async () => {
-    const encoded = Base64urlEncode(TestDataDraft7.claimTests[0].contents);
+    const encoded = base64urlEncode(TestDataDraft7.claimTests[0].contents);
     expect(encoded).toStrictEqual(TestDataDraft7.claimTests[0].disclosure);
 
     const disclosure = await Disclosure.fromEncode(