js-dev-tool 1.2.4 → 1.2.6

package/basic-types.d.ts

@@ -107,6 +107,7 @@ type PickStringProperties<T> = PickProperties<string, T>;
 type NonFunctionPropertyNames<T> = { [K in keyof T]-?: T[K] extends Function ? never : K }[keyof T];
 type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
 type ArrayToUnion<T extends readonly unknown[]> = T[number];
+type ExpandUnion<T> = T extends any ? T : never;
 /**
  * for lazy assign class.
  */

package/extras/algorithms.d.ts

@@ -0,0 +1,15 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file extras/algorithms.d.ts
+ */
+/**
+ * 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;

package/extras/algorithms.js

@@ -0,0 +1,39 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file extras/algorithms.js
+ */
+/**
+ * @import * as algzm from "./algorithms.js";
+ */
+/**
+ * @type {algzm["bnSearch"]}
+ */
+const bnSearch = (src, v, comparator) => {
+  let low = 0;
+  let hi = src.length - 1;
+  while (low <= hi) {
+    /** to middle index */
+    const m = low + ((hi - low) >>> 1);
+    /** compare value */
+    const r = comparator(src[m], v);
+    if (r > 0) {
+      hi = m - 1;
+    }
+    else if (r < 0) {
+      low = m + 1;
+    }
+    else {
+      return m;
+    }
+  }
+  return -1;
+};
+module.exports = {
+  bnSearch,
+};

package/extras/jsonl.d.ts

@@ -0,0 +1,116 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * Resolve a file name to an absolute JSONL path.
+ */
+export type TJsonlPathResolver = (fileName: string) => string;
+/**
+ * Handle JSON parse errors from {@link readJsonl}.
+ *
+ * `lineNo` is the physical line number in the source file.
+ */
+export type TJsonlParseErrorHandler = (error: unknown, line: string, lineNo: number) => void;
+/**
+ * Common options for JSONL line reading.
+ */
+export type TJsonlReadBaseOption = {
+  /**
+   * @default undefined
+   */
+  baseDir?: string;
+  /**
+   * @default undefined
+   */
+  pathResolver?: TJsonlPathResolver;
+  /**
+   * @default "utf8"
+   */
+  encoding?: BufferEncoding;
+  /**
+   * __Recommended minimum value is `128` (integer)__
+   *
+   * __Decimals are internally converted to integers__ `(| 0)`
+   *
+   * - The chunk size passed to `fs.createReadStream`.
+   * - Expected: A finite number greater than or equal to `128`.
+   * - Decimal values are truncated to signed 32-bit integer by `| 0`.
+   * - Very large values can overflow signed 32-bit range and may fail in Node.js stream validation.
+   */
+  highWaterMark?: number;
+  /**
+   * @default true
+   */
+  skipEmptyLine?: boolean;
+};
+/**
+ * Options for row-level JSONL parsing and transformation.
+ */
+export type TJsonlReadOption<TRow = any, TOut = TRow> = TJsonlReadBaseOption & {
+  /**
+   * @default undefined
+   */
+  onParseError?: TJsonlParseErrorHandler;
+  /**
+   * @default undefined
+   */
+  keyField?: string;
+  /**
+   * @default undefined
+   */
+  filter?: (row: TRow) => boolean;
+  /**
+   * @default undefined
+   */
+  map?: (row: TRow) => TOut;
+};
+/**
+ * Resolve file path from `fileName` and options.
+ *
+ * Priority:
+ * 1) `pathResolver`
+ * 2) `path.resolve(baseDir || process.cwd(), fileName)`
+ */
+export function resolveJsonlPath(fileName: string, options?: Pick<TJsonlReadBaseOption, "baseDir" | "pathResolver">): string;
+/**
+ * Read JSONL file as raw lines.
+ *
+ * - Splits by LF (`\n`) and trims trailing CR (`\r`) per line.
+ * - By default, empty lines are skipped.
+ */
+export function readJsonlLines(fileName: string, onLine: (line: string, lineNo: number) => void, options?: TJsonlReadBaseOption): Promise<void>;
+/**
+ * Parse each JSONL line and emit typed rows.
+ *
+ * - Parse errors are reported via `onParseError` when provided.
+ * - Without `onParseError`, parse errors are logged to stderr.
+ */
+export function readJsonl<TRow = any>(fileName: string, onRow: (row: TRow, lineNo: number) => void, options?: TJsonlReadBaseOption & {
+  onParseError?: TJsonlParseErrorHandler;
+}): Promise<void>;
+/**
+ * Parse JSONL rows into an array.
+ *
+ * Supports row filtering and mapping via `filter` and `map`.
+ */
+export function readJsonlArray<TRow = any, TOut = TRow>(fileName: string, options?: TJsonlReadOption<TRow, TOut>): Promise<TOut[]>;
+/**
+ * Parse JSONL rows into a key-value map.
+ *
+ * - Key field defaults to `"_key"`.
+ * - Rows with `null` / `undefined` key are ignored.
+ * - On duplicate keys, later rows overwrite earlier rows.
+ */
+export function readJsonlMapByKey<TRow = any, TOut = TRow>(fileName: string, options?: TJsonlReadOption<TRow, TOut> & {
+  keyField?: string;
+}): Promise<Record<string, TOut>>;
+/**
+ * Fast extraction for top-level integer field from a JSONL line.
+ *
+ * Intended for performance-sensitive hot paths where full `JSON.parse` is unnecessary.
+ */
+export function fastGetIntFieldCheap(line: string, key: string): number | undefined;

package/extras/jsonl.js

@@ -0,0 +1,204 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+"use strict";
+/**
+ * @file extras/jsonl.js
+ */
+const fs = require("fs");
+const path = require("path");
+/**
+ * @import { TJsonlReadOption, TJsonlReadBaseOption } from "./jsonl.js";
+ */
+/**
+ * Resolve jsonl path from file name and options.
+ *
+ * @param {string} fileName
+ * @param {Pick<TJsonlReadBaseOption, "baseDir" | "pathResolver">=} options
+ * @returns {string}
+ */
+function resolveJsonlPath(fileName, options = {}) {
+  if (options.pathResolver) {
+    return options.pathResolver(fileName);
+  }
+  return path.resolve(options.baseDir || process.cwd(), fileName);
+}
+/**
+ * Fast path: extracts a top-level integer field from a JSONL line by searching `"${key}":`.
+ *
+ * Notes:
+ * - Intended for top-level integer fields only.
+ * - Returns `undefined` when the key does not exist or the value is not an integer.
+ *
+ * @param {string} line
+ * @param {string} key
+ * @returns {number | undefined}
+ */
+function fastGetIntFieldCheap(line, key) {
+  const pattern = `"${key}":`;
+  const keyStart = line.indexOf(pattern);
+  if (keyStart < 0) {
+    return undefined;
+  }
+  const lineLen = line.length;
+  let i = keyStart + pattern.length;
+  while (i < lineLen) {
+    const c = line[i];
+    if (c !== " " && c !== "\t") {
+      break;
+    }
+    i++;
+  }
+  let sign = 1;
+  if (line[i] === "-") {
+    sign = -1;
+    i++;
+  }
+  let n = 0;
+  let ok = 0;
+  for (; i < lineLen; i++) {
+    const c = line.charCodeAt(i);
+    if (c >= 48 && c <= 57) {
+      n = n * 10 + (c - 48);
+      ok = 1;
+    } else {
+      break;
+    }
+  }
+  return ok ? sign * n : undefined;
+}
+const HIGHWATERMARK_MIN = 128;
+/**
+ * @param {unknown} n 
+ * @returns {n is number}
+ */
+const isNumber = (n) => Number.isFinite(n);
+/**
+ * @param {string} fileName
+ * @param {(line: string, lineNo: number) => void} onLine
+ * @param {TJsonlReadBaseOption=} options
+ * @returns {Promise<void>}
+ */
+async function readJsonlLines(fileName, onLine, options = {}) {
+  const filePath = resolveJsonlPath(fileName, options);
+  /** @type {fs.ReadStreamOptions} */
+  const readOpt = {
+    encoding: options.encoding || "utf8",
+  };
+  if (isNumber(options.highWaterMark) && options.highWaterMark >= HIGHWATERMARK_MIN) {
+    readOpt.highWaterMark = options.highWaterMark | 0;
+  }
+  const skipEmptyLine = options.skipEmptyLine ?? true;
+  const stream = fs.createReadStream(filePath, readOpt);
+  let lineNo = 0;
+  let buf = "";
+  /** @param {string} rawLine */
+  const emitLine = (rawLine) => {
+    lineNo++;
+    if (rawLine[rawLine.length - 1] === "\r") {
+      rawLine = rawLine.slice(0, -1);
+    }
+    if (skipEmptyLine && !rawLine.length) {
+      return;
+    }
+    onLine(rawLine, lineNo);
+  };
+  for await (const chunk of stream) {
+    buf += chunk;
+    let start = 0;
+    while (true) {
+      const nl = buf.indexOf("\n", start);
+      if (nl === -1) {
+        break;
+      }
+      emitLine(buf.slice(start, nl));
+      start = nl + 1;
+    }
+    buf = buf.slice(start);
+  }
+  if (buf.length > 0) {
+    emitLine(buf);
+  }
+}
+/**
+ * @template T
+ * @param {string} fileName
+ * @param {(row: T, lineNo: number) => void} onRow
+ * @param {TJsonlReadOption=} options
+ * @returns {Promise<void>}
+ */
+async function readJsonl(fileName, onRow, options = {}) {
+  const jsonParse = JSON.parse;
+  const onParseError = options.onParseError;
+  await readJsonlLines(
+    fileName,
+    (line, lineNo) => {
+      try {
+        const row = jsonParse(line);
+        onRow(row, lineNo);
+      } catch (error) {
+        if (onParseError) {
+          onParseError(error, line, lineNo);
+          return;
+        }
+        console.error("jsonl parse error:", fileName, `line=${lineNo}`, error);
+      }
+    },
+    options
+  );
+}
+/**
+ * @template T
+ * @param {string} fileName
+ * @param {TJsonlReadOption=} options
+ * @returns {Promise<T[]>}
+ */
+async function readJsonlArray(fileName, options = {}) {
+  /** @type {T[]} */
+  const out = [];
+  const filter = options.filter;
+  const mapper = options.map;
+  await readJsonl(fileName, (row) => {
+    if (filter && !filter(row)) {
+      return;
+    }
+    out.push(mapper ? mapper(row) : row);
+  }, options);
+  return out;
+}
+/**
+ * @template T
+ * @param {string} fileName
+ * @param {TJsonlReadOption=} options
+ * @returns {Promise<Record<string, T>>}
+ */
+async function readJsonlMapByKey(fileName, options = {}) {
+  /** @type {Record<string, T>} */
+  const out = {};
+  const keyField = options.keyField || "_key";
+  const filter = options.filter;
+  const mapper = options.map;
+  await readJsonl(fileName, (row) => {
+    if (filter && !filter(row)) {
+      return;
+    }
+    const key = row[keyField];
+    if (key == null) {
+      return;
+    }
+    out[String(key)] = mapper ? mapper(row) : row;
+  }, options);
+  return out;
+}
+module.exports = {
+  resolveJsonlPath,
+  readJsonlLines,
+  readJsonl,
+  readJsonlArray,
+  readJsonlMapByKey,
+  fastGetIntFieldCheap,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "bin": {
     "jstool": "tools.js"
   },
@@ -72,7 +72,7 @@
     "!unzip.ts",
     "!scripts/bin",
     "!publish-version.json",
-    "!normalize-commit-msg.mjs",
+    "!scripts/*.mjs",
     "!regex-test.ts",
     "!extras/npm",
     "!/**/*.png",

package/tools.js

@@ -141,7 +141,7 @@ const ToolFunctions = {
           : [];
       if (paths.length) {
         utils.fireReplace(
-          /(v)?(\d+\.\d+\.\d+(?:[^\s"]+)?)/g,
+          /(v)?(\d+\.\d+\.\d+(?:[\w\-.+]+)?)/g,
           /** @type {TStringReplacer} */($0, $prefix, $versionStr) => {
             if ($versionStr === currentVersion) {
               return ($prefix ? "v" : "") + nextVersion;