js-dev-tool 1.2.22 → 1.2.24

package/README.md

@@ -210,7 +210,9 @@ main().catch(console.error);
 Exports:
 
 - `gzip(data, useZeroTimestamp?)`
+- `gunzip(data)`
 - `toBase64SourceLiteral(rawData, wrapSize?)`
+- `fromBase64SourceLiteral(sourceLiteral)`
 
 Use this module when you want deterministic gzip output and a clean way to embed the compressed bytes into JavaScript source.
 
@@ -218,19 +220,26 @@ Key behaviors:
 
 - `gzip(...)` compresses with gzip level `9`
 - `gzip(..., true)` zeroes the gzip `mtime` header so repeated builds with the same input stay byte-stable
+- `gunzip(...)` restores raw bytes from gzip-compressed data
 - `toBase64SourceLiteral(...)` wraps Base64 output with trailing `\` line continuations so the result can be pasted into a multi-line JavaScript string literal
+- `fromBase64SourceLiteral(...)` reverses the wrapped source-literal form and accepts both LF and CRLF line continuations
 - `wrapSize` must be a finite integer between `1` and `2048`
 
 Example:
 
 ```js
-const { gzip, toBase64SourceLiteral } = require("js-dev-tool/extras/gzip-tool");
+const {
+  gzip, gunzip,
+  toBase64SourceLiteral, fromBase64SourceLiteral
+} = require("js-dev-tool/extras/gzip-tool");
 
 const compressed = gzip("console.log(\"hello\");");
 const sourceLiteral = toBase64SourceLiteral(compressed, 76);
+const restored = gunzip(fromBase64SourceLiteral(sourceLiteral));
 
 console.log(compressed.length);
 console.log(sourceLiteral);
+console.log(restored.toString("utf8"));
 ```
 
 ### `js-dev-tool/extras/progress-light`

package/extras/algorithms.d.ts

@@ -12,4 +12,5 @@
  * Array.sort etc...
  */
 export declare type TBnComparator<T, V> = (a: T, b: V) => number;
-export declare const bnSearch: <T, V>(src: T[], v: V, comparator: TBnComparator<T, V>) => number;
+export declare const bnSearch: <T, V>(src: T[], v: V, comparator: TBnComparator<T, V>) => number;
+export declare const bnFind: <T, V>(src: T[], v: V, comparator: TBnComparator<T, V>) => T | null;

package/extras/algorithms.js

@@ -34,6 +34,13 @@ const bnSearch = (src, v, comparator) => {
   }
   return -1;
 };
+/**
+ * @type {algzm["bnFind"]}
+ */
+const bnFind = (src, v, comparator) => {
+  const index = bnSearch(src, v, comparator);
+  return index >= 0 ? src[index] : null;
+};
 module.exports = {
-  bnSearch,
+  bnSearch, bnFind
 };

package/extras/gzip-tool.d.ts

@@ -21,6 +21,16 @@ import type { InputType } from "zlib";
  * @returns {Buffer} gzip-compressed binary data
  */
 export function gzip(data: InputType, useZeroTimestamp?: boolean): Buffer;
+/**
+ * Decompresses gzip binary data.
+ *
+ * This is a small wrapper around `zlib.gunzipSync(...)` so callers can pair it
+ * with {@link gzip} from the same helper module.
+ *
+ * @param {InputType} data gzip-compressed binary data
+ * @returns {Buffer} decompressed raw bytes
+ */
+export function gunzip(data: InputType): Buffer;
 /**
  * Encodes binary data as Base64 and formats it as a JavaScript string-literal fragment.
  *
@@ -31,4 +41,15 @@ export function gzip(data: InputType, useZeroTimestamp?: boolean): Buffer;
  * @param {number=} [wrapSize=100] max Base64 characters per physical line. (default __`100`__)
  * @returns {string} Base64 text wrapped with `\\\n` line continuations
  */
-export function toBase64SourceLiteral(rawData: Uint8Array, wrapSize?: number): string;
+export function toBase64SourceLiteral(rawData: Uint8Array, wrapSize?: number): string;
+/**
+ * Decodes a Base64 JavaScript string-literal fragment back into raw bytes.
+ *
+ * This reverses {@link toBase64SourceLiteral} by removing the trailing
+ * line-continuation sequences (`\\\n` or `\\\r\n`) between wrapped lines and then
+ * decoding the resulting Base64 text.
+ *
+ * @param {string} sourceLiteral Base64 source-literal fragment
+ * @returns {Buffer} decoded raw bytes
+ */
+export function fromBase64SourceLiteral(sourceLiteral: string): Buffer;

package/extras/gzip-tool.js

@@ -9,7 +9,7 @@
 /**
  * @file extras/gzip-tool.js
  */
-const { gzipSync, constants } = require("zlib");
+const { gzipSync, constants, gunzipSync } = require("zlib");
 /**
  * @import { InputType } from "zlib";
  */
@@ -24,7 +24,7 @@ const { gzipSync, constants } = require("zlib");
  * @param {boolean=} [useZeroTimestamp=true] when `true`, zeroes the gzip `mtime` header. (default __`true`__)
  * @returns {Buffer} gzip-compressed binary data
  */
-function gzip(data, useZeroTimestamp = true) {
+const gzip = (data, useZeroTimestamp = true) => {
   const compressed = gzipSync(data, {
     level: 9, strategy: constants.Z_DEFAULT_STRATEGY
   });
@@ -32,7 +32,17 @@ function gzip(data, useZeroTimestamp = true) {
     compressed.writeUInt32LE(0, 4);
   }
   return compressed;
-}
+};
+/**
+ * Decompresses gzip binary data.
+ *
+ * This is a small wrapper around `zlib.gunzipSync(...)` so callers can pair it
+ * with {@link gzip} from the same helper module.
+ *
+ * @param {InputType} data gzip-compressed binary data
+ * @returns {Buffer} decompressed raw bytes
+ */
+const gunzip = (data) => gunzipSync(data);
 /**
  * Encodes binary data as Base64 and formats it as a JavaScript string-literal fragment.
  *
@@ -43,7 +53,7 @@ function gzip(data, useZeroTimestamp = true) {
  * @param {number=} [wrapSize=100] max Base64 characters per physical line. (default __`100`__)
  * @returns {string} Base64 text wrapped with `\\\n` line continuations
  */
-function toBase64SourceLiteral(rawData, wrapSize = 100) {
+const toBase64SourceLiteral = (rawData, wrapSize = 100) => {
   if (!Number.isFinite(wrapSize)) throw new Error(`Invalid wrapSize: ${wrapSize}`);
   if (!Number.isInteger(wrapSize)) throw new Error(`wrapSize is not a integer - ${wrapSize}`);
   if (wrapSize > 2048) throw new Error(`"wrapSize" is expected to be 2048 or less - ${wrapSize}`);
@@ -59,7 +69,19 @@ function toBase64SourceLiteral(rawData, wrapSize = 100) {
     wrapped += (base64.slice(offset, offset += wrapSize) + lineSuffix);
   }
   return wrapped;
-}
+};
+/**
+ * Decodes a Base64 JavaScript string-literal fragment back into raw bytes.
+ *
+ * This reverses {@link toBase64SourceLiteral} by removing the trailing
+ * line-continuation sequences (`\\\n` or `\\\r\n`) between wrapped lines and then
+ * decoding the resulting Base64 text.
+ *
+ * @param {string} sourceLiteral Base64 source-literal fragment
+ * @returns {Buffer} decoded raw bytes
+ */
+const fromBase64SourceLiteral = (sourceLiteral) =>
+  Buffer.from(sourceLiteral.replace(/\\\r?\n/g, ""), "base64");
 module.exports = {
-  gzip, toBase64SourceLiteral
+  gzip, gunzip, toBase64SourceLiteral, fromBase64SourceLiteral
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.2.22",
+  "version": "1.2.24",
   "type": "commonjs",
   "bin": {
     "jstool": "tools.js",

package/tool-lib/cmt-trick.js

@@ -11,16 +11,16 @@
 /**
  * @file comment trick toggle
  */
+const rmc = require("rm-cstyle-cmts");
 /**
  * @param {string} code
  * @param {NsJsTool.TDevConsole} logger
  */
 function cleanup(code, logger) {
-  const reCleanUp = new RegExp(
-    "\s*\/(?:\s*\/+\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)([\s\S]+?)(?:\s+)\/\*\/[\s\S]+|\s*\*\s+(?:ctt|comment-toggle-trick|https:\/\/coderwall)[\s\S]+\/\*\/([\s\S]+?))\s*\/{2,}\*\/", "g"
-  );
+  const reCleanUp = /(?<=[\x20\t]*?)\/\/?\*\s+(?:ctt)[\s\S]+?\/\/\*\//gm;
   return code.replace(
-    reCleanUp, ($0, $1, $2) => $1 || $2 || $0,
+    reCleanUp,
+    $0 => rmc($0),
   );
 }
 /**
@@ -53,21 +53,22 @@ module.exports = () => {
         /** @type {string} */ (this.taskName), (code) => {
           return mode === "clean" ? cleanup(code, logger) : doIt(code, logger);
         }, {
-          ...params,
+          // @ts-expect-error force
+          base: params.basePath
         },
       );
     },
     get help() {
       const level = 16;
-      return `jstool -cmd cmtTrick[:clean] (-basePath "<source dir>" | -basePath "<source dir>,<source dir>,...") [-test "re/\\\\.js$/"]
+      return `jstool -cmd cmtTrick[:clean] (-base "<source dir>" | -base "<source dir>,<source dir>,...") [-test "r/\\\\.js$/"]
 
 ${"  Example:".red}
-  ${"jstool".yellow} ${"-cmd".green} ${"cmtTrick:clean".cyan} ${"-basePath".green} ${"src,examples".gray(level)} ${"-test".green} ${"re/\\\\.js$/".gray(level)}
+  ${"jstool".yellow} ${"-cmd".green} ${"cmtTrick:clean".cyan} ${"-base".green} ${"src,examples".gray(level)} ${"-test".green} ${"re/\\\\.js$/".gray(level)}
 
 ${"  Options:".red}
-  ${"  :clean".cyan}     ${`: Remove comment tokens and leave the currently enabled code.`.gray(level)}
-  ${"  basePath".cyan}   ${`: Source directory path(s). Comma-separated or array type arg is accepted.`.gray(level)}
-  ${"  test".cyan}       ${`: Target file matcher. default is /\\\\.js$/.`.gray(level)}
+  ${"  :clean".cyan} ${`: Remove comment tokens and leave the currently enabled code.`.gray(level)}
+  ${"  base".cyan}   ${`: Source directory path(s). Comma-separated or array type arg is accepted.`.gray(level)}
+  ${"  test".cyan}   ${`: Target file matcher. default is /\\\\.js$/.`.gray(level)}
 
 ${"  Note:".magenta} ${`Recognized markers: ctt | comment-toggle-trick | https://coderwall`.gray(level)}
 `;

package/utils.d.ts

@@ -12,10 +12,6 @@ import type {
 } from "fs";
 export const tinArgs: typeof import("tin-args");
 export type TFsCallback = (err: any, data: string) => void;
-export type TypedRecord<T> = {
-  [x: string]: T;
-};
-export type TReadJsonCallback<T> = (err: any, data: Record<string, T>) => void;
 export type TExtraArgsValue = string | boolean | RegExp | string[];
 /**
  * prepend `content` to the beginning of each element of `str_array`
@@ -83,15 +79,16 @@ export function readText<C extends TBD<TFsCallback>, R extends undefined extends
  * @param path
  * @param [callback]
  */
-export function readJson<T, C extends TBD<TReadJsonCallback<string>>, R extends undefined extends C ? TypedRecord<T> : void>(path: string, callback?: C): R;
+export function readJson<T = Record<string, unknown>>(path: string): T;
+export function readJson<T = Record<string, unknown>>(path: string, callback: (err: any, data: T) => void): void;
 /**
  * @template T
- * @param {T} json file path.
+ * @param {T} json json object
  * @param {string} path file path.
- * @param {TWriteJsonCallback} [callback]
+ * @param {() => void=} [callback]
  * @returns {void} description
  */
-declare function writeJson<T>(json: T, path: string, callback?: TWriteJsonCallback): void;
+declare function writeJson<T>(json: T, path: string, callback?: () => void): void;
 /**
  * @template T
  * @param {T} json

package/utils.js

@@ -142,26 +142,15 @@ function readText(from, callback) {
   }
   return /** @type {R} */ (undefined);
 }
-/**
- * @template T
- * @typedef {Record<string, T>} TypedRecord<T>
- */
-/**
- * @template T
- * @typedef {TBD<(err: any, data: TypedRecord<T>) => void>} TReadJsonCallback
- */
-/**
- * @typedef {TBD<() => void>} TWriteJsonCallback
- */
 /**
  * NOTE: when callback specified, returns undefined
  *
  * @template T
- * @template {TReadJsonCallback<T>} C description
- * @template {Conditional<C, TypedRecord<T>, void>} R description
- * @param {string} path file path.
- * @param {C} [callback]
- * @returns {R} description
+ * @template {(err: any, data: T) => void=} C
+ * @template {C extends void ? T : void} R
+ * @param {string} path
+ * @param {C=} callback
+ * @returns {R}
  */
 function readJson(path, callback) {
   if (typeof callback === "function") {
@@ -176,9 +165,9 @@ function readJson(path, callback) {
 }
 /**
  * @template T
- * @param {T} json file path.
+ * @param {T} json json object
  * @param {string} path file path.
- * @param {TWriteJsonCallback} [callback]
+ * @param {() => void=} [callback]
  * @returns {void} description
  */
 function writeJson(json, path, callback) {