ts-codemod-lib 2.2.1 → 2.2.3

package/dist/functions/ast-transformers/transform-source-code.mjs

@@ -2,84 +2,82 @@ import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 
 const extractFileIgnoreTransformers = (code) => {
-    // Try to find any of the supported file-level ignore comment prefixes
-    const patterns = [
-        {
-            prefix: 'transformer-ignore',
-            regex: /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u,
-        },
-        {
-            prefix: 'ts-codemod-ignore',
-            regex: /\/\*\s*ts-codemod-ignore\s*(.*?)\s*\*\//u,
-        },
-        {
-            prefix: 'codemod-ignore',
-            regex: /\/\*\s*codemod-ignore\s*(.*?)\s*\*\//u,
-        },
-        {
-            prefix: 'transform-ignore',
-            regex: /\/\*\s*transform-ignore\s*(.*?)\s*\*\//u,
-        },
-    ];
-    for (const { regex } of patterns) {
-        const match = regex.exec(code);
-        if (match !== null) {
-            const targetTransformers = match[1]?.trim() ?? '';
-            // Empty means ignore all transformers
-            if (targetTransformers === '') {
-                return [];
-            }
-            // Parse comma-separated transformer names
-            return targetTransformers.split(',').map((name) => name.trim());
-        }
+  const patterns = [
+    {
+      prefix: "transformer-ignore",
+      regex: /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u
+    },
+    {
+      prefix: "ts-codemod-ignore",
+      regex: /\/\*\s*ts-codemod-ignore\s*(.*?)\s*\*\//u
+    },
+    {
+      prefix: "codemod-ignore",
+      regex: /\/\*\s*codemod-ignore\s*(.*?)\s*\*\//u
+    },
+    {
+      prefix: "transform-ignore",
+      regex: /\/\*\s*transform-ignore\s*(.*?)\s*\*\//u
     }
-    return [];
+  ];
+  for (const { regex } of patterns) {
+    const match = regex.exec(code);
+    if (match !== null) {
+      const targetTransformers = match[1]?.trim() ?? "";
+      if (targetTransformers === "") {
+        return [];
+      }
+      return targetTransformers.split(",").map((name) => name.trim());
+    }
+  }
+  return [];
 };
 const shouldSkipFile = (code, transformerName) => {
-    const ignoredTransformers = extractFileIgnoreTransformers(code);
-    // If no file-level ignore comment found, don't skip
-    const patterns = [
-        /\/\*\s*transformer-ignore\s*.*?\s*\*\//u,
-        /\/\*\s*ts-codemod-ignore\s*.*?\s*\*\//u,
-        /\/\*\s*codemod-ignore\s*.*?\s*\*\//u,
-        /\/\*\s*transform-ignore\s*.*?\s*\*\//u,
-    ];
-    const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
-    if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {
-        return false;
-    }
-    // Empty array means ignore all transformers (file-level ignore without specific transformers)
-    if (Arr.isArrayOfLength(ignoredTransformers, 0)) {
-        return true;
-    }
-    // If transformer name is not specified, don't skip
-    if (transformerName === undefined) {
-        return false;
-    }
-    // Check if the transformer is in the ignore list
-    return ignoredTransformers.includes(transformerName);
+  const ignoredTransformers = extractFileIgnoreTransformers(code);
+  const patterns = [
+    /\/\*\s*transformer-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*ts-codemod-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*codemod-ignore\s*.*?\s*\*\//u,
+    /\/\*\s*transform-ignore\s*.*?\s*\*\//u
+  ];
+  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
+  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {
+    return false;
+  }
+  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {
+    return true;
+  }
+  if (transformerName === void 0) {
+    return false;
+  }
+  return ignoredTransformers.includes(transformerName);
 };
 const transformSourceCode = (code, isTsx, transformers, debug = false) => {
-    const project = new tsm.Project({
-        useInMemoryFileSystem: true,
-        compilerOptions: {
-            jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,
-            target: tsm.ts.ScriptTarget.ESNext,
-            module: tsm.ts.ModuleKind.ESNext,
-        },
-    });
-    const sourceAst = project.createSourceFile(`source.${isTsx ? 'tsx' : 'ts'}`, code);
-    for (const transformer of transformers) {
-        const transformerName = transformer.name;
-        if (shouldSkipFile(code, transformerName)) {
-            if (debug) {
-                console.debug(`skipped by ignore-file comment for transformer: ${transformerName}`);
-            }
-            continue;
-        }
-        transformer.transform(sourceAst);
+  const project = new tsm.Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      jsx: isTsx ? tsm.ts.JsxEmit.React : void 0,
+      target: tsm.ts.ScriptTarget.ESNext,
+      module: tsm.ts.ModuleKind.ESNext
+    }
+  });
+  const sourceAst = project.createSourceFile(
+    `source.${isTsx ? "tsx" : "ts"}`,
+    code
+  );
+  for (const transformer of transformers) {
+    const transformerName = transformer.name;
+    if (shouldSkipFile(code, transformerName)) {
+      if (debug) {
+        console.debug(
+          `skipped by ignore-file comment for transformer: ${transformerName}`
+        );
+      }
+      continue;
     }
-    return sourceAst.getFullText();
+    transformer.transform(sourceAst);
+  }
+  return sourceAst.getFullText();
 };
 
 export { transformSourceCode };

package/dist/functions/ast-transformers/transform-source-code.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transform-source-code.mjs","sources":["../../../src/functions/ast-transformers/transform-source-code.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"transform-source-code.mjs","sources":["../../../src/functions/ast-transformers/transform-source-code.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type TsMorphTransformer } from './types.mjs';\n\nconst extractFileIgnoreTransformers = (code: string): readonly string[] => {\n  // Try to find any of the supported file-level ignore comment prefixes\n  const patterns = [\n    {\n      prefix: 'transformer-ignore',\n      regex: /\\/\\*\\s*transformer-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'ts-codemod-ignore',\n      regex: /\\/\\*\\s*ts-codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'codemod-ignore',\n      regex: /\\/\\*\\s*codemod-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n    {\n      prefix: 'transform-ignore',\n      regex: /\\/\\*\\s*transform-ignore\\s*(.*?)\\s*\\*\\//u,\n    },\n  ] as const;\n\n  for (const { regex } of patterns) {\n    const match = regex.exec(code);\n\n    if (match !== null) {\n      const targetTransformers = match[1]?.trim() ?? '';\n\n      // Empty means ignore all transformers\n      if (targetTransformers === '') {\n        return [];\n      }\n\n      // Parse comma-separated transformer names\n      return targetTransformers.split(',').map((name) => name.trim());\n    }\n  }\n\n  return [];\n};\n\nconst shouldSkipFile = (\n  code: string,\n  transformerName: string | undefined,\n): boolean => {\n  const ignoredTransformers = extractFileIgnoreTransformers(code);\n\n  // If no file-level ignore comment found, don't skip\n  const patterns = [\n    /\\/\\*\\s*transformer-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*ts-codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*codemod-ignore\\s*.*?\\s*\\*\\//u,\n    /\\/\\*\\s*transform-ignore\\s*.*?\\s*\\*\\//u,\n  ] as const;\n\n  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));\n\n  if (Arr.isArrayOfLength(ignoredTransformers, 0) && !hasFileIgnoreComment) {\n    return false;\n  }\n\n  // Empty array means ignore all transformers (file-level ignore without specific transformers)\n  if (Arr.isArrayOfLength(ignoredTransformers, 0)) {\n    return true;\n  }\n\n  // If transformer name is not specified, don't skip\n  if (transformerName === undefined) {\n    return false;\n  }\n\n  // Check if the transformer is in the ignore list\n  return ignoredTransformers.includes(transformerName);\n};\n\nexport const transformSourceCode = (\n  code: string,\n  isTsx: boolean,\n  transformers: readonly TsMorphTransformer[],\n  debug: boolean = false,\n): string => {\n  const project = new tsm.Project({\n    useInMemoryFileSystem: true,\n    compilerOptions: {\n      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,\n      target: tsm.ts.ScriptTarget.ESNext,\n      module: tsm.ts.ModuleKind.ESNext,\n    },\n  });\n\n  const sourceAst = project.createSourceFile(\n    `source.${isTsx ? 'tsx' : 'ts'}`,\n    code,\n  );\n\n  for (const transformer of transformers) {\n    const transformerName = transformer.name;\n\n    if (shouldSkipFile(code, transformerName)) {\n      if (debug) {\n        console.debug(\n          `skipped by ignore-file comment for transformer: ${transformerName}`,\n        );\n      }\n\n      continue;\n    }\n\n    transformer.transform(sourceAst);\n  }\n\n  return sourceAst.getFullText();\n};\n"],"names":[],"mappings":";;;AAIA,MAAM,6BAAA,GAAgC,CAAC,IAAA,KAAoC;AAEzE,EAAA,MAAM,QAAA,GAAW;AAAA,IACf;AAAA,MACE,MAAA,EAAQ,oBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,mBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,gBAAA;AAAA,MACR,KAAA,EAAO;AAAA,KACT;AAAA,IACA;AAAA,MACE,MAAA,EAAQ,kBAAA;AAAA,MACR,KAAA,EAAO;AAAA;AACT,GACF;AAEA,EAAA,KAAA,MAAW,EAAE,KAAA,EAAM,IAAK,QAAA,EAAU;AAChC,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,IAAA,CAAK,IAAI,CAAA;AAE7B,IAAA,IAAI,UAAU,IAAA,EAAM;AAClB,MAAA,MAAM,kBAAA,GAAqB,KAAA,CAAM,CAAC,CAAA,EAAG,MAAK,IAAK,EAAA;AAG/C,MAAA,IAAI,uBAAuB,EAAA,EAAI;AAC7B,QAAA,OAAO,EAAC;AAAA,MACV;AAGA,MAAA,OAAO,kBAAA,CAAmB,MAAM,GAAG,CAAA,CAAE,IAAI,CAAC,IAAA,KAAS,IAAA,CAAK,IAAA,EAAM,CAAA;AAAA,IAChE;AAAA,EACF;AAEA,EAAA,OAAO,EAAC;AACV,CAAA;AAEA,MAAM,cAAA,GAAiB,CACrB,IAAA,EACA,eAAA,KACY;AACZ,EAAA,MAAM,mBAAA,GAAsB,8BAA8B,IAAI,CAAA;AAG9D,EAAA,MAAM,QAAA,GAAW;AAAA,IACf,yCAAA;AAAA,IACA,wCAAA;AAAA,IACA,qCAAA;AAAA,IACA;AAAA,GACF;AAEA,EAAA,MAAM,oBAAA,GAAuB,SAAS,IAAA,CAAK,CAAC,UAAU,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA;AAEtE,EAAA,IAAI,IAAI,eAAA,CAAgB,mBAAA,EAAqB,CAAC,CAAA,IAAK,CAAC,oBAAA,EAAsB;AACxE,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,GAAA,CAAI,eAAA,CAAgB,mBAAA,EAAqB,CAAC,CAAA,EAAG;AAC/C,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,IAAI,oBAAoB,MAAA,EAAW;AACjC,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,OAAO,mBAAA,CAAoB,SAAS,eAAe,CAAA;AACrD,CAAA;AAEO,MAAM,sBAAsB,CACjC,IAAA,EACA,KAAA,EACA,YAAA,EACA,QAAiB,KAAA,KACN;AACX,EAAA,MAAM,OAAA,GAAU,IAAI,GAAA,CAAI,OAAA,CAAQ;AAAA,IAC9B,qBAAA,EAAuB,IAAA;AAAA,IACvB,eAAA,EAAiB;AAAA,MACf,GAAA,EAAK,KAAA,GAAQ,GAAA,CAAI,EAAA,CAAG,QAAQ,KAAA,GAAQ,MAAA;AAAA,MACpC,MAAA,EAAQ,GAAA,CAAI,EAAA,CAAG,YAAA,CAAa,MAAA;AAAA,MAC5B,MAAA,EAAQ,GAAA,CAAI,EAAA,CAAG,UAAA,CAAW;AAAA;AAC5B,GACD,CAAA;AAED,EAAA,MAAM,YAAY,OAAA,CAAQ,gBAAA;AAAA,IACxB,CAAA,OAAA,EAAU,KAAA,GAAQ,KAAA,GAAQ,IAAI,CAAA,CAAA;AAAA,IAC9B;AAAA,GACF;AAEA,EAAA,KAAA,MAAW,eAAe,YAAA,EAAc;AACtC,IAAA,MAAM,kBAAkB,WAAA,CAAY,IAAA;AAEpC,IAAA,IAAI,cAAA,CAAe,IAAA,EAAM,eAAe,CAAA,EAAG;AACzC,MAAA,IAAI,KAAA,EAAO;AACT,QAAA,OAAA,CAAQ,KAAA;AAAA,UACN,mDAAmD,eAAe,CAAA;AAAA,SACpE;AAAA,MACF;AAEA,MAAA;AAAA,IACF;AAEA,IAAA,WAAA,CAAY,UAAU,SAAS,CAAA;AAAA,EACjC;AAEA,EAAA,OAAO,UAAU,WAAA,EAAY;AAC/B;;;;"}

package/dist/functions/constants/ignore-comment-text.d.mts

@@ -1,3 +1,3 @@
-export declare const IGNORE_LINE_COMMENT_PREFIXES: readonly ["transformer-ignore-next-line", "ts-codemod-ignore-next-line", "codemod-ignore-next-line", "transform-ignore-next-line"];
-export declare const IGNORE_FILE_COMMENT_PREFIXES: readonly ["transformer-ignore", "ts-codemod-ignore", "codemod-ignore", "transform-ignore"];
+export declare const IGNORE_LINE_COMMENT_PREFIXES: readonly ['transformer-ignore-next-line', 'ts-codemod-ignore-next-line', 'codemod-ignore-next-line', 'transform-ignore-next-line'];
+export declare const IGNORE_FILE_COMMENT_PREFIXES: readonly ['transformer-ignore', 'ts-codemod-ignore', 'codemod-ignore', 'transform-ignore'];
 //# sourceMappingURL=ignore-comment-text.d.mts.map

package/dist/functions/constants/ignore-comment-text.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ignore-comment-text.d.mts","sourceRoot":"","sources":["../../../src/functions/constants/ignore-comment-text.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,oIAK/B,CAAC;AAEX,eAAO,MAAM,4BAA4B,4FAK/B,CAAC"}
+{"version":3,"file":"ignore-comment-text.d.mts","sourceRoot":"","sources":["../../../src/functions/constants/ignore-comment-text.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,YACvC,8BAA8B,EAC9B,6BAA6B,EAC7B,0BAA0B,EAC1B,4BAA4B,CACpB,CAAC;AAEX,eAAO,MAAM,4BAA4B,YACvC,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,CACV,CAAC"}

package/dist/functions/constants/ignore-comment-text.mjs

@@ -1,14 +1,14 @@
 const IGNORE_LINE_COMMENT_PREFIXES = [
-    'transformer-ignore-next-line',
-    'ts-codemod-ignore-next-line',
-    'codemod-ignore-next-line',
-    'transform-ignore-next-line',
+  "transformer-ignore-next-line",
+  "ts-codemod-ignore-next-line",
+  "codemod-ignore-next-line",
+  "transform-ignore-next-line"
 ];
 const IGNORE_FILE_COMMENT_PREFIXES = [
-    'transformer-ignore',
-    'ts-codemod-ignore',
-    'codemod-ignore',
-    'transform-ignore',
+  "transformer-ignore",
+  "ts-codemod-ignore",
+  "codemod-ignore",
+  "transform-ignore"
 ];
 
 export { IGNORE_FILE_COMMENT_PREFIXES, IGNORE_LINE_COMMENT_PREFIXES };

package/dist/functions/constants/ignore-comment-text.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ignore-comment-text.mjs","sources":["../../../src/functions/constants/ignore-comment-text.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,4BAA4B,GAAG;IAC1C,8BAA8B;IAC9B,6BAA6B;IAC7B,0BAA0B;IAC1B,4BAA4B;;AAGvB,MAAM,4BAA4B,GAAG;IAC1C,oBAAoB;IACpB,mBAAmB;IACnB,gBAAgB;IAChB,kBAAkB;;;;;"}
+{"version":3,"file":"ignore-comment-text.mjs","sources":["../../../src/functions/constants/ignore-comment-text.mts"],"sourcesContent":["export const IGNORE_LINE_COMMENT_PREFIXES = [\n  'transformer-ignore-next-line',\n  'ts-codemod-ignore-next-line',\n  'codemod-ignore-next-line',\n  'transform-ignore-next-line',\n] as const;\n\nexport const IGNORE_FILE_COMMENT_PREFIXES = [\n  'transformer-ignore',\n  'ts-codemod-ignore',\n  'codemod-ignore',\n  'transform-ignore',\n] as const;\n"],"names":[],"mappings":"AAAO,MAAM,4BAAA,GAA+B;AAAA,EAC1C,8BAAA;AAAA,EACA,6BAAA;AAAA,EACA,0BAAA;AAAA,EACA;AACF;AAEO,MAAM,4BAAA,GAA+B;AAAA,EAC1C,oBAAA;AAAA,EACA,mBAAA;AAAA,EACA,gBAAA;AAAA,EACA;AACF;;;;"}

package/dist/functions/functions/has-disable-next-line-comment.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"has-disable-next-line-comment.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/has-disable-next-line-comment.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAGhC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GACpC,MAAM,GAAG,CAAC,IAAI,EACd,kBAAkB,MAAM,KACvB,OAwEF,CAAC"}
+{"version":3,"file":"has-disable-next-line-comment.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/has-disable-next-line-comment.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAGhC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,SAC9B,GAAG,CAAC,IAAI,oBACI,MAAM,KACvB,OAwEF,CAAC"}

package/dist/functions/functions/has-disable-next-line-comment.mjs

@@ -1,74 +1,42 @@
 import * as tsm from 'ts-morph';
 import { IGNORE_LINE_COMMENT_PREFIXES } from '../constants/ignore-comment-text.mjs';
 
-/**
- * Checks if a given ts-morph Node is immediately preceded by an ignore-next-line comment,
- * optionally filtered by transformer name(s).
- *
- * @param node - The ts-morph Node to check.
- * @param transformerName - Optional transformer name to check for specific ignore directive.
- *                          If provided, only ignores if the comment specifies this transformer.
- *                          Supports ESLint-style syntax like:
- *                          - `// transformer-ignore-next-line` (ignores all transformers)
- *                          - `// transformer-ignore-next-line append-as-const` (specific transformer)
- *                          - `// transformer-ignore-next-line append-as-const, replace-any-with-unknown` (multiple transformers)
- *                          - Also accepts `ts-codemod-ignore-next-line`, `codemod-ignore-next-line`, `transform-ignore-next-line`
- * @returns True if the node is preceded by the ignore comment on the immediately previous line, false otherwise.
- */
 const hasDisableNextLineComment = (node, transformerName) => {
-    const nodeStartLine = node.getStartLineNumber();
-    // Cannot be ignored if it's on the first line
-    if (nodeStartLine <= 1) {
-        return false;
-    }
-    const sourceFile = node.getSourceFile(); // Get the SourceFile
-    const leadingCommentRanges = node.getLeadingCommentRanges();
-    // Iterate backwards through comments as the closest one is most relevant
-    for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const commentRange = leadingCommentRanges[mut_i];
-        // Get the end position and convert it to line number
-        const commentEndPos = commentRange.getEnd();
-        const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;
-        // Check if the comment is on the immediately preceding line
-        if (nodeStartLine === commentEndLine + 1) {
-            // Check if it's a single-line comment containing the specific ignore text
-            if (commentRange.getKind() === tsm.SyntaxKind.SingleLineCommentTrivia) {
-                const commentText = commentRange.getText().trim();
-                // Check if the comment contains any of the supported ignore prefixes
-                const matchedPrefix = IGNORE_LINE_COMMENT_PREFIXES.find((prefix) => commentText.includes(prefix));
-                if (matchedPrefix !== undefined) {
-                    // Extract the part after the prefix
-                    const afterPrefix = commentText
-                        .slice(commentText.indexOf(matchedPrefix))
-                        .replace(matchedPrefix, '')
-                        .trim();
-                    // If no transformer name specified, check if comment applies to all transformers
-                    if (transformerName === undefined) {
-                        return true;
-                    }
-                    // If no specific transformers listed in comment, it applies to all
-                    if (afterPrefix === '') {
-                        return true;
-                    }
-                    // Check if the transformer name is in the comma-separated list
-                    const targetTransformers = afterPrefix
-                        .split(',')
-                        .map((name) => name.trim());
-                    return targetTransformers.includes(transformerName);
-                }
-            }
-            // If we found *any* comment on the preceding line, but it wasn't
-            // the correct ignore comment, then the node is not ignored by
-            // a comment on the *immediately* preceding line. Stop checking further back.
-            return false;
-        }
-        // If the comment ends before the preceding line, stop checking further back.
-        if (commentEndLine < nodeStartLine - 1) {
-            break;
+  const nodeStartLine = node.getStartLineNumber();
+  if (nodeStartLine <= 1) {
+    return false;
+  }
+  const sourceFile = node.getSourceFile();
+  const leadingCommentRanges = node.getLeadingCommentRanges();
+  for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {
+    const commentRange = leadingCommentRanges[mut_i];
+    const commentEndPos = commentRange.getEnd();
+    const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;
+    if (nodeStartLine === commentEndLine + 1) {
+      if (commentRange.getKind() === tsm.SyntaxKind.SingleLineCommentTrivia) {
+        const commentText = commentRange.getText().trim();
+        const matchedPrefix = IGNORE_LINE_COMMENT_PREFIXES.find(
+          (prefix) => commentText.includes(prefix)
+        );
+        if (matchedPrefix !== void 0) {
+          if (transformerName === void 0) {
+            return true;
+          }
+          const afterPrefix = commentText.slice(commentText.indexOf(matchedPrefix)).replace(matchedPrefix, "").trim();
+          if (afterPrefix === "") {
+            return true;
+          }
+          const targetTransformers = afterPrefix.split(",").map((name) => name.trim());
+          return targetTransformers.includes(transformerName);
         }
+      }
+      return false;
     }
-    return false;
+    if (commentEndLine < nodeStartLine - 1) {
+      break;
+    }
+  }
+  return false;
 };
 
 export { hasDisableNextLineComment };

package/dist/functions/functions/has-disable-next-line-comment.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-disable-next-line-comment.mjs","sources":["../../../src/functions/functions/has-disable-next-line-comment.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;AAaG;MACU,yBAAyB,GAAG,CACvC,IAAc,EACd,eAAwB,KACb;AACX,IAAA,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE;;AAG/C,IAAA,IAAI,aAAa,IAAI,CAAC,EAAE;AACtB,QAAA,OAAO,KAAK;IACd;IAEA,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;AAExC,IAAA,MAAM,oBAAoB,GAAG,IAAI,CAAC,uBAAuB,EAAE;;AAG3D,IAAA,KAAK,IAAI,KAAK,GAAG,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE;;AAErE,QAAA,MAAM,YAAY,GAAG,oBAAoB,CAAC,KAAK,CAAE;;AAGjD,QAAA,MAAM,aAAa,GAAG,YAAY,CAAC,MAAM,EAAE;QAE3C,MAAM,cAAc,GAAG,UAAU,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,IAAI;;AAG3E,QAAA,IAAI,aAAa,KAAK,cAAc,GAAG,CAAC,EAAE;;YAExC,IAAI,YAAY,CAAC,OAAO,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,uBAAuB,EAAE;gBACrE,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE;;AAGjD,gBAAA,MAAM,aAAa,GAAG,4BAA4B,CAAC,IAAI,CAAC,CAAC,MAAM,KAC7D,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAC7B;AAED,gBAAA,IAAI,aAAa,KAAK,SAAS,EAAE;;oBAE/B,MAAM,WAAW,GAAG;AACjB,yBAAA,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC;AACxC,yBAAA,OAAO,CAAC,aAAa,EAAE,EAAE;AACzB,yBAAA,IAAI,EAAE;;AAGT,oBAAA,IAAI,eAAe,KAAK,SAAS,EAAE;AACjC,wBAAA,OAAO,IAAI;oBACb;;AAGA,oBAAA,IAAI,WAAW,KAAK,EAAE,EAAE;AACtB,wBAAA,OAAO,IAAI;oBACb;;oBAGA,MAAM,kBAAkB,GAAG;yBACxB,KAAK,CAAC,GAAG;yBACT,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;AAE7B,oBAAA,OAAO,kBAAkB,CAAC,QAAQ,CAAC,eAAe,CAAC;gBACrD;YACF;;;;AAKA,YAAA,OAAO,KAAK;QACd;;AAGA,QAAA,IAAI,cAAc,GAAG,aAAa,GAAG,CAAC,EAAE;YACtC;QACF;IACF;AAEA,IAAA,OAAO,KAAK;AACd;;;;"}
+{"version":3,"file":"has-disable-next-line-comment.mjs","sources":["../../../src/functions/functions/has-disable-next-line-comment.mts"],"sourcesContent":["import * as tsm from 'ts-morph';\nimport { IGNORE_LINE_COMMENT_PREFIXES } from '../constants/index.mjs';\n\n/**\n * Checks if a given ts-morph Node is immediately preceded by an ignore-next-line comment,\n * optionally filtered by transformer name(s).\n *\n * @param node - The ts-morph Node to check.\n * @param transformerName - Optional transformer name to check for specific ignore directive.\n *                          If provided, only ignores if the comment specifies this transformer.\n *                          Supports ESLint-style syntax like:\n *                          - `// transformer-ignore-next-line` (ignores all transformers)\n *                          - `// transformer-ignore-next-line append-as-const` (specific transformer)\n *                          - `// transformer-ignore-next-line append-as-const, replace-any-with-unknown` (multiple transformers)\n *                          - Also accepts `ts-codemod-ignore-next-line`, `codemod-ignore-next-line`, `transform-ignore-next-line`\n * @returns True if the node is preceded by the ignore comment on the immediately previous line, false otherwise.\n */\nexport const hasDisableNextLineComment = (\n  node: tsm.Node,\n  transformerName?: string,\n): boolean => {\n  const nodeStartLine = node.getStartLineNumber();\n\n  // Cannot be ignored if it's on the first line\n  if (nodeStartLine <= 1) {\n    return false;\n  }\n\n  const sourceFile = node.getSourceFile(); // Get the SourceFile\n\n  const leadingCommentRanges = node.getLeadingCommentRanges();\n\n  // Iterate backwards through comments as the closest one is most relevant\n  for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const commentRange = leadingCommentRanges[mut_i]!;\n\n    // Get the end position and convert it to line number\n    const commentEndPos = commentRange.getEnd();\n\n    const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;\n\n    // Check if the comment is on the immediately preceding line\n    if (nodeStartLine === commentEndLine + 1) {\n      // Check if it's a single-line comment containing the specific ignore text\n      if (commentRange.getKind() === tsm.SyntaxKind.SingleLineCommentTrivia) {\n        const commentText = commentRange.getText().trim();\n\n        // Check if the comment contains any of the supported ignore prefixes\n        const matchedPrefix = IGNORE_LINE_COMMENT_PREFIXES.find((prefix) =>\n          commentText.includes(prefix),\n        );\n\n        if (matchedPrefix !== undefined) {\n          // If no transformer name specified, check if comment applies to all transformers\n          if (transformerName === undefined) {\n            return true;\n          }\n\n          // Extract the part after the prefix\n          const afterPrefix = commentText\n            .slice(commentText.indexOf(matchedPrefix))\n            .replace(matchedPrefix, '')\n            .trim();\n\n          // If no specific transformers listed in comment, it applies to all\n          if (afterPrefix === '') {\n            return true;\n          }\n\n          // Check if the transformer name is in the comma-separated list\n          const targetTransformers = afterPrefix\n            .split(',')\n            .map((name) => name.trim());\n\n          return targetTransformers.includes(transformerName);\n        }\n      }\n\n      // If we found *any* comment on the preceding line, but it wasn't\n      // the correct ignore comment, then the node is not ignored by\n      // a comment on the *immediately* preceding line. Stop checking further back.\n      return false;\n    }\n\n    // If the comment ends before the preceding line, stop checking further back.\n    if (commentEndLine < nodeStartLine - 1) {\n      break;\n    }\n  }\n\n  return false;\n};\n"],"names":[],"mappings":";;;AAiBO,MAAM,yBAAA,GAA4B,CACvC,IAAA,EACA,eAAA,KACY;AACZ,EAAA,MAAM,aAAA,GAAgB,KAAK,kBAAA,EAAmB;AAG9C,EAAA,IAAI,iBAAiB,CAAA,EAAG;AACtB,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,UAAA,GAAa,KAAK,aAAA,EAAc;AAEtC,EAAA,MAAM,oBAAA,GAAuB,KAAK,uBAAA,EAAwB;AAG1D,EAAA,KAAA,IAAS,QAAQ,oBAAA,CAAqB,MAAA,GAAS,CAAA,EAAG,KAAA,IAAS,GAAG,KAAA,EAAA,EAAS;AAErE,IAAA,MAAM,YAAA,GAAe,qBAAqB,KAAK,CAAA;AAG/C,IAAA,MAAM,aAAA,GAAgB,aAAa,MAAA,EAAO;AAE1C,IAAA,MAAM,cAAA,GAAiB,UAAA,CAAW,qBAAA,CAAsB,aAAa,CAAA,CAAE,IAAA;AAGvE,IAAA,IAAI,aAAA,KAAkB,iBAAiB,CAAA,EAAG;AAExC,MAAA,IAAI,YAAA,CAAa,OAAA,EAAQ,KAAM,GAAA,CAAI,WAAW,uBAAA,EAAyB;AACrE,QAAA,MAAM,WAAA,GAAc,YAAA,CAAa,OAAA,EAAQ,CAAE,IAAA,EAAK;AAGhD,QAAA,MAAM,gBAAgB,4BAAA,CAA6B,IAAA;AAAA,UAAK,CAAC,MAAA,KACvD,WAAA,CAAY,QAAA,CAAS,MAAM;AAAA,SAC7B;AAEA,QAAA,IAAI,kBAAkB,MAAA,EAAW;AAE/B,UAAA,IAAI,oBAAoB,MAAA,EAAW;AACjC,YAAA,OAAO,IAAA;AAAA,UACT;AAGA,UAAA,MAAM,WAAA,GAAc,WAAA,CACjB,KAAA,CAAM,WAAA,CAAY,OAAA,CAAQ,aAAa,CAAC,CAAA,CACxC,OAAA,CAAQ,aAAA,EAAe,EAAE,CAAA,CACzB,IAAA,EAAK;AAGR,UAAA,IAAI,gBAAgB,EAAA,EAAI;AACtB,YAAA,OAAO,IAAA;AAAA,UACT;AAGA,UAAA,MAAM,kBAAA,GAAqB,WAAA,CACxB,KAAA,CAAM,GAAG,CAAA,CACT,IAAI,CAAC,IAAA,KAAS,IAAA,CAAK,IAAA,EAAM,CAAA;AAE5B,UAAA,OAAO,kBAAA,CAAmB,SAAS,eAAe,CAAA;AAAA,QACpD;AAAA,MACF;AAKA,MAAA,OAAO,KAAA;AAAA,IACT;AAGA,IAAA,IAAI,cAAA,GAAiB,gBAAgB,CAAA,EAAG;AACtC,MAAA;AAAA,IACF;AAAA,EACF;AAEA,EAAA,OAAO,KAAA;AACT;;;;"}

package/dist/functions/functions/is-as-const-node.d.mts

@@ -2,7 +2,7 @@ import * as ts from 'ts-morph';
 export declare const isAsConstNode: (node: ts.Node) => node is ts.AsExpression & Readonly<{
     type: ts.TypeReferenceNode & Readonly<{
         typeName: ts.Identifier & Readonly<{
-            text: "const";
+            text: 'const';
         }>;
         typeArguments: undefined;
     }>;

package/dist/functions/functions/is-as-const-node.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-as-const-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-as-const-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/B,eAAO,MAAM,aAAa,GACxB,MAAM,EAAE,CAAC,IAAI,KACZ,IAAI,IAAI,EAAE,CAAC,YAAY,GACxB,QAAQ,CAAC;IACP,IAAI,EAAE,EAAE,CAAC,iBAAiB,GACxB,QAAQ,CAAC;QACP,QAAQ,EAAE,EAAE,CAAC,UAAU,GACrB,QAAQ,CAAC;YACP,IAAI,EAAE,OAAO,CAAC;SACf,CAAC,CAAC;QACL,aAAa,EAAE,SAAS,CAAC;KAC1B,CAAC,CAAC;CACN,CAgCF,CAAC"}
+{"version":3,"file":"is-as-const-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-as-const-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAE/B,eAAO,MAAM,aAAa,SAClB,EAAE,CAAC,IAAI,KACZ,IAAI,IAAI,EAAE,CAAC,YAAY,GACxB,QAAQ,CAAC;IACP,IAAI,EAAE,EAAE,CAAC,iBAAiB,GACxB,QAAQ,CAAC;QACP,QAAQ,EAAE,EAAE,CAAC,UAAU,GACrB,QAAQ,CAAC;YACP,IAAI,EAAE,OAAO,CAAC;SACf,CAAC,CAAC;QACL,aAAa,EAAE,SAAS,CAAC;KAC1B,CAAC,CAAC;CACN,CAgCF,CAAC"}

package/dist/functions/functions/is-as-const-node.mjs

@@ -2,29 +2,21 @@ import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 
 const isAsConstNode = (node) => {
-    if (!node.isKind(tsm.SyntaxKind.AsExpression)) {
-        return false;
-    }
-    // 2. Get the 'type' node from the AsExpression
-    const typeNode = node.getTypeNode();
-    if (typeNode === undefined) {
-        return false; // Should have a type node for 'as const'
-    }
-    // 3. Check if the 'type' node is a TypeReference
-    if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
-        return false;
-    }
-    // 4. Get the 'typeName' from the TypeReference
-    const typeNameNode = typeNode.getTypeName();
-    // 5. Check if the 'typeName' is an Identifier
-    if (!typeNameNode.isKind(tsm.SyntaxKind.Identifier)) {
-        // 'as const' uses a simple Identifier 'const', not a QualifiedName
-        return false;
-    }
-    // 6. Check if the Identifier's text is 'const'
-    //    and that there are no type arguments (as const doesn't have them)
-    return (typeNameNode.getText() === 'const' &&
-        Arr.isArrayOfLength(typeNode.getTypeArguments(), 0));
+  if (!node.isKind(tsm.SyntaxKind.AsExpression)) {
+    return false;
+  }
+  const typeNode = node.getTypeNode();
+  if (typeNode === void 0) {
+    return false;
+  }
+  if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
+    return false;
+  }
+  const typeNameNode = typeNode.getTypeName();
+  if (!typeNameNode.isKind(tsm.SyntaxKind.Identifier)) {
+    return false;
+  }
+  return typeNameNode.getText() === "const" && Arr.isArrayOfLength(typeNode.getTypeArguments(), 0);
 };
 
 export { isAsConstNode };

package/dist/functions/functions/is-as-const-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-as-const-node.mjs","sources":["../../../src/functions/functions/is-as-const-node.mts"],"sourcesContent":[null],"names":["ts"],"mappings":";;;AAGO,MAAM,aAAa,GAAG,CAC3B,IAAa,KAWR;AACL,IAAA,IAAI,CAAC,IAAI,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;AAC5C,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE;AAEnC,IAAA,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,OAAO,KAAK,CAAC;IACf;;AAGA,IAAA,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;AACjD,QAAA,OAAO,KAAK;IACd;;AAGA,IAAA,MAAM,YAAY,GAAG,QAAQ,CAAC,WAAW,EAAE;;AAG3C,IAAA,IAAI,CAAC,YAAY,CAAC,MAAM,CAACA,GAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;;AAElD,QAAA,OAAO,KAAK;IACd;;;AAIA,IAAA,QACE,YAAY,CAAC,OAAO,EAAE,KAAK,OAAO;QAClC,GAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;AAEvD;;;;"}
+{"version":3,"file":"is-as-const-node.mjs","sources":["../../../src/functions/functions/is-as-const-node.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as ts from 'ts-morph';\n\nexport const isAsConstNode = (\n  node: ts.Node,\n): node is ts.AsExpression &\n  Readonly<{\n    type: ts.TypeReferenceNode &\n      Readonly<{\n        typeName: ts.Identifier &\n          Readonly<{\n            text: 'const';\n          }>;\n        typeArguments: undefined;\n      }>;\n  }> => {\n  if (!node.isKind(ts.SyntaxKind.AsExpression)) {\n    return false;\n  }\n\n  // 2. Get the 'type' node from the AsExpression\n  const typeNode = node.getTypeNode();\n\n  if (typeNode === undefined) {\n    return false; // Should have a type node for 'as const'\n  }\n\n  // 3. Check if the 'type' node is a TypeReference\n  if (!typeNode.isKind(ts.SyntaxKind.TypeReference)) {\n    return false;\n  }\n\n  // 4. Get the 'typeName' from the TypeReference\n  const typeNameNode = typeNode.getTypeName();\n\n  // 5. Check if the 'typeName' is an Identifier\n  if (!typeNameNode.isKind(ts.SyntaxKind.Identifier)) {\n    // 'as const' uses a simple Identifier 'const', not a QualifiedName\n    return false;\n  }\n\n  // 6. Check if the Identifier's text is 'const'\n  //    and that there are no type arguments (as const doesn't have them)\n  return (\n    typeNameNode.getText() === 'const' &&\n    Arr.isArrayOfLength(typeNode.getTypeArguments(), 0)\n  );\n};\n"],"names":["ts"],"mappings":";;;AAGO,MAAM,aAAA,GAAgB,CAC3B,IAAA,KAWM;AACN,EAAA,IAAI,CAAC,IAAA,CAAK,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,YAAY,CAAA,EAAG;AAC5C,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,QAAA,GAAW,KAAK,WAAA,EAAY;AAElC,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,IAAI,CAAC,QAAA,CAAS,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,aAAa,CAAA,EAAG;AACjD,IAAA,OAAO,KAAA;AAAA,EACT;AAGA,EAAA,MAAM,YAAA,GAAe,SAAS,WAAA,EAAY;AAG1C,EAAA,IAAI,CAAC,YAAA,CAAa,MAAA,CAAOA,GAAA,CAAG,UAAA,CAAW,UAAU,CAAA,EAAG;AAElD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,OACE,YAAA,CAAa,SAAQ,KAAM,OAAA,IAC3B,IAAI,eAAA,CAAgB,QAAA,CAAS,gBAAA,EAAiB,EAAG,CAAC,CAAA;AAEtD;;;;"}

package/dist/functions/functions/is-atomic-type-node.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-atomic-type-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAkBlD,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,IAAI,GACnC,QAAQ,CACJ,GAAG,CAAC,eAAe,GACnB,GAAG,CAAC,uBAAuB,GAC3B,CAAC,GAAG,CAAC,QAAQ,GAAG;IACd,IAAI,EACA,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,cAAc,GAC7B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,gBAAgB,GAC/B,GAAG,CAAC,UAAU,CAAC,WAAW,GAC1B,GAAG,CAAC,UAAU,CAAC,UAAU,GACzB,GAAG,CAAC,UAAU,CAAC,cAAc,GAC7B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC;CACjC,CAAC,CACL,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,cAmBV,CAAC"}
+{"version":3,"file":"is-atomic-type-node.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAkBlD,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,IAAI,GACnC,QAAQ,CACJ,GAAG,CAAC,eAAe,GACnB,GAAG,CAAC,uBAAuB,GAC3B,CAAC,GAAG,CAAC,QAAQ,GAAG;IACd,IAAI,EACA,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,cAAc,GAC7B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,gBAAgB,GAC/B,GAAG,CAAC,UAAU,CAAC,WAAW,GAC1B,GAAG,CAAC,UAAU,CAAC,UAAU,GACzB,GAAG,CAAC,UAAU,CAAC,cAAc,GAC7B,GAAG,CAAC,UAAU,CAAC,aAAa,GAC5B,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC;CACjC,CAAC,CACL,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,SACrB,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,KAC3B,IAAI,IAAI,cAmBV,CAAC"}

package/dist/functions/functions/is-atomic-type-node.mjs

@@ -1,45 +1,31 @@
 import { ISet } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 
-// Define the set of SyntaxKinds that represent primitive type keywords
 const atomicTypeKeywordKinds = ISet.create([
-    tsm.SyntaxKind.StringKeyword,
-    tsm.SyntaxKind.BooleanKeyword,
-    tsm.SyntaxKind.NumberKeyword,
-    tsm.SyntaxKind.BigIntKeyword,
-    tsm.SyntaxKind.SymbolKeyword,
-    tsm.SyntaxKind.UndefinedKeyword,
-    tsm.SyntaxKind.VoidKeyword,
-    tsm.SyntaxKind.AnyKeyword,
-    tsm.SyntaxKind.UnknownKeyword,
-    tsm.SyntaxKind.ObjectKeyword, // Note: 'object' is sometimes considered primitive in TS type system context
-    tsm.SyntaxKind.NeverKeyword,
+  tsm.SyntaxKind.StringKeyword,
+  tsm.SyntaxKind.BooleanKeyword,
+  tsm.SyntaxKind.NumberKeyword,
+  tsm.SyntaxKind.BigIntKeyword,
+  tsm.SyntaxKind.SymbolKeyword,
+  tsm.SyntaxKind.UndefinedKeyword,
+  tsm.SyntaxKind.VoidKeyword,
+  tsm.SyntaxKind.AnyKeyword,
+  tsm.SyntaxKind.UnknownKeyword,
+  tsm.SyntaxKind.ObjectKeyword,
+  // Note: 'object' is sometimes considered primitive in TS type system context
+  tsm.SyntaxKind.NeverKeyword
 ]);
-/**
- * Checks if a given ts-morph node represents a primitive type node.
- * This includes keyword types (string, number, etc.), literal types (null, "abc", 123),
- * and template literal types.
- *
- * @param node - The ts-morph node to check.
- * @returns True if the node represents a primitive type node, false otherwise.
- *          Acts as a type guard.
- */
 const isAtomicTypeNode = (node) => {
-    // Check for literal types (null, "aaa", 1.23, 456n, true, false)
-    if (node.isKind(tsm.SyntaxKind.LiteralType)) {
-        return true;
-    }
-    // Check for template literal types (`abc${expr}def`)
-    if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {
-        return true;
-    }
-    // Check if it's a TypeNode and its kind is one of the primitive keywords
-    // Node.isTypeNode(node) ensures we only check nodes that represent types
-    // if (ts.Node.isTypeNode(node) && primitiveKeywordKinds.has(node.getKind())) {
-    if (atomicTypeKeywordKinds.has(node.getKind())) {
-        return true;
-    }
-    return false;
+  if (node.isKind(tsm.SyntaxKind.LiteralType)) {
+    return true;
+  }
+  if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {
+    return true;
+  }
+  if (atomicTypeKeywordKinds.has(node.getKind())) {
+    return true;
+  }
+  return false;
 };
 
 export { isAtomicTypeNode };

package/dist/functions/functions/is-atomic-type-node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-atomic-type-node.mjs","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;AACA,MAAM,sBAAsB,GAAG,IAAI,CAAC,MAAM,CAAiB;IACzD,GAAG,CAAC,UAAU,CAAC,aAAa;IAC5B,GAAG,CAAC,UAAU,CAAC,cAAc;IAC7B,GAAG,CAAC,UAAU,CAAC,aAAa;IAC5B,GAAG,CAAC,UAAU,CAAC,aAAa;IAC5B,GAAG,CAAC,UAAU,CAAC,aAAa;IAC5B,GAAG,CAAC,UAAU,CAAC,gBAAgB;IAC/B,GAAG,CAAC,UAAU,CAAC,WAAW;IAC1B,GAAG,CAAC,UAAU,CAAC,UAAU;IACzB,GAAG,CAAC,UAAU,CAAC,cAAc;AAC7B,IAAA,GAAG,CAAC,UAAU,CAAC,aAAa;IAC5B,GAAG,CAAC,UAAU,CAAC,YAAY;AAC5B,CAAA,CAAC;AAuBF;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAA4B,KACF;;IAE1B,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;AAC3C,QAAA,OAAO,IAAI;IACb;;IAGA,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE;AACnD,QAAA,OAAO,IAAI;IACb;;;;IAKA,IAAI,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE;AAC9C,QAAA,OAAO,IAAI;IACb;AAEA,IAAA,OAAO,KAAK;AACd;;;;"}
+{"version":3,"file":"is-atomic-type-node.mjs","sources":["../../../src/functions/functions/is-atomic-type-node.mts"],"sourcesContent":["import { ISet } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly } from 'ts-type-forge';\n\n// Define the set of SyntaxKinds that represent primitive type keywords\nconst atomicTypeKeywordKinds = ISet.create<tsm.SyntaxKind>([\n  tsm.SyntaxKind.StringKeyword,\n  tsm.SyntaxKind.BooleanKeyword,\n  tsm.SyntaxKind.NumberKeyword,\n  tsm.SyntaxKind.BigIntKeyword,\n  tsm.SyntaxKind.SymbolKeyword,\n  tsm.SyntaxKind.UndefinedKeyword,\n  tsm.SyntaxKind.VoidKeyword,\n  tsm.SyntaxKind.AnyKeyword,\n  tsm.SyntaxKind.UnknownKeyword,\n  tsm.SyntaxKind.ObjectKeyword, // Note: 'object' is sometimes considered primitive in TS type system context\n  tsm.SyntaxKind.NeverKeyword,\n]);\n\n// transformer-ignore-next-line convert-to-readonly\nexport type AtomicTypeNode = tsm.Node &\n  Readonly<\n    | tsm.LiteralTypeNode\n    | tsm.TemplateLiteralTypeNode\n    | (tsm.TypeNode & {\n        kind:\n          | tsm.SyntaxKind.StringKeyword\n          | tsm.SyntaxKind.BooleanKeyword\n          | tsm.SyntaxKind.NumberKeyword\n          | tsm.SyntaxKind.BigIntKeyword\n          | tsm.SyntaxKind.SymbolKeyword\n          | tsm.SyntaxKind.UndefinedKeyword\n          | tsm.SyntaxKind.VoidKeyword\n          | tsm.SyntaxKind.AnyKeyword\n          | tsm.SyntaxKind.UnknownKeyword\n          | tsm.SyntaxKind.ObjectKeyword\n          | tsm.SyntaxKind.NeverKeyword;\n      })\n  >;\n\n/**\n * Checks if a given ts-morph node represents a primitive type node.\n * This includes keyword types (string, number, etc.), literal types (null, \"abc\", 123),\n * and template literal types.\n *\n * @param node - The ts-morph node to check.\n * @returns True if the node represents a primitive type node, false otherwise.\n *          Acts as a type guard.\n */\nexport const isAtomicTypeNode = (\n  node: DeepReadonly<tsm.Node>,\n): node is AtomicTypeNode => {\n  // Check for literal types (null, \"aaa\", 1.23, 456n, true, false)\n  if (node.isKind(tsm.SyntaxKind.LiteralType)) {\n    return true;\n  }\n\n  // Check for template literal types (`abc${expr}def`)\n  if (node.isKind(tsm.SyntaxKind.TemplateLiteralType)) {\n    return true;\n  }\n\n  // Check if it's a TypeNode and its kind is one of the primitive keywords\n  // Node.isTypeNode(node) ensures we only check nodes that represent types\n  // if (ts.Node.isTypeNode(node) && primitiveKeywordKinds.has(node.getKind())) {\n  if (atomicTypeKeywordKinds.has(node.getKind())) {\n    return true;\n  }\n\n  return false;\n};\n\nif (import.meta.vitest !== undefined) {\n  // Helper to get a specific type node from source code\n  const getTypeNodeFromSource = (\n    sourceCode: string,\n    typeName: string,\n  ): tsm.TypeNode => {\n    const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n    const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n    const typeAlias = sourceFile.getTypeAliasOrThrow(typeName);\n\n    return typeAlias.getTypeNodeOrThrow();\n  };\n\n  // Helper to get the first node of a specific kind from source code\n  const getFirstNodeOfKind = <T extends tsm.Node>(\n    sourceCode: string,\n    kind: tsm.SyntaxKind,\n  ): T | undefined => {\n    const project = new tsm.Project({ useInMemoryFileSystem: true });\n\n    const sourceFile = project.createSourceFile('test.ts', sourceCode);\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return sourceFile.getFirstDescendantByKind(kind) as T | undefined;\n  };\n\n  describe('isAtomicTypeNode', () => {\n    describe('positive cases', () => {\n      test.each([\n        {\n          name: 'string',\n          code: 'type Test = string;',\n          kind: tsm.SyntaxKind.StringKeyword,\n        },\n        {\n          name: 'number',\n          code: 'type Test = number;',\n          kind: tsm.SyntaxKind.NumberKeyword,\n        },\n        {\n          name: 'boolean',\n          code: 'type Test = boolean;',\n          kind: tsm.SyntaxKind.BooleanKeyword,\n        },\n        {\n          name: 'bigint',\n          code: 'type Test = bigint;',\n          kind: tsm.SyntaxKind.BigIntKeyword,\n        },\n        {\n          name: 'symbol',\n          code: 'type Test = symbol;',\n          kind: tsm.SyntaxKind.SymbolKeyword,\n        },\n        {\n          name: 'undefined',\n          code: 'type Test = undefined;',\n          kind: tsm.SyntaxKind.UndefinedKeyword,\n        },\n        {\n          name: 'void',\n          code: 'type Test = void;',\n          kind: tsm.SyntaxKind.VoidKeyword,\n        },\n        {\n          name: 'any',\n          code: 'type Test = any;',\n          kind: tsm.SyntaxKind.AnyKeyword,\n        },\n        {\n          name: 'unknown',\n          code: 'type Test = unknown;',\n          kind: tsm.SyntaxKind.UnknownKeyword,\n        },\n        {\n          name: 'never',\n          code: 'type Test = never;',\n          kind: tsm.SyntaxKind.NeverKeyword,\n        },\n        {\n          name: 'object',\n          code: 'type Test = object;',\n          kind: tsm.SyntaxKind.ObjectKeyword,\n        }, // Included based on original code\n        {\n          name: 'null',\n          code: 'type Test = null;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'string literal (\"hello\")',\n          code: 'type Test = \"hello\";',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'number literal (123)',\n          code: 'type Test = 123;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'bigint literal (123n)',\n          code: 'type Test = 123n;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'boolean literal (true)',\n          code: 'type Test = true;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'boolean literal (false)',\n          code: 'type Test = false;',\n          kind: tsm.SyntaxKind.LiteralType,\n        },\n        {\n          name: 'TemplateLiteral',\n          // eslint-disable-next-line no-template-curly-in-string\n          code: 'type Test = `a${string}b`;',\n          kind: tsm.SyntaxKind.TemplateLiteralType,\n        },\n      ])('$name', ({ code, kind }) => {\n        const node = getTypeNodeFromSource(code, 'Test');\n\n        expect(node.getKind()).toBe(kind);\n\n        assert.isTrue(isAtomicTypeNode(node));\n      });\n    });\n\n    describe('negative cases', () => {\n      test.each([\n        {\n          name: 'Date TypeReference',\n          code: 'type Test = Date;',\n          kind: tsm.SyntaxKind.TypeReference,\n        },\n        {\n          name: 'Array Type',\n          code: 'type Test = number[];',\n          kind: tsm.SyntaxKind.ArrayType,\n        },\n        {\n          name: 'Tuple Type',\n          code: 'type Test = [string, number];',\n          kind: tsm.SyntaxKind.TupleType,\n        },\n        {\n          name: 'Type Literal',\n          code: 'type Test = { a: number };',\n          kind: tsm.SyntaxKind.TypeLiteral,\n        },\n        {\n          name: 'Readonly Type Operator',\n          code: 'type Test = readonly string[];',\n          kind: tsm.SyntaxKind.TypeOperator,\n        },\n        {\n          name: 'Union Type',\n          code: 'type Test = string | number;',\n          kind: tsm.SyntaxKind.UnionType,\n        },\n        {\n          name: 'Intersection Type',\n          code: 'type Test = A & B;',\n          kind: tsm.SyntaxKind.IntersectionType,\n        },\n        {\n          name: 'Mapped Type',\n          code: 'type Test = { [K in keyof T]: T[K] };',\n          kind: tsm.SyntaxKind.MappedType,\n        }, // Needs T defined\n        {\n          name: 'Parenthesized Type',\n          code: 'type Test = (string);',\n          kind: tsm.SyntaxKind.ParenthesizedType,\n        },\n        {\n          name: 'Conditional Type',\n          code: 'type Test = T extends U ? X : Y;',\n          kind: tsm.SyntaxKind.ConditionalType,\n        }, // Needs T, U, X, Y\n        {\n          name: 'Indexed Access Type',\n          code: 'type Test = T[K];',\n          kind: tsm.SyntaxKind.IndexedAccessType,\n        }, // Needs T, K\n        {\n          name: 'Type Query (typeof)',\n          code: 'type Test = typeof myVar;',\n          kind: tsm.SyntaxKind.TypeQuery,\n        },\n      ])('$name', ({ code, kind }) => {\n        const node = getTypeNodeFromSource(code, 'Test');\n\n        expect(node.getKind()).toBe(kind); // Verify node type\n\n        assert.isFalse(isAtomicTypeNode(node));\n      });\n\n      test.each([\n        {\n          name: 'Type Predicate',\n          code: 'function isString(x: any): x is string { return typeof x === \"string\"; }',\n          kind: tsm.SyntaxKind.TypePredicate,\n        }, // Node is part of function sig\n        {\n          name: 'This Type',\n          code: 'class C { method(): this {} }',\n          kind: tsm.SyntaxKind.ThisType,\n        }, // Node is part of method sig\n        {\n          name: 'Infer Type',\n          code: 'type Test<T> = T extends Promise<infer R> ? R : T;',\n          kind: tsm.SyntaxKind.InferType,\n        }, // Needs context\n      ])('$name (not a type node)', ({ code, kind }) => {\n        const node = getFirstNodeOfKind(code, kind);\n\n        expect(node).toBeDefined();\n\n        if (node === undefined) {\n          throw new Error('Node should be defined');\n        }\n\n        assert.isFalse(isAtomicTypeNode(node));\n      });\n    });\n  });\n}\n"],"names":[],"mappings":";;;AAKA,MAAM,sBAAA,GAAyB,KAAK,MAAA,CAAuB;AAAA,EACzD,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,cAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA,EACf,IAAI,UAAA,CAAW,gBAAA;AAAA,EACf,IAAI,UAAA,CAAW,WAAA;AAAA,EACf,IAAI,UAAA,CAAW,UAAA;AAAA,EACf,IAAI,UAAA,CAAW,cAAA;AAAA,EACf,IAAI,UAAA,CAAW,aAAA;AAAA;AAAA,EACf,IAAI,UAAA,CAAW;AACjB,CAAC,CAAA;AAgCM,MAAM,gBAAA,GAAmB,CAC9B,IAAA,KAC2B;AAE3B,EAAA,IAAI,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC3C,IAAA,OAAO,IAAA;AAAA,EACT;AAGA,EAAA,IAAI,IAAA,CAAK,MAAA,CAAO,GAAA,CAAI,UAAA,CAAW,mBAAmB,CAAA,EAAG;AACnD,IAAA,OAAO,IAAA;AAAA,EACT;AAKA,EAAA,IAAI,sBAAA,CAAuB,GAAA,CAAI,IAAA,CAAK,OAAA,EAAS,CAAA,EAAG;AAC9C,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,OAAO,KAAA;AACT;;;;"}

package/dist/functions/functions/is-conditional-type-distribution-guard.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-conditional-type-distribution-guard.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kCAAkC,GAAI,MAAM,GAAG,CAAC,IAAI,KAAG,OAsBnE,CAAC"}
+{"version":3,"file":"is-conditional-type-distribution-guard.d.mts","sourceRoot":"","sources":["../../../src/functions/functions/is-conditional-type-distribution-guard.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kCAAkC,SAAU,GAAG,CAAC,IAAI,KAAG,OAsBnE,CAAC"}