@stacksjs/zig-dtsx 0.9.17 → 0.9.20

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/zig-dtsx",
   "type": "module",
-  "version": "0.9.17",
+  "version": "0.9.20",
   "description": "High-performance DTS emitter written in Zig",
   "exports": {
     ".": {
@@ -18,6 +18,6 @@
     "benchmark": "bun run test/benchmark.ts"
   },
   "dependencies": {
-    "@stacksjs/dtsx": "0.9.17"
+    "@stacksjs/dtsx": "0.9.20"
   }
 }

package/src/extractors.zig

@@ -555,11 +555,21 @@ pub fn buildDtsParams(s: *Scanner, raw_params: []const u8) []const u8 {
     var str_ch: u8 = 0;
     var skip_next = false;
 
+    var in_block_comment = false;
+    var skip_to_eol = false;
     for (inner, 0..) |c, i| {
         if (skip_next) {
             skip_next = false;
             continue;
         }
+        if (skip_to_eol) {
+            if (c == '\n') skip_to_eol = false;
+            continue;
+        }
+        if (in_block_comment) {
+            if (c == '/' and i > 0 and inner[i - 1] == '*') in_block_comment = false;
+            continue;
+        }
         if (in_str) {
             if (c == ch.CH_BACKSLASH) {
                 skip_next = true; // skip the escaped character
@@ -568,6 +578,20 @@ pub fn buildDtsParams(s: *Scanner, raw_params: []const u8) []const u8 {
             if (c == str_ch) in_str = false;
             continue;
         }
+        // Skip block and line comments — JSDoc prose can contain unmatched
+        // quote chars (e.g. apostrophe in "error's") that would otherwise
+        // trip the scanner into a string-literal mode it never escapes.
+        if (c == '/' and i + 1 < inner.len) {
+            const nc = inner[i + 1];
+            if (nc == '*') {
+                in_block_comment = true;
+                continue;
+            }
+            if (nc == '/') {
+                skip_to_eol = true;
+                continue;
+            }
+        }
         if (c == ch.CH_SQUOTE or c == ch.CH_DQUOTE or c == ch.CH_BACKTICK) {
             in_str = true;
             str_ch = c;
@@ -655,11 +679,21 @@ pub fn buildSingleDtsParam(s: *Scanner, raw: []const u8) []const u8 {
     var str_ch2: u8 = 0;
     var skip_next2 = false;
 
+    var in_block_comment2 = false;
+    var skip_to_eol2 = false;
     for (p, 0..) |c, i| {
         if (skip_next2) {
             skip_next2 = false;
             continue;
         }
+        if (skip_to_eol2) {
+            if (c == '\n') skip_to_eol2 = false;
+            continue;
+        }
+        if (in_block_comment2) {
+            if (c == '/' and i > 0 and p[i - 1] == '*') in_block_comment2 = false;
+            continue;
+        }
         if (in_str2) {
             if (c == ch.CH_BACKSLASH) {
                 skip_next2 = true;
@@ -668,6 +702,19 @@ pub fn buildSingleDtsParam(s: *Scanner, raw: []const u8) []const u8 {
             if (c == str_ch2) in_str2 = false;
             continue;
         }
+        // Skip block and line comments before string-mode detection so JSDoc
+        // apostrophes (e.g. "error's") don't trigger an unclosed string.
+        if (c == '/' and i + 1 < p.len) {
+            const nc = p[i + 1];
+            if (nc == '*') {
+                in_block_comment2 = true;
+                continue;
+            }
+            if (nc == '/') {
+                skip_to_eol2 = true;
+                continue;
+            }
+        }
         if (c == ch.CH_SQUOTE or c == ch.CH_DQUOTE or c == ch.CH_BACKTICK) {
             in_str2 = true;
             str_ch2 = c;
@@ -763,6 +810,30 @@ fn cleanDestructuredPattern(alloc: std.mem.Allocator, pattern: []const u8) []con
     while (i < pattern.len) : (i += 1) {
         const c = pattern[i];
 
+        // Preserve block and line comments verbatim (useful JSDoc) but skip
+        // parsing inside them so apostrophes in prose (e.g. "error's") don't
+        // put us in an inescapable string mode.
+        if (!in_str and c == '/' and i + 1 < pattern.len) {
+            const nc = pattern[i + 1];
+            if (nc == '*') {
+                const start = i;
+                var j = i + 2;
+                while (j + 1 < pattern.len and !(pattern[j] == '*' and pattern[j + 1] == '/')) : (j += 1) {}
+                const end = if (j + 1 < pattern.len) j + 2 else pattern.len;
+                result.appendSlice(pattern[start..end]) catch {};
+                i = end - 1; // loop's += 1 advances past
+                continue;
+            }
+            if (nc == '/') {
+                const start = i;
+                var j = i;
+                while (j < pattern.len and pattern[j] != '\n') : (j += 1) {}
+                result.appendSlice(pattern[start..j]) catch {};
+                i = if (j == 0) 0 else j - 1; // loop's += 1 lands on the newline
+                continue;
+            }
+        }
+
         // String tracking
         if (!in_str and (c == '\'' or c == '"' or c == '`')) {
             in_str = true;
@@ -934,16 +1005,18 @@ pub fn extractFunction(s: *Scanner, decl_start: usize, is_exported: bool, is_asy
 
     // Build DTS text — single alloc + memcpy is cheaper than ArrayList init +
     // multiple appendSlice + toOwnedSlice for the fixed-shape function header.
-    const export_prefix: []const u8 = if (is_exported) "export " else "";
-    const declare_kw = "declare function ";
+    // `export default function foo()` keeps its `default` keyword in DTS:
+    // `declare` is not allowed alongside `default`, and emitting
+    // `export declare function ...` would silently drop the default-export
+    // signal that consumers (and the dtsx TS reference impl) preserve.
+    const export_prefix: []const u8 = if (is_default) "export default function " else if (is_exported) "export declare function " else "declare function ";
     const colon_sep = ": ";
-    const total = export_prefix.len + declare_kw.len + func_name.len + generics.len +
+    const total = export_prefix.len + func_name.len + generics.len +
         dts_params.len + colon_sep.len + return_type.len + 1; // +1 for ';'
     const dts_text = blk: {
         const buf = s.allocator.alloc(u8, total) catch break :blk @as([]const u8, "");
         var tp: usize = 0;
         @memcpy(buf[tp..][0..export_prefix.len], export_prefix); tp += export_prefix.len;
-        @memcpy(buf[tp..][0..declare_kw.len], declare_kw); tp += declare_kw.len;
         @memcpy(buf[tp..][0..func_name.len], func_name); tp += func_name.len;
         @memcpy(buf[tp..][0..generics.len], generics); tp += generics.len;
         @memcpy(buf[tp..][0..dts_params.len], dts_params); tp += dts_params.len;

package/test/zig-dtsx.test.ts

@@ -963,7 +963,9 @@ export function useFoo(f: Foo): void {}
 
     test('default export function', () => {
       const result = dts(`export default function main(): void {}`)
-      expect(result).toContain('declare function main(): void')
+      // `export default function` keeps the `default` keyword in DTS —
+      // `export declare function` would lose the default-export signal.
+      expect(result).toContain('export default function main(): void')
     })
 
     test('default export class', () => {
@@ -977,7 +979,7 @@ export const version = '1.0.0'
 export default function init(): void {}
 `)
       expect(result).toContain('declare const version')
-      expect(result).toContain('declare function init')
+      expect(result).toContain('export default function init')
     })
   })
 
@@ -1173,6 +1175,29 @@ export function merge<T extends Record<string, unknown>, U extends Record<string
       expect(result).toContain('declare function parse')
     })
 
+    test('issue 3095 — destructured param with JSDoc apostrophe', () => {
+      // JSDoc prose containing an apostrophe (e.g. "error's") used to put the
+      // param scanner into an inescapable string-literal mode, producing
+      // `,: unknown):` that TypeScript rejects with TS1138.
+      const result = dts(`export class CLI {
+  async parse(
+    argv: string[] = [],
+    {
+      /** Whether to run the action for matched command */
+      run = true,
+      /**
+       * Defaults to \`false\`. When set, render the error's message and exit.
+       */
+      exitOnError = false,
+    }: { run?: boolean, exitOnError?: boolean } = {},
+  ): Promise<void> {}
+}`)
+      expect(result).not.toMatch(/,\s*:\s*unknown\)/)
+      expect(result).not.toContain('= {}')
+      expect(result).toContain('run?: boolean')
+      expect(result).toContain('exitOnError?: boolean')
+    })
+
     test('export declare (already declared)', () => {
       const result = dts(`export declare const VERSION: string`)
       expect(result).toContain('export declare const VERSION: string')