@gjsify/webcrypto 0.1.0

package/README.md

@@ -0,0 +1,28 @@
+# @gjsify/webcrypto
+
+GJS implementation of the Web Crypto API using GLib.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/webcrypto
+# or
+yarn add @gjsify/webcrypto
+```
+
+## Usage
+
+```typescript
+import { crypto } from '@gjsify/webcrypto';
+
+const array = new Uint8Array(16);
+crypto.getRandomValues(array);
+
+const uuid = crypto.randomUUID();
+```
+
+## License
+
+MIT

package/globals.mjs

@@ -0,0 +1,6 @@
+/**
+ * Re-exports native WebCrypto globals for use in Node.js builds.
+ * On Node.js, crypto.subtle is a native global.
+ */
+export default globalThis.crypto;
+export const subtle = globalThis.crypto.subtle;

package/lib/esm/crypto-key.js

@@ -0,0 +1,21 @@
+class CryptoKey {
+  type;
+  extractable;
+  algorithm;
+  usages;
+  /** @internal Raw key material — not visible to user code */
+  _handle;
+  constructor(type, extractable, algorithm, usages, handle) {
+    this.type = type;
+    this.extractable = extractable;
+    this.algorithm = Object.freeze({ ...algorithm });
+    this.usages = Object.freeze([...usages]);
+    this._handle = handle;
+  }
+  get [Symbol.toStringTag]() {
+    return "CryptoKey";
+  }
+}
+export {
+  CryptoKey
+};

package/lib/esm/index.js

@@ -0,0 +1,49 @@
+import { SubtleCrypto } from "./subtle.js";
+import { CryptoKey } from "./crypto-key.js";
+const _nativeCrypto = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : null;
+class CryptoPolyfill {
+  subtle = new SubtleCrypto();
+  getRandomValues(array) {
+    if (!(array instanceof Int8Array || array instanceof Uint8Array || array instanceof Int16Array || array instanceof Uint16Array || array instanceof Int32Array || array instanceof Uint32Array || array instanceof Uint8ClampedArray || array instanceof BigInt64Array || array instanceof BigUint64Array)) {
+      throw new DOMException("The provided value is not of type '(Int8Array or Int16Array or Int32Array or Uint8Array or Uint8ClampedArray or Uint16Array or Uint32Array or BigInt64Array or BigUint64Array)'", "TypeMismatchError");
+    }
+    if (array.byteLength > 65536) {
+      throw new DOMException("The ArrayBufferView's byte length exceeds the number of bytes of entropy available via this API (65536)", "QuotaExceededError");
+    }
+    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    if (_nativeCrypto && typeof _nativeCrypto.getRandomValues === "function") {
+      _nativeCrypto.getRandomValues(bytes);
+    } else {
+      for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return array;
+  }
+  randomUUID() {
+    if (_nativeCrypto && typeof _nativeCrypto.randomUUID === "function") {
+      return _nativeCrypto.randomUUID();
+    }
+    const bytes = new Uint8Array(16);
+    this.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+}
+const hasNativeSubtle = _nativeCrypto !== null && typeof _nativeCrypto.subtle !== "undefined" && typeof _nativeCrypto.subtle.digest === "function";
+const cryptoInstance = hasNativeSubtle ? _nativeCrypto : new CryptoPolyfill();
+const subtleInstance = hasNativeSubtle ? _nativeCrypto.subtle : new SubtleCrypto();
+if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle === "undefined") {
+  globalThis.crypto = cryptoInstance;
+}
+var index_default = cryptoInstance;
+export {
+  CryptoPolyfill as Crypto,
+  CryptoKey,
+  SubtleCrypto,
+  cryptoInstance as crypto,
+  index_default as default,
+  subtleInstance as subtle
+};