test: add tests

Author: metonym

.gitignore

@@ -2,5 +2,6 @@
 /.vscode
 /lib
 /node_modules
+/src/tests/__fixtures__/processed
 yarn-debug.log*
 yarn-error.log*

package.json

@@ -4,8 +4,8 @@
   "license": "MIT",
   "description": "PostHTML plugin for hashing static assets",
   "author": "Eric Liu (https://github.com/metonym)",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "lib/plugin.js",
+  "types": "lib/plugin.d.ts",
   "scripts": {
     "test": "tsnd src/tests",
     "test:tdd": "tsnd --respawn src/tests",

src/index.ts

@@ -3,88 +3,63 @@ import path from "path";
 import { PostHTML } from "posthtml";
 import hasha from "hasha";
 
-const DEFAULT_PATH = "";
 const DEFAULT_HASH_LENGTH = 20;
-const DEFAULT_OPTIONS: IOptions = {
-  path: DEFAULT_PATH,
-  hashLength: DEFAULT_HASH_LENGTH,
-  css: true,
-  js: true,
-};
-
 const REGEX_HASH = new RegExp(/\[hash.*]/g);
 
-export function replaceHash(str: string, buffer: Buffer | string) {
+export function replaceHash(str: string, buffer: Buffer) {
   const match = str.match(REGEX_HASH);
-
-  if (match == null) {
-    return str;
-  }
-
-  const [_, len] = match[0].replace(/\[|]/g, "").split(":");
+  const [_, len] = match![0].replace(/\[|]/g, "").split(":");
 
   return str.replace(
     REGEX_HASH,
     hasha(buffer).slice(0, Number(len) || DEFAULT_HASH_LENGTH)
   );
 }
 
-function plugin(options = DEFAULT_OPTIONS) {
-  return function posthtmlHash(tree: PostHTML.Node) {
-    const hashLength = options.hashLength || DEFAULT_HASH_LENGTH;
-    const css = options.css !== undefined ? options.css : DEFAULT_OPTIONS.css;
-    const js = options.js !== undefined ? options.js : DEFAULT_OPTIONS.js;
-    const nonEmptyString = new RegExp(/\S+/);
-    const matchers = ([
-      css && {
-        tag: "link",
-        attrs: { rel: "stylesheet", href: nonEmptyString },
-      },
-      js && { tag: "script", attrs: { src: nonEmptyString } },
-    ].filter(Boolean) as unknown) as IPostHTMLHashMatcher[];
-
-    tree.match(matchers, (node) => {
-      const attrs = node.attrs!;
-      let fileName = "";
-
-      if (attrs.href) {
-        fileName = attrs.href;
-      } else if (attrs.src) {
-        fileName = attrs.src;
-      }
-
-      const pathToFile = options.path || "";
-      const file = path.join(process.cwd(), pathToFile, fileName);
-
-      if (fs.existsSync(file)) {
-        const buffer = fs.readFileSync(file);
-        const hashedFileName = replaceHash(fileName, buffer);
-        const hashedFile = path.join(process.cwd(), pathToFile, hashedFileName);
+type NodeWithHashRegex = { attrs: { href?: string; src?: string } };
 
-        fs.renameSync(file, hashedFile);
+function plugin(options?: { path?: string }) {
+  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;
+
+        let fileName = "";
+
+        if (href) {
+          fileName = href;
+        } else if (src) {
+          fileName = src;
+        }
 
-        if (attrs.href) {
-          node.attrs!.href = hashedFileName;
-        } else if (attrs.src) {
-          node.attrs!.src = hashedFileName;
+        const pathToFile = options?.path || "";
+        const file = path.join(process.cwd(), pathToFile, fileName);
+
+        if (fs.existsSync(file)) {
+          const buffer = fs.readFileSync(file);
+          const hashedFileName = replaceHash(fileName, buffer);
+          const hashedFile = path.join(
+            process.cwd(),
+            pathToFile,
+            hashedFileName
+          );
+
+          fs.renameSync(file, hashedFile);
+
+          if (href) {
+            _node.attrs.href = hashedFileName;
+          } else if (src) {
+            _node.attrs.src = hashedFileName;
+          }
         }
-      }
 
-      return node;
-    });
+        return node;
+      }
+    );
   };
 }
 
-interface IOptions {
-  path?: string;
-  hashLength?: number;
-  css?: boolean;
-  js?: boolean;
-}
-
-interface IPostHTMLHashMatcher {
-  tag: PostHTML.StringMatcher;
-  attrs: PostHTML.AttrMatcher;
-}
-
-export { plugin, DEFAULT_HASH_LENGTH };
+export default plugin;
+export { plugin as hash, plugin as posthtmlHash };