js-dev-tool 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "bin": {
     "jstool": "tools.js"
   },
@@ -35,6 +35,7 @@
     "!tool-lib/cjbm-*",
     "!scripts/unzip.ts",
     "!scripts/bin",
+    "!regex-test.ts",
     "!extras/npm",
     "!/**/*.png",
     "!tool.sh",

package/regex.d.ts

@@ -9,23 +9,64 @@
  * @file js-dev-scripts/regex.d.ts
  */
 declare global {
+  interface RegExp/* extends TypedRegExp<string, string>*/ {
+    /**
+     * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
+     * @template {string} P
+     * @template {string} F
+     * @param {TypedRegExp<P, F>} this The regular expression object.
+     * @param {string} str The String object or string literal on which to perform the search.
+     * @returns {RegExpExecArrayFixed< this > | null} An array of results or null if no match is found.
+     */
+    exec<const P extends string, const F extends string = "">(this: TypedRegExp<P, F>, str: string): RegExpExecArrayFixed< this > | null;
+  }
+  interface String {
+    /**
+     * Replaces occurrences of a pattern in the string with a specified replacement.
+     * @template {RegExp | string} SV
+     * @param searchValue A regular expression object.
+     * @param replaceValue A string or a function to create the new substring.
+     */
+    replace<SV extends RegExp | string>(this: string, searchValue: SV, replaceValue: ReplacerFunctionSignature<SV>): string;
+  }
   interface RegExpConstructor {
-    new <const P extends string, const F extends string = "">(pattern: string, flags?: F): RegExp & {
+    /**
+     * Creates a typed RegExp object with literal types for the pattern and flags.
+     * @template {string} P
+     * @template {string} F
+     * @param {P} pattern The regular expression pattern.
+     * @param {F} [flags] The flags for the regular expression.
+     * @returns {RegExp & { readonly source: P; readonly flags: F }} A typed RegExp object.
+     */
+    new <const P extends string, const F extends string = "">(pattern: P, flags?: F): RegExp & {
       readonly source: P;
       readonly flags: F;
     };
-    <const P extends string, const F extends string = "">(pattern: string, flags?: F): RegExp & {
+    /**
+     * Creates a typed RegExp object with literal types for the pattern and flags.
+     * @template {string} P
+     * @template {string} F
+     * @param {P} pattern The regular expression pattern.
+     * @param {F} [flags] The flags for the regular expression.
+     * @returns {RegExp & { readonly source: P; readonly flags: F }} A typed RegExp object.
+     */
+    <const P extends string, const F extends string = "">(pattern: P, flags?: F): RegExp & {
       readonly source: P;
       readonly flags: F;
     };
     readonly "prototype": RegExp;
   }
 }
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                                   Basics
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
 /**
  * Extracts the literal type from the source property of a RegExp.
  * @template R - A RegExp type.
  */
-export type ReSource<R extends RegExp> = R extends RegExp & { readonly source: infer T } ? T : never;
+export type RegExpSource<R extends RegExp> = R extends RegExp & { readonly source: infer T } ? T : never;
 export type TypedRegExp<const P extends string, const F extends string = ""> = RegExp & {
   readonly source: P;
   readonly flags: F;
@@ -34,6 +75,11 @@ export declare function createRegExp<
   const P extends string,
   const F extends string = ""
 >(pattern: P, flags?: F): TypedRegExp<P, F>;
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                            Named Capture Groups
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
 type FirstChar<S extends string> = S extends `${infer F}${infer _}` ? F : never;
 /**
  * Recursively extracts parts that match the format (?<GroupName>...) from a string pattern,
@@ -52,10 +98,17 @@ export type ExtractGroupNames<S extends string> =
  * Creates an object type with keys as the extracted group names and values as strings.
  * If no groups are found, it results in an empty object.
  * @template R - A RegExp type.
+ * @date 2025/12/24 14:46:30 - It may be possible to extract the group name accurately (?)
  */
-export type ReGroups<R extends RegExp> = {
-  [K in ExtractGroupNames<ReSource<R>>]?: string;
-};
+export type RegExpNamedGroups<R extends RegExp> = R extends { readonly source: infer T }
+ ? {
+  [K in ExtractGroupNames<T>]?: string;
+} : never;
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                               Capture Groups
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
 /**
  * Preprocesses escape sequences in a string pattern by replacing escaped backslashes and characters.
  * 
@@ -86,7 +139,7 @@ export type CountCaptureGroups<
     ? Rest extends `${"?:" | "?=" | "?!" | "?<=" | "?<!"}${infer After}`
       ? CountCaptureGroups<After, Counter>
       : CountCaptureGroups<Rest, [...Counter, unknown]>
-    : Counter['length'];
+    : Counter["length"];
 /**
  * Represents a fixed version of RegExpExecArray that includes the matched string,
  * captures, and optionally named groups.
@@ -96,21 +149,32 @@ export type CountCaptureGroups<
  */
 export type RegExpExecArrayFixed<
   R extends RegExp,
-  S extends ReSource<R> = ReSource<R>,
+  S extends RegExpSource<R> = RegExpSource<R>,
   GroupCount extends number = CountCaptureGroups<S>
-> = [match: string, ...ExtractCaptures<GroupCount>] & {
-  groups?: ReGroups<R>;
+> = [match: string, ...BuildCaptureTuple<GroupCount>] & {
+  groups?: RegExpNamedGroups<R>;
   index: number;
   input: string;
 };
+export type TupleOf<
+  Count extends number, ArrayType,
+  Result extends ArrayType[] = []
+> = Result["length"] extends Count
+  ? Result
+  : TupleOf<Count, ArrayType, [...Result, ArrayType]>;
 /**
- * Generates an array type with a length corresponding to the number of capture groups.
- * @template Count - The number of capture groups.
- * @template Result - The resulting array type.
+ * Builds a tuple type whose length equals the number of capture groups.
+ * @template Count - Number of capture groups.
+ * @template Result - Accumulator (internal).
  */
-export type ExtractCaptures<Count extends number, Result extends unknown[] = []> =
-  Result['length'] extends Count
-    ? Result : ExtractCaptures<Count, [...Result, string]>;
+export type BuildCaptureTuple<
+  Count extends number, ArrayType = string,
+> = TupleOf<Count, ArrayType>;
+/*!
+// ============================================================================
+//                          Helper Types for Replacer
+// ============================================================================
+*/
 /**
  * Creates the parameter types for String.replace callback function.
  * 
@@ -120,25 +184,17 @@ export type ExtractCaptures<Count extends number, Result extends unknown[] = []>
  */
 export type ReplaceCallbackParams<
   R extends RegExp,
-  S extends ReSource<R> = ReSource<R>,
+  S extends RegExpSource<R> = RegExpSource<R>,
   GroupCount extends number = CountCaptureGroups<S>
 > = [
   match: string,
-  ...captures: ExtractCaptures<GroupCount>,
+  ...captures: BuildCaptureTuple<GroupCount>,
   offset: number,
   input: string,
-  groups: ReGroups<R>
+  groups: RegExpNamedGroups<R>
 ];
-export type ReplacerFunctionSignature<R extends RegExp> = (...args: ReplaceCallbackParams<R>) => string;
-const re1 = createRegExp("(test)(group)()()()()()()()(22)", "g");
-type TRe1Replacer = ReplacerFunctionSignature<typeof re1>;
-type ExecResult1 = RegExpExecArrayFixed<typeof re1>;
-const re2 = createRegExp("(?<name1>test)(?<name2>group)", "g");
-type TRe2Replacer = ReplacerFunctionSignature<typeof re2>;
-type ExecResult2 = RegExpExecArrayFixed<typeof re2>;
-const result = re2.exec("test group") as RegExpExecArrayFixed<typeof re2>;
-if (result) {
-  console.log(result[1]);
-  console.log(result.groups?.name1);
-}
+export type ReplacerFunctionSignature<R extends unkown> =
+  R extends (
+    RegExp & { readonly source: infer T }
+  ) ? (...args: ReplaceCallbackParams<R, T>) => string : string;
 export as namespace XRegex;

package/scripts/publish-version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.0.15"
+  "version": "1.0.17"
 }

package/tool-lib/cjbm.js

@@ -13,7 +13,12 @@
 const fs = require("fs");
 const path = require("path");
 /**
- * @type {typeof XRegex.createRegExp}
+ * Creates a typed RegExp object with literal types for the pattern and flags.
+ * @template {string} P
+ * @template {string} F
+ * @param {P} pattern The regular expression pattern.
+ * @param {F} [flags] The flags for the regular expression.
+ * @returns {XRegex.TypedRegExp<P, F>} A typed RegExp object.
  */
 function createRegExp(pattern, flags) {
   return new RegExp(pattern, flags);
@@ -127,7 +132,7 @@ module.exports = () => {
     root     - Recursively searches for files.
                This option is useful, but if there are directories that need to be avoided, use the 'basePath' option
     basePath - can be "<path>,<path>,..." (array type arg)
-    ext      - specifies the module extension for import clauses. default is "js"
+    ext      - specifies the module extension for import/export clauses. default is "js"
     test     - Any file extension can be specified. (The default is /\\.js$/)
     targets  - specify this if you want to apply it only to a specific file.
                the file specified here should be directly under \`basePath\`!

package/tool-lib/cmt-trick.js

@@ -15,23 +15,11 @@
  * @param {string} code
  */
 function cleanup(code) {
-  const pcreStyle = String.raw`
-\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,}\*\/
-`;
+  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"
+  );
   return code.replace(
-    new RegExp(pcreStyle.replace(/\s*\(\?#.*\)\s*$|#\s.*$|\s+/gm, ""), "g"), ($0, $1, $2) => $1 || $2,
+    reCleanUp, ($0, $1, $2) => $1 || $2,
   );
 }
 /**