init

Author: Guthib-of-Dan

.github/workflows/commit-test.yml

@@ -0,0 +1,15 @@
+name: Test
+on: push
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: setup Node.js
+        uses: actions/setup-node@v4
+      - name: install deps
+        run: npm i
+      - name: run test
+        run: npx vitest run

.github/workflows/release.yml

@@ -0,0 +1,33 @@
+name: Test
+on:
+  release:
+    types: [created]
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+      - name: setup Node.js
+        uses: actions/setup-node@v4
+      - name: install deps
+        run: npm i
+      - name: run test
+        run: npx vitest run
+  deploy:
+    needs: test
+    name: Deploy on npm
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

.gitignore

@@ -0,0 +1 @@
+node_modules

.npmignore

@@ -0,0 +1,3 @@
+.gitignore
+.github
+tests

README.md

@@ -0,0 +1,82 @@
+![ublitzjs](https://github.com/ublitzjs/core/blob/main/logo.png)
+
+# @ublitzjs/dev-comments package for removing unused code using build step
+
+This package (currently) removes all code between <code>/\*\_START_DEV\_\*/</code> comment and <code>/\*\_END_DEV\_\*/</code>.
+
+## minifyFile
+
+For example, there is a file with console.log
+_some.js_
+
+```javascript
+let a = 10;
+console.log("BEFORE", a);
+a = await doSomething(a);
+console.log("AFTER", a);
+sendSomewhere(a);
+```
+
+But you want to debug this code AND don't care about that when the project goes to production<br>
+Just do this (esm or cjs - no difference)
+
+_some.js_
+
+```javascript
+let a = 10;
+/*_START_DEV_*/ console.log("BEFORE", a); /*_END_DEV_*/
+a = await prepare(a);
+/*_START_DEV_*/ console.log("AFTER", a); /*_END_DEV_*/
+sendSomewhere(a);
+```
+
+and in separate file define "build" script
+
+_build.js_
+
+```javascript
+import { minifyFile } from "@ublitzjs/dev-comments";
+import path from "node:path";
+await minifyFile(
+  /*absolute paths*/
+  path.resolve(import.meta.dirname, "./some.js"),
+  path.resolve(import.meta.dirname, "./some.output.js")
+);
+```
+
+It will generate the file as follows
+
+```javascript
+let a = 10;
+
+a = await doSomething(a);
+
+sendSomewhere(a);
+```
+
+## minifyFolder
+
+this function goes through all given file paths (which are off thee same format as keys of return type of "@ublitzjs/static".analyzeFolder function)
+
+```javascript
+import { minifyFolder } from "@ublitzjs/dev-comments";
+
+minifyFolder(
+  /*input directory path relative ot absolute path*/ "from",
+  /*ouput dir path*/ "to",
+  /*files */ ["b.js"]
+);
+```
+
+and example using analyzeFolder from "static" package
+
+```javascript
+import { minifyFolder } from "@ublitzjs/dev-comments";
+import { analyzeFolder } from "@ublitzjs/static";
+
+await minifyFolder(
+  "from",
+  "to",
+  Object.keys(await analyzeFolder("from", { deleteMimesList: true }))
+);
+```

cjs/index.cjs

@@ -0,0 +1,47 @@
+var { Worker } = require("node:worker_threads");
+var path = require("node:path");
+var fs = require("fs/promises");
+var os = require("node:os");
+var cpus = os.cpus().length;
+
+async function minifyFolder(inputDir, outputDir, filesToMinify) {
+  await fs.mkdir(outputDir, { recursive: true });
+  for (let i = 1; i <= cpus && filesToMinify.length; i++)
+    RegisterWorkersToFiles(inputDir, outputDir, filesToMinify);
+}
+async function RegisterWorkersToFiles(inputDir, outputDir, filesToMinify) {
+  do {
+    const fileName = filesToMinify.shift();
+    if (!fileName) return;
+    const inputPath = path.join(inputDir, fileName);
+    const outputPath = path.join(outputDir, fileName);
+    await minifyFile(inputPath, outputPath);
+  } while (filesToMinify.length);
+}
+
+async function minifyFile(input, output) {
+  const worker = new Worker(path.resolve(__dirname, "worker.cjs"), {
+    workerData: {
+      input,
+      output,
+    },
+  });
+  return new Promise((resolve, reject) => {
+    worker.on("message", (msg) => {
+      resolve(msg);
+    });
+
+    worker.on("error", (err) => {
+      reject(err);
+    });
+    worker.on("exit", (code) => {
+      if (code !== 0) {
+        reject(code);
+      }
+    });
+  });
+}
+module.exports = {
+  minifyFile,
+  minifyFolder,
+};

cjs/worker.cjs

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import { workerData, parentPort } from "node:worker_threads";
+import path from "node:path";
+
+const { input, output } = workerData;
+
+const START_TAG = "/*_START_DEV_*/";
+const END_TAG = "/*_END_DEV_*/";
+(async () => {
+  await fs.promises.mkdir(path.dirname(output), { recursive: true });
+
+  const rs = fs.createReadStream(input, {
+    encoding: "utf8",
+    highWaterMark: 20,
+  });
+  const ws = fs.createWriteStream(output, { encoding: "utf8" });
+
+  let buffer = ""; // holds leftover across chunks
+  let state = "KEEPING"; // or "DELETING"
+
+  rs.on("data", (chunk) => {
+    buffer += chunk;
+    let idx;
+
+    while (true) {
+      if (state === "KEEPING") {
+        idx = buffer.indexOf(START_TAG);
+        // No START tag – flush all except trailing possible START_TAG prefix
+        if (idx === -1) {
+          const safeEnd = buffer.length - START_TAG.length + 1;
+          if (safeEnd > 0) {
+            ws.write(buffer.slice(0, safeEnd));
+            buffer = buffer.slice(safeEnd);
+          }
+          break;
+        } else {
+          // Found START tag
+          ws.write(buffer.slice(0, idx));
+          buffer = buffer.slice(idx + START_TAG.length);
+          state = "DELETING";
+        }
+      } else {
+        idx = buffer.indexOf(END_TAG);
+        if (idx === -1) {
+          // Not found yet – trim buffer to last possible END_TAG start
+          buffer = buffer.slice(-END_TAG.length + 1);
+          break;
+        } else {
+          buffer = buffer.slice(idx + END_TAG.length);
+          state = "KEEPING";
+        }
+      }
+    }
+  });
+
+  rs.on("end", () => {
+    if (state === "KEEPING" && buffer.length > 0) {
+      ws.write(buffer);
+    }
+    ws.end(() => parentPort.postMessage(`${input} → ${output}`));
+  });
+
+  rs.on("error", (err) => parentPort.postMessage(`Read error: ${err}`));
+  ws.on("error", (err) => parentPort.postMessage(`Write error: ${err}`));
+})();

index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This function takes all files (in 3rd parameter) and effectively utilizes worker threads to get all of your code prepared as soon as possible.
+ * @param inputDir directory, which is 'compiled'
+ * @param outputDir directory, to whichfiles are 'compiled'
+ * @param filesToMinify array of filepaths, relative ot inputDir. will be created in same nested dirs and same names as is in inputDir.
+ */
+export function minifyFolder(
+  inputDir: string,
+  outputDir: string,
+  filesToMinify: string[]
+): Promise<any>;
+/**
+ * remove code in a single file
+ * @param input ABSOLUTE path to input file
+ * @param output ABSOLUTE path to output file
+ */
+export function minifyFile(
+  input: string,
+  output: string
+): Promise<Error | string>;

mjs/index.mjs

@@ -0,0 +1,44 @@
+import { Worker } from "node:worker_threads";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+var cpus = os.cpus().length;
+
+async function minifyFolder(inputDir, outputDir, filesToMinify) {
+  await fs.mkdir(outputDir, { recursive: true });
+  for (let i = 1; i <= cpus && filesToMinify.length; i++)
+    RegisterWorkersToFiles(inputDir, outputDir, filesToMinify);
+}
+async function RegisterWorkersToFiles(inputDir, outputDir, filesToMinify) {
+  do {
+    const fileName = filesToMinify.shift();
+    if (!fileName) return;
+    const inputPath = path.join(inputDir, fileName);
+    const outputPath = path.join(outputDir, fileName);
+    await minifyFile(inputPath, outputPath);
+  } while (filesToMinify.length);
+}
+
+async function minifyFile(input, output) {
+  const worker = new Worker(new URL("./worker.mjs", import.meta.url), {
+    workerData: {
+      input,
+      output,
+    },
+  });
+  return new Promise((resolve, reject) => {
+    worker.on("message", (msg) => {
+      resolve(msg);
+    });
+
+    worker.on("error", (err) => {
+      reject(err);
+    });
+    worker.on("exit", (code) => {
+      if (code !== 0) {
+        reject(code);
+      }
+    });
+  });
+}
+export { minifyFile, minifyFolder };

mjs/worker.mjs

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import { workerData, parentPort } from "node:worker_threads";
+import path from "node:path";
+
+const { input, output } = workerData;
+
+const START_TAG = "/*_START_DEV_*/";
+const END_TAG = "/*_END_DEV_*/";
+
+await fs.promises.mkdir(path.dirname(output), { recursive: true });
+
+const rs = fs.createReadStream(input, { encoding: "utf8", highWaterMark: 20 });
+const ws = fs.createWriteStream(output, { encoding: "utf8" });
+
+let buffer = ""; // holds leftover across chunks
+let state = "KEEPING"; // or "DELETING"
+
+rs.on("data", (chunk) => {
+  buffer += chunk;
+  let idx;
+
+  while (true) {
+    if (state === "KEEPING") {
+      idx = buffer.indexOf(START_TAG);
+      if (idx === -1) {
+        // No START tag – flush all except trailing possible START_TAG prefix
+        const safeEnd = buffer.length - START_TAG.length + 1;
+        if (safeEnd > 0) {
+          ws.write(buffer.slice(0, safeEnd));
+          buffer = buffer.slice(safeEnd);
+        }
+        break;
+      } else {
+        // Found START tag
+        ws.write(buffer.slice(0, idx));
+        buffer = buffer.slice(idx + START_TAG.length);
+        state = "DELETING";
+      }
+    } else {
+      idx = buffer.indexOf(END_TAG);
+      if (idx === -1) {
+        // Not found yet – trim buffer to last possible END_TAG start
+        buffer = buffer.slice(-END_TAG.length + 1);
+        break;
+      } else {
+        buffer = buffer.slice(idx + END_TAG.length);
+        state = "KEEPING";
+      }
+    }
+  }
+});
+
+rs.on("end", () => {
+  if (state === "KEEPING" && buffer.length > 0) {
+    ws.write(buffer);
+  }
+  ws.end(() => parentPort.postMessage(`${input} → ${output}`));
+});
+
+rs.on("error", (err) => parentPort.postMessage(`Read error: ${err}`));
+ws.on("error", (err) => parentPort.postMessage(`Write error: ${err}`));