minor refactor, cleanup

shims/crypto/create-hash.js

@@ -1,20 +1,21 @@
-// Shim for crypto.createHash
-// Obsidian uses createHash('SHA256') for signature verification (main process only)
-// and possibly for content hashing in the renderer.
-// Uses SubtleCrypto where possible.
-
 export function createHash(algorithm) {
-  const alg = algorithm.toUpperCase().replace('-', '');
-  const subtleAlg = alg === 'SHA256' ? 'SHA-256' : alg === 'SHA1' ? 'SHA-1' : alg === 'SHA512' ? 'SHA-512' : alg;
+  const alg = algorithm.toUpperCase().replace("-", "");
+  const subtleAlg =
+    alg === "SHA256"
+      ? "SHA-256"
+      : alg === "SHA1"
+        ? "SHA-1"
+        : alg === "SHA512"
+          ? "SHA-512"
+          : alg;
 
   let inputData = new Uint8Array(0);
 
   return {
     update(data) {
-      if (typeof data === 'string') {
+      if (typeof data === "string") {
         data = new TextEncoder().encode(data);
       }
-      // Concatenate
       const merged = new Uint8Array(inputData.length + data.length);
       merged.set(inputData);
       merged.set(data, inputData.length);
@@ -22,27 +23,23 @@ export function createHash(algorithm) {
       return this;
     },
 
-    // Note: digest is sync in Node but we may need async.
-    // For now provide sync hex/base64 via a simple JS implementation.
-    // TODO: evaluate if any sync call sites exist; if not, make this async.
     digest(encoding) {
-      // Fallback: simple sync hash (for SHA-256 only)
-      // This is a placeholder  -  swap in a proper sync implementation if needed
-      console.warn('[shim:crypto] createHash.digest  -  using placeholder');
+      console.warn("[shim:crypto] createHash.digest - using placeholder");
       const hash = simpleHash(inputData);
-      if (encoding === 'hex') return hash;
-      if (encoding === 'base64') return btoa(hash);
+      if (encoding === "hex") return hash;
+      if (encoding === "base64") return btoa(hash);
       return hash;
     },
 
-    // Async alternative for contexts that can await
     async digestAsync(encoding) {
       const hashBuffer = await crypto.subtle.digest(subtleAlg, inputData);
       const hashArray = new Uint8Array(hashBuffer);
-      if (encoding === 'hex') {
-        return Array.from(hashArray).map(b => b.toString(16).padStart(2, '0')).join('');
+      if (encoding === "hex") {
+        return Array.from(hashArray)
+          .map((b) => b.toString(16).padStart(2, "0"))
+          .join("");
       }
-      if (encoding === 'base64') {
+      if (encoding === "base64") {
         return btoa(String.fromCharCode(...hashArray));
       }
       return hashArray;
@@ -50,11 +47,10 @@ export function createHash(algorithm) {
   };
 }
 
-// Very basic placeholder hash  -  not cryptographic, just for bootstrapping
 function simpleHash(data) {
   let hash = 0;
   for (let i = 0; i < data.length; i++) {
     hash = ((hash << 5) - hash + data[i]) | 0;
   }
-  return Math.abs(hash).toString(16).padStart(8, '0');
+  return Math.abs(hash).toString(16).padStart(8, "0");
 }

shims/crypto/index.js

@@ -1,9 +1,6 @@
-// Crypto shim
-// Obsidian uses: scrypt, randomBytes, createHash
-
-import { randomBytes } from './random-bytes.js';
-import { createHash } from './create-hash.js';
-import { scrypt } from './scrypt.js';
+import { randomBytes } from "./random-bytes.js";
+import { createHash } from "./create-hash.js";
+import { scrypt } from "./scrypt.js";
 
 export const cryptoShim = {
   randomBytes,

shims/crypto/random-bytes.js

@@ -1,16 +1,14 @@
-// Shim for crypto.randomBytes
-// Uses Web Crypto API under the hood
-
 export function randomBytes(size) {
   const buf = new Uint8Array(size);
   crypto.getRandomValues(buf);
 
-  // Add Buffer-like convenience methods
-  buf.toString = function(encoding) {
-    if (encoding === 'hex') {
-      return Array.from(this).map(b => b.toString(16).padStart(2, '0')).join('');
+  buf.toString = function (encoding) {
+    if (encoding === "hex") {
+      return Array.from(this)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
     }
-    if (encoding === 'base64') {
+    if (encoding === "base64") {
       return btoa(String.fromCharCode(...this));
     }
     return new TextDecoder().decode(this);

shims/crypto/scrypt.js

@@ -1,12 +1,5 @@
-// Shim for crypto.scrypt
-// Delegates to window.scrypt which is already loaded by Obsidian's own scrypt.js
-
 export function scrypt(password, salt, keylen, options, callback) {
-  // Node signature: scrypt(password, salt, keylen, options, callback)
-  // Obsidian's app.js checks for window.require("crypto") and uses it if available,
-  // otherwise falls back to window.scrypt  -  so this shim just delegates to the latter.
-
-  if (typeof options === 'function') {
+  if (typeof options === "function") {
     callback = options;
     options = {};
   }
@@ -16,14 +9,18 @@ export function scrypt(password, salt, keylen, options, callback) {
   const p = options?.p || 1;
 
   if (window.scrypt && window.scrypt.scrypt) {
-    // Use the browser scrypt library already loaded by Obsidian
-    const pwBytes = typeof password === 'string' ? new TextEncoder().encode(password) : password;
-    const saltBytes = typeof salt === 'string' ? new TextEncoder().encode(salt) : salt;
+    const pwBytes =
+      typeof password === "string"
+        ? new TextEncoder().encode(password)
+        : password;
+    const saltBytes =
+      typeof salt === "string" ? new TextEncoder().encode(salt) : salt;
 
-    window.scrypt.scrypt(pwBytes, saltBytes, N, r, p, keylen)
+    window.scrypt
+      .scrypt(pwBytes, saltBytes, N, r, p, keylen)
       .then((result) => callback(null, new Uint8Array(result)))
       .catch((err) => callback(err));
   } else {
-    callback(new Error('scrypt not available'));
+    callback(new Error("scrypt not available"));
   }
 }