npm - ghtml - Versions diffs - 3.0.8 → 3.0.9 - Mend

ghtml 3.0.8 → 3.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/bench/index.js +2 -4
package/bin/README.md +1 -1
package/bin/example/assets/script.js +1 -1
package/bin/example/routes/index.js +1 -3
package/bin/example/server.js +3 -8
package/bin/src/index.js +7 -7
package/bin/src/utils.js +6 -2
package/eslint.config.js +12 -1
package/package.json +3 -3
package/src/index.d.ts +3 -1
package/src/index.js +246 -1
package/src/html.d.ts +0 -3
package/src/html.js +0 -248

package/bench/index.js CHANGED Viewed

@@ -1,13 +1,11 @@
 /* eslint-disable no-unused-vars */
-import { html } from "../src/index.js";
+import { html } from "ghtml";
 import { Bench } from "tinybench";
 import { writeFileSync } from "node:fs";
 import { Buffer } from "node:buffer";
-let result = "";
 const bench = new Bench({ time: 500 });
+let result = "";
 bench.add("simple HTML formatting", () => {
   result = html`<div>Hello, world!</div>`;

package/bin/README.md CHANGED Viewed

@@ -5,7 +5,7 @@ Append unique hashes to assets referenced in your views to aggressively cache th
 Running the following command will scan asset files found in the `roots` path(s) and replace their references in the `refs` path(s) with hashed versions:
 ```sh
-npx ghtml --roots="base/path/to/scan/assets/1/,base/path/to/scan/assets/2/" --refs="views/path/to/append/hashes/1/,views/path/to/append/hashes/2/"
+npx ghtml --roots="base/path/to/scan/assets/1/,base/path/to/scan/assets/2/" --refs="views/path/to/append/hashes/1/,views/path/to/append/hashes/2/" --prefix="/optional/prefix/"
 ```
 ## Example (Fastify)

package/bin/example/assets/script.js CHANGED Viewed

	@@ -1 +1 @@
1	- globalThis.console.~~warn~~("Hello World!");
1	+ globalThis.console.log("Hello World!");

package/bin/example/routes/index.js CHANGED Viewed

@@ -1,5 +1,3 @@
-/* eslint-disable n/no-missing-import, require-await */
 import { html } from "ghtml";
 export default async (fastify) => {
@@ -21,7 +19,7 @@ export default async (fastify) => {
         <body>
           !${inner}
         </body>
-      </html> `;
+      </html>`;
   });
   fastify.get("/", async (request, reply) => {

package/bin/example/server.js CHANGED Viewed

@@ -1,5 +1,3 @@
-/* eslint-disable n/no-missing-import */
 import Fastify from "fastify";
 const fastify = Fastify();
@@ -17,10 +15,7 @@ await fastify.register(import("@fastify/static"), {
 // Routes
 fastify.register(import("./routes/index.js"));
-fastify.listen({ port: 5050 }, (err, address) => {
-  if (err) {
-    throw err;
-  }
+// Listen
+const address = await fastify.listen({ port: 5050 });
-  globalThis.console.warn(`Server listening at ${address}`);
-});
+globalThis.console.log(`Server listening at ${address}`);

package/bin/src/index.js CHANGED Viewed

@@ -18,7 +18,7 @@ const parseArguments = (args) => {
   }
   if (!roots || !refs) {
-    globalThis.console.error(
+    globalThis.console.log(
       'Usage: npx ghtml --roots="base/path/to/scan/assets/1/,base/path/to/scan/assets/2/" --refs="views/path/to/append/hashes/1/,views/path/to/append/hashes/2/" [--prefix="/optional/prefix/"]',
     );
     process.exit(1);
@@ -31,10 +31,10 @@ const main = async () => {
   const { roots, refs, prefix } = parseArguments(process.argv.slice(2));
   try {
-    globalThis.console.warn(`Generating hashes and updating file paths...`);
-    globalThis.console.warn(`Scanning files in: ${roots}`);
-    globalThis.console.warn(`Updating files in: ${refs}`);
-    globalThis.console.warn(`Using prefix: ${prefix}`);
+    globalThis.console.log(`Generating hashes and updating file paths...`);
+    globalThis.console.log(`Scanning files in: ${roots}`);
+    globalThis.console.log(`Updating files in: ${refs}`);
+    globalThis.console.log(`Using prefix: ${prefix}`);
     await generateHashesAndReplace({
       roots,
@@ -42,11 +42,11 @@ const main = async () => {
       prefix,
     });
-    globalThis.console.warn(
+    globalThis.console.log(
       "Hash generation and file updates completed successfully.",
     );
   } catch (error) {
-    globalThis.console.error(`Error occurred: ${error.message}`);
+    globalThis.console.log(`Error occurred: ${error.message}`);
     process.exit(1);
   }
 };

package/bin/src/utils.js CHANGED Viewed

@@ -1,5 +1,3 @@
-/* eslint-disable no-await-in-loop */
 import { Glob } from "glob";
 import { createHash } from "node:crypto";
 import { readFile, writeFile } from "node:fs/promises";
@@ -8,11 +6,13 @@ import { win32, posix } from "node:path";
 const generateFileHash = async (filePath) => {
   try {
     const fileBuffer = await readFile(filePath);
     return createHash("md5").update(fileBuffer).digest("hex").slice(0, 16);
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw err;
     }
     return "";
   }
 };
@@ -26,6 +26,7 @@ const updateFilePathsWithHashes = async (
 ) => {
   for (let ref of refs) {
     ref = ref.replaceAll(win32.sep, posix.sep);
     if (!ref.endsWith("/")) {
       ref += "/";
     }
@@ -84,11 +85,13 @@ export const generateHashesAndReplace = async ({
   skipPatterns = ["**/node_modules/**"],
 }) => {
   const fileHashes = new Map();
   roots = Array.isArray(roots) ? roots : [roots];
   refs = Array.isArray(refs) ? refs : [refs];
   for (let root of roots) {
     root = root.replaceAll(win32.sep, posix.sep);
     if (!root.endsWith("/")) {
       root += "/";
     }
@@ -114,6 +117,7 @@ export const generateHashesAndReplace = async ({
     for (let i = 0; i < files.length; ++i) {
       const fileRelativePath = posix.relative(root, files[i]);
       fileHashes.set(fileRelativePath, hashes[i]);
     }
   }

package/eslint.config.js CHANGED Viewed

@@ -1,3 +1,14 @@
 import grules from "grules";
-export default [...grules];
+export default [
+  ...grules,
+  {
+    rules: {
+      "no-await-in-loop": "off",
+      "require-unicode-regexp": "off",
+    },
+  },
+  {
+    ignores: ["bin/example/**/*.js"],
+  },
+];

package/package.json CHANGED Viewed

@@ -3,7 +3,7 @@
   "description": "Replace your template engine with fast JavaScript by leveraging the power of tagged templates.",
   "author": "Gürgün Dayıoğlu",
   "license": "MIT",
-  "version": "3.0.8",
+  "version": "3.0.9",
   "type": "module",
   "bin": "./bin/src/index.js",
   "main": "./src/index.js",
@@ -19,7 +19,7 @@
     "test": "npm run lint && c8 --100 node --test test/*.js",
     "lint": "eslint . && prettier --check .",
     "lint:fix": "eslint --fix . && prettier --write .",
-    "typescript": "tsc src/*.js --allowJs --declaration --emitDeclarationOnly"
+    "typescript": "tsc src/*.js --allowJs --declaration --emitDeclarationOnly --skipLibCheck"
   },
   "dependencies": {
     "glob": "^10.4.5"
@@ -27,7 +27,7 @@
   "devDependencies": {
     "@fastify/pre-commit": "^2.1.0",
     "c8": "^10.1.2",
-    "grules": "^0.25.0",
+    "grules": "^0.25.3",
     "tinybench": "^2.9.0",
     "typescript": ">=5.6.2"
   },

package/src/index.d.ts CHANGED Viewed

@@ -1 +1,3 @@
-export { html, htmlGenerator, htmlAsyncGenerator } from "./html.js";
+export function html(literals: TemplateStringsArray, ...expressions: any[]): string;
+export function htmlGenerator(literals: TemplateStringsArray, ...expressions: any[]): Generator<string, void, void>;
+export function htmlAsyncGenerator(literals: TemplateStringsArray, ...expressions: any[]): AsyncGenerator<string, void, void>;

package/src/index.js CHANGED Viewed

@@ -1 +1,246 @@
-export { html, htmlGenerator, htmlAsyncGenerator } from "./html.js";
+const escapeRegExp = /["&'<=>]/g;
+const escapeFunction = (string) => {
+  let escaped = "";
+  let start = 0;
+  while (escapeRegExp.test(string)) {
+    const i = escapeRegExp.lastIndex - 1;
+    switch (string.charCodeAt(i)) {
+      case 34:
+        escaped += string.slice(start, i) + "&#34;"; // "
+        break;
+      case 38:
+        escaped += string.slice(start, i) + "&#38;"; // &
+        break;
+      case 39:
+        escaped += string.slice(start, i) + "&#39;"; // '
+        break;
+      case 60:
+        escaped += string.slice(start, i) + "&#60;"; // <
+        break;
+      case 61:
+        escaped += string.slice(start, i) + "&#61;"; // =
+        break;
+      default: {
+        escaped += string.slice(start, i) + "&#62;"; // >
+      }
+    }
+    start = escapeRegExp.lastIndex;
+  }
+  return escaped + string.slice(start);
+};
+/**
+ * @param {TemplateStringsArray} literals literals
+ * @param {...any} expressions expressions
+ * @returns {string} string
+ */
+export const html = (literals, ...expressions) => {
+  let accumulator = "";
+  for (let i = 0; i !== expressions.length; ++i) {
+    let literal = literals.raw[i];
+    let string = Array.isArray(expressions[i])
+      ? expressions[i].join("")
+      : String(expressions[i] ?? "");
+    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
+      literal = literal.slice(0, -1);
+    } else {
+      string &&= escapeFunction(string);
+    }
+    accumulator += literal + string;
+  }
+  return accumulator + literals.raw[expressions.length];
+};
+/**
+ * @param {TemplateStringsArray} literals literals
+ * @param {...any} expressions expressions
+ * @yields {string} string
+ * @returns {Generator<string, void, void>} Generator<string, void, void>
+ */
+export const htmlGenerator = function* (literals, ...expressions) {
+  for (let i = 0; i !== expressions.length; ++i) {
+    let expression = expressions[i];
+    let literal = literals.raw[i];
+    let string;
+    if (typeof expression === "string") {
+      string = expression;
+    } else if (expression === undefined || expression === null) {
+      string = "";
+    } else {
+      if (expression[Symbol.iterator]) {
+        const isRaw =
+          Boolean(literal) && literal.charCodeAt(literal.length - 1) === 33;
+        if (isRaw) {
+          literal = literal.slice(0, -1);
+        }
+        if (literal) {
+          yield literal;
+        }
+        for (expression of expression) {
+          if (typeof expression === "string") {
+            string = expression;
+          } else {
+            if (expression === undefined || expression === null) {
+              continue;
+            }
+            if (expression[Symbol.iterator]) {
+              for (expression of expression) {
+                if (expression === undefined || expression === null) {
+                  continue;
+                }
+                string = String(expression);
+                if (string) {
+                  if (!isRaw) {
+                    string = escapeFunction(string);
+                  }
+                  yield string;
+                }
+              }
+              continue;
+            }
+            string = String(expression);
+          }
+          if (string) {
+            if (!isRaw) {
+              string = escapeFunction(string);
+            }
+            yield string;
+          }
+        }
+        continue;
+      }
+      string = String(expression);
+    }
+    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
+      literal = literal.slice(0, -1);
+    } else {
+      string &&= escapeFunction(string);
+    }
+    if (literal || string) {
+      yield literal + string;
+    }
+  }
+  if (literals.raw[expressions.length]) {
+    yield literals.raw[expressions.length];
+  }
+};
+/**
+ * @param {TemplateStringsArray} literals literals
+ * @param {...any} expressions expressions
+ * @yields {string} string
+ * @returns {AsyncGenerator<string, void, void>} AsyncGenerator<string, void, void>
+ */
+export const htmlAsyncGenerator = async function* (literals, ...expressions) {
+  for (let i = 0; i !== expressions.length; ++i) {
+    let expression = await expressions[i];
+    let literal = literals.raw[i];
+    let string;
+    if (typeof expression === "string") {
+      string = expression;
+    } else if (expression === undefined || expression === null) {
+      string = "";
+    } else {
+      if (expression[Symbol.iterator] || expression[Symbol.asyncIterator]) {
+        const isRaw =
+          Boolean(literal) && literal.charCodeAt(literal.length - 1) === 33;
+        if (isRaw) {
+          literal = literal.slice(0, -1);
+        }
+        if (literal) {
+          yield literal;
+        }
+        for await (expression of expression) {
+          if (typeof expression === "string") {
+            string = expression;
+          } else {
+            if (expression === undefined || expression === null) {
+              continue;
+            }
+            if (
+              expression[Symbol.iterator] ||
+              expression[Symbol.asyncIterator]
+            ) {
+              for await (expression of expression) {
+                if (expression === undefined || expression === null) {
+                  continue;
+                }
+                string = String(expression);
+                if (string) {
+                  if (!isRaw) {
+                    string = escapeFunction(string);
+                  }
+                  yield string;
+                }
+              }
+              continue;
+            }
+            string = String(expression);
+          }
+          if (string) {
+            if (!isRaw) {
+              string = escapeFunction(string);
+            }
+            yield string;
+          }
+        }
+        continue;
+      }
+      string = String(expression);
+    }
+    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
+      literal = literal.slice(0, -1);
+    } else {
+      string &&= escapeFunction(string);
+    }
+    if (literal || string) {
+      yield literal + string;
+    }
+  }
+  if (literals.raw[expressions.length]) {
+    yield literals.raw[expressions.length];
+  }
+};

package/src/html.d.ts DELETED Viewed

@@ -1,3 +0,0 @@
-export function html(literals: TemplateStringsArray, ...expressions: any[]): string;
-export function htmlGenerator(literals: TemplateStringsArray, ...expressions: any[]): Generator<string, void, void>;
-export function htmlAsyncGenerator(literals: TemplateStringsArray, ...expressions: any[]): AsyncGenerator<string, void, void>;

package/src/html.js DELETED Viewed

@@ -1,248 +0,0 @@
-/* eslint-disable no-await-in-loop, require-unicode-regexp */
-const escapeRegExp = /["&'<=>]/g;
-const escapeFunction = (string) => {
-  let escaped = "";
-  let start = 0;
-  while (escapeRegExp.test(string)) {
-    const i = escapeRegExp.lastIndex - 1;
-    switch (string.charCodeAt(i)) {
-      case 34: // "
-        escaped += string.slice(start, i) + "&#34;";
-        break;
-      case 38: // &
-        escaped += string.slice(start, i) + "&#38;";
-        break;
-      case 39: // '
-        escaped += string.slice(start, i) + "&#39;";
-        break;
-      case 60: // <
-        escaped += string.slice(start, i) + "&#60;";
-        break;
-      case 61: // =
-        escaped += string.slice(start, i) + "&#61;";
-        break;
-      case 62: // >
-        escaped += string.slice(start, i) + "&#62;";
-        break;
-    }
-    start = escapeRegExp.lastIndex;
-  }
-  return escaped + string.slice(start);
-};
-/**
- * @param {TemplateStringsArray} literals literals
- * @param {...any} expressions expressions
- * @returns {string} string
- */
-export const html = (literals, ...expressions) => {
-  let accumulator = "";
-  for (let i = 0; i !== expressions.length; ++i) {
-    let literal = literals.raw[i];
-    let string = Array.isArray(expressions[i])
-      ? expressions[i].join("")
-      : String(expressions[i] ?? "");
-    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
-      literal = literal.slice(0, -1);
-    } else {
-      string &&= escapeFunction(string);
-    }
-    accumulator += literal + string;
-  }
-  return accumulator + literals.raw[expressions.length];
-};
-/**
- * @param {TemplateStringsArray} literals literals
- * @param {...any} expressions expressions
- * @yields {string} string
- * @returns {Generator<string, void, void>} Generator<string, void, void>
- */
-export const htmlGenerator = function* (literals, ...expressions) {
-  for (let i = 0; i !== expressions.length; ++i) {
-    let expression = expressions[i];
-    let literal = literals.raw[i];
-    let string;
-    if (typeof expression === "string") {
-      string = expression;
-    } else if (expression === undefined || expression === null) {
-      string = "";
-    } else {
-      if (expression[Symbol.iterator]) {
-        const isRaw =
-          Boolean(literal) && literal.charCodeAt(literal.length - 1) === 33;
-        if (isRaw) {
-          literal = literal.slice(0, -1);
-        }
-        if (literal) {
-          yield literal;
-        }
-        for (expression of expression) {
-          if (typeof expression === "string") {
-            string = expression;
-          } else {
-            if (expression === undefined || expression === null) {
-              continue;
-            }
-            if (expression[Symbol.iterator]) {
-              for (expression of expression) {
-                if (expression === undefined || expression === null) {
-                  continue;
-                }
-                string = String(expression);
-                if (string) {
-                  if (!isRaw) {
-                    string = escapeFunction(string);
-                  }
-                  yield string;
-                }
-              }
-              continue;
-            }
-            string = String(expression);
-          }
-          if (string) {
-            if (!isRaw) {
-              string = escapeFunction(string);
-            }
-            yield string;
-          }
-        }
-        continue;
-      }
-      string = String(expression);
-    }
-    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
-      literal = literal.slice(0, -1);
-    } else {
-      string &&= escapeFunction(string);
-    }
-    if (literal || string) {
-      yield literal + string;
-    }
-  }
-  if (literals.raw[expressions.length]) {
-    yield literals.raw[expressions.length];
-  }
-};
-/**
- * @param {TemplateStringsArray} literals literals
- * @param {...any} expressions expressions
- * @yields {string} string
- * @returns {AsyncGenerator<string, void, void>} AsyncGenerator<string, void, void>
- */
-export const htmlAsyncGenerator = async function* (literals, ...expressions) {
-  for (let i = 0; i !== expressions.length; ++i) {
-    let expression = await expressions[i];
-    let literal = literals.raw[i];
-    let string;
-    if (typeof expression === "string") {
-      string = expression;
-    } else if (expression === undefined || expression === null) {
-      string = "";
-    } else {
-      if (expression[Symbol.iterator] || expression[Symbol.asyncIterator]) {
-        const isRaw =
-          Boolean(literal) && literal.charCodeAt(literal.length - 1) === 33;
-        if (isRaw) {
-          literal = literal.slice(0, -1);
-        }
-        if (literal) {
-          yield literal;
-        }
-        for await (expression of expression) {
-          if (typeof expression === "string") {
-            string = expression;
-          } else {
-            if (expression === undefined || expression === null) {
-              continue;
-            }
-            if (
-              expression[Symbol.iterator] ||
-              expression[Symbol.asyncIterator]
-            ) {
-              for await (expression of expression) {
-                if (expression === undefined || expression === null) {
-                  continue;
-                }
-                string = String(expression);
-                if (string) {
-                  if (!isRaw) {
-                    string = escapeFunction(string);
-                  }
-                  yield string;
-                }
-              }
-              continue;
-            }
-            string = String(expression);
-          }
-          if (string) {
-            if (!isRaw) {
-              string = escapeFunction(string);
-            }
-            yield string;
-          }
-        }
-        continue;
-      }
-      string = String(expression);
-    }
-    if (literal && literal.charCodeAt(literal.length - 1) === 33) {
-      literal = literal.slice(0, -1);
-    } else {
-      string &&= escapeFunction(string);
-    }
-    if (literal || string) {
-      yield literal + string;
-    }
-  }
-  if (literals.raw[expressions.length]) {
-    yield literals.raw[expressions.length];
-  }
-};