@localnerve/csp-hashes 7.0.4 → 7.1.0

package/index.js

@@ -8,4 +8,4 @@
  * Copyright (c) 2022-2025 Alex Grant (@localnerve), LocalNerve LLC
  * Licensed under the MIT license.
  */
-export { hashstream as default, hashstream, removeCspMeta, createCspHash } from './lib/index.js';
+export { hashstream as default, hashstream, removeCspMeta, createCspHash, cspHashes } from './lib/index.js';

package/lib/index.js

@@ -75,6 +75,44 @@ export function createCspHash(input, algo = 'sha256') {
   return makeCspHash(algo, input);
 }
 
+/**
+ * cspHashes
+ * Accepts an algorithm and content buffer/string and returns a hashes object
+ * containing all CSP hashes for inline scripts and styles. This is useful for
+ * users who just have a few files to process and will handle I/O themselves,
+ * without needing a stream.
+ *
+ * @param {String} [algo] - hash algorithm, default sha256. Can be sha384, sha512.
+ * @param {Buffer|String} content - The HTML content to extract hashes from.
+ * @returns {Object} The hashes object with script and style elements and attributes.
+ */
+export function cspHashes (algo = 'sha256', content) {
+  if (!/^sha(256|384|512)$/.test(algo)) {
+    throw new Error('algo option must be one of "sha256", "sha384", or "sha512" only.');
+  }
+
+  const hashes = {
+    script: {
+      elements: [],
+      attributes: [],
+      get all () {
+        return this.elements.concat(this.attributes);
+      }
+    },
+    style: {
+      elements: [],
+      attributes: [],
+      get all () {
+        return this.elements.concat(this.attributes);
+      }
+    }
+  };
+
+  collectHashes(makeCspHash.bind(null, algo), content, hashes);
+
+  return hashes;
+}
+
 /**
  * hashstream
  * Accepts the processing options and returns a Transform object stream.
@@ -105,24 +143,7 @@ export function hashstream ({
       const path = file.path;
       const content = file.contents;
 
-      const hashes = {
-        script: {
-          elements: [],
-          attributes: [],
-          get all () {
-            return this.elements.concat(this.attributes);
-          }
-        },
-        style: {
-          elements: [],
-          attributes: [],
-          get all () {
-            return this.elements.concat(this.attributes);
-          }
-        }
-      };
-  
-      collectHashes(makeCspHash.bind(null, algo), content, hashes);
+      const hashes = cspHashes(algo, content);
   
       if (replace) {
         const s = callback(path, hashes, content.toString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@localnerve/csp-hashes",
-  "version": "7.0.4",
+  "version": "7.1.0",
   "description": "Flexible library to generate CSP hashes",
   "main": "index.js",
   "type": "module",

package/readme.md

@@ -13,6 +13,7 @@
   - [Breaking Changes](#breaking-changes)
   - [API](#api)
     - [hashstream (also the default export)](#hashstream-also-the-default-export)
+    - [cspHashes](#csphashes)
     - [createCspHash](#createcsphash)
     - [removeCspMeta](#removecspmeta)
     - [Hashstream Options](#hashstream-options)
@@ -49,6 +50,33 @@ Stream hashstream ({
 
 See [`hashstream options`](#hashstream-options) for a detailed explanation of the input options.
 
+### cspHashes
+This library exports a convenience function that takes an algorithm and HTML content, and returns a hashes object containing all CSP hashes for inline scripts and styles. This is useful for users who just have a few files to process and will handle I/O themselves, without needing a stream.
+
+```
+Object cspHashes(algo = 'sha256', content)
+```
+
++ {String} **\[algo\]** - Optional - Defaults to `'sha256'`, can be one of 'sha256', 'sha384' or 'sha512'.
++ {Buffer|String} **content** - Required - The HTML content to extract hashes from.
+
+Returns a [`hashes` object](#callback-hashes-object) with the same structure as the `hashstream` callback receives:
+
+```javascript
+{
+  script: {
+    elements: [],
+    attributes: [],
+    get all () { return this.elements.concat(this.attributes); }
+  },
+  style: {
+    elements: [],
+    attributes: [],
+    get all () { return this.elements.concat(this.attributes); }
+  }
+}
+```
+
 ### createCspHash
 This library exports the helper method it uses to make CSP formatted hashes. This is useful if you have a picece of code you need to hash and place into your hash list outside the scope of the page as rendered.
 
@@ -179,6 +207,20 @@ export function stripCspMetaContents (settings) {
 }
 ```
 
+### Simple File Processing (No Stream Required)
+If you just have a few files to process and want to handle I/O yourself, use `cspHashes` instead of `hashstream`:
+
+```javascript
+import fs from 'node:fs';
+import { cspHashes } from '@localnerve/csp-hashes';
+
+const html = fs.readFileSync('./dist/index.html', { encoding: 'utf8' });
+const hashes = cspHashes('sha256', html);
+
+console.log('Script element hashes:', hashes.script.elements.join(' '));
+console.log('Style attribute hashes:', hashes.style.attributes.join(' '));
+```
+
 ### Native Node.js Streams (No Gulp/Vinyl Required)
 You can use `hashstream` directly with native Node.js streams by wrapping raw file buffers into plain file-like objects. This example reads HTML files from a source directory, processes them through `hashstream`, and writes the output to a destination: