feat: allow options to customize pattern and hash length

Author: metonym

src/plugin.ts

@@ -4,60 +4,62 @@ import { PostHTML } from "posthtml";
 import hasha from "hasha";
 
 const DEFAULT_HASH_LENGTH = 20;
-const REGEX_HASH = new RegExp(/\[hash.*]/g);
+const DEFAULT_PATTERN = new RegExp(/\[hash.*]/g);
 
-export function replaceHash(str: string, buffer: Buffer) {
-  const match = str.match(REGEX_HASH);
+export function replaceHash(
+  str: string,
+  buffer: Buffer,
+  exp: RegExp,
+  hashLength: number
+) {
+  const match = str.match(exp);
   const [_, len] = match![0].replace(/\[|]/g, "").split(":");
 
-  return str.replace(
-    REGEX_HASH,
-    hasha(buffer).slice(0, Number(len) || DEFAULT_HASH_LENGTH)
-  );
+  return str.replace(exp, hasha(buffer).slice(0, Number(len) || hashLength));
 }
 
 type NodeWithHashRegex = { attrs: { href?: string; src?: string } };
 
-function plugin(options?: { path?: string }) {
+function plugin(options?: {
+  path?: string;
+  hashLength?: number;
+  pattern?: RegExp;
+}) {
   return function posthtmlHash(tree: PostHTML.Node) {
-    tree.match(
-      [{ attrs: { href: REGEX_HASH } }, { attrs: { src: REGEX_HASH } }],
-      (node) => {
-        const _node = (node as unknown) as NodeWithHashRegex;
-        const { href, src } = _node.attrs;
+    const exp = options?.pattern || DEFAULT_PATTERN;
+    const hashLength = options?.hashLength || DEFAULT_HASH_LENGTH;
 
-        let fileName = "";
+    tree.match([{ attrs: { href: exp } }, { attrs: { src: exp } }], (node) => {
+      const _node = (node as unknown) as NodeWithHashRegex;
+      const { href, src } = _node.attrs;
 
-        if (href) {
-          fileName = href;
-        } else if (src) {
-          fileName = src;
-        }
+      let fileName = "";
 
-        const pathToFile = options?.path || "";
-        const file = path.join(process.cwd(), pathToFile, fileName);
+      if (href) {
+        fileName = href;
+      } else if (src) {
+        fileName = src;
+      }
 
-        if (fs.existsSync(file)) {
-          const buffer = fs.readFileSync(file);
-          const hashedFileName = replaceHash(fileName, buffer);
-          const hashedFile = path.join(
-            process.cwd(),
-            pathToFile,
-            hashedFileName
-          );
+      const pathToFile = options?.path || "";
+      const file = path.join(process.cwd(), pathToFile, fileName);
 
-          fs.renameSync(file, hashedFile);
+      if (fs.existsSync(file)) {
+        const buffer = fs.readFileSync(file);
+        const hashedFileName = replaceHash(fileName, buffer, exp, hashLength);
+        const hashedFile = path.join(process.cwd(), pathToFile, hashedFileName);
 
-          if (href) {
-            _node.attrs.href = hashedFileName;
-          } else if (src) {
-            _node.attrs.src = hashedFileName;
-          }
-        }
+        fs.renameSync(file, hashedFile);
 
-        return node;
+        if (href) {
+          _node.attrs.href = hashedFileName;
+        } else if (src) {
+          _node.attrs.src = hashedFileName;
+        }
       }
-    );
+
+      return node;
+    });
   };
 }
 

src/tests/plugin.test.ts

@@ -4,24 +4,66 @@ import fs from "fs";
 import path from "path";
 import posthtml from "posthtml";
 
+if (!fs.existsSync("src/tests/__fixtures__/processed")) {
+  fs.mkdirSync("src/tests/__fixtures__/processed");
+}
+
 const buffer = fs.readFileSync(
   path.resolve(__dirname, "__fixtures__/original/bundle.min.[hash].js")
 );
 
-test.equal(replaceHash("[hash].js", buffer), "b0dcc67ffc1fd562f212.js");
+const DEFAULT_HASH_LENGTH = 20;
+const DEFAULT_PATTERN = new RegExp(/\[hash.*]/g);
+
+test.equal(
+  replaceHash("[hash].js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH),
+  "b0dcc67ffc1fd562f212.js"
+);
 test.equal(
-  replaceHash("script.[hash].js", buffer),
+  replaceHash("script.[hash].js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH),
   "script.b0dcc67ffc1fd562f212.js"
 );
 test.equal(
-  replaceHash("script.[hash:20].js", buffer),
+  replaceHash(
+    "script.[hash:20].js",
+    buffer,
+    DEFAULT_PATTERN,
+    DEFAULT_HASH_LENGTH
+  ),
   "script.b0dcc67ffc1fd562f212.js"
 );
-test.equal(replaceHash("script.[hash:8].js", buffer), "script.b0dcc67f.js");
-test.throws(() => replaceHash("script.js", buffer));
-test.throws(() => replaceHash("script[].js", buffer));
-test.throws(() => replaceHash("script.[has:8].js", buffer));
-test.throws(() => replaceHash("script.js", buffer));
+test.equal(
+  replaceHash(
+    "script.[hash:8].js",
+    buffer,
+    DEFAULT_PATTERN,
+    DEFAULT_HASH_LENGTH
+  ),
+  "script.b0dcc67f.js"
+);
+test.throws(() =>
+  replaceHash("script.js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH)
+);
+test.throws(() =>
+  replaceHash("script[].js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH)
+);
+test.throws(() =>
+  replaceHash("script.[has:8].js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH)
+);
+test.throws(() =>
+  replaceHash("script.js", buffer, DEFAULT_PATTERN, DEFAULT_HASH_LENGTH)
+);
+
+const CUSTOM_EXP = new RegExp(/\[oh-my-hash.*]/g);
+
+test.equal(
+  replaceHash("[oh-my-hash].js", buffer, CUSTOM_EXP, DEFAULT_HASH_LENGTH),
+  "b0dcc67ffc1fd562f212.js"
+);
+test.equal(
+  replaceHash("script.[oh-my-hash].js", buffer, CUSTOM_EXP, 8),
+  "script.b0dcc67f.js"
+);
 
 function copyFixture(fileName: string) {
   const file = path.join(__dirname, "__fixtures__/original", fileName);