pi-ast-sgrep 2.0.0 → 2.0.1

package/dist/present.d.ts

@@ -45,6 +45,9 @@ export declare function formatSearchResult(response: EnvelopeLike, meta: {
 }, theme?: PresentTheme): string;
 export declare function formatStatusResult(response: EnvelopeLike, theme?: PresentTheme): string;
 export declare function formatIndexResult(command: string, response: EnvelopeLike, theme?: PresentTheme): string;
+/** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
+export declare function visibleWidth(text: string): number;
+export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string): string;
 export declare function formatCodemodeResult(value: unknown, meta?: {
     stats?: {
         calls: number;
@@ -62,6 +65,6 @@ export declare class AsgrepText {
     constructor(text?: string);
     setText(text: string): void;
     invalidate(): void;
-    render(_width: number): string[];
+    render(width: number): string[];
 }
 export declare function presentText(formatted: string, last: unknown): AsgrepText;

package/dist/present.js

@@ -84,6 +84,97 @@ export function formatIndexResult(command, response, theme) {
     const tail = count === undefined ? "done" : `${count} file${count === 1 ? "" : "s"}`;
     return header(theme, command, [tail]);
 }
+function ansiLengthAt(text, index) {
+    if (text.charCodeAt(index) !== 0x1b)
+        return 0;
+    const next = text[index + 1];
+    if (next === "[") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            const code = text.charCodeAt(cursor);
+            if (code >= 0x40 && code <= 0x7e)
+                return cursor - index + 1;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    if (next === "]") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            if (text.charCodeAt(cursor) === 0x07)
+                return cursor - index + 1;
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    if (next === "P" || next === "X" || next === "^" || next === "_") {
+        let cursor = index + 2;
+        while (cursor < text.length) {
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+            cursor += 1;
+        }
+        return text.length - index;
+    }
+    return Math.min(2, text.length - index);
+}
+function cellWidthAt(text, index) {
+    const code = text.charCodeAt(index);
+    if (code === 0x09)
+        return { width: 3, length: 1 };
+    if (code >= 0xd800 && code <= 0xdbff)
+        return { width: 2, length: 2 };
+    if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+        return { width: 0, length: 1 };
+    if (code <= 0x7e)
+        return { width: 1, length: 1 };
+    return { width: 2, length: 1 };
+}
+/** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
+export function visibleWidth(text) {
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        width += cell.width;
+        index += cell.length;
+    }
+    return width;
+}
+export function truncateToWidth(text, maxWidth, ellipsis = "...") {
+    const limit = Math.max(0, maxWidth);
+    if (limit <= 0)
+        return "";
+    if (visibleWidth(text) <= limit)
+        return text;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (ellipsisWidth >= limit)
+        return ellipsis.slice(0, limit);
+    const budget = limit - ellipsisWidth;
+    let kept = "";
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            kept += text.slice(index, index + ansi);
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        if (width + cell.width > budget)
+            break;
+        kept += text.slice(index, index + cell.length);
+        width += cell.width;
+        index += cell.length;
+    }
+    return `${kept}${ellipsis}`;
+}
 function compactValue(value) {
     if (value === null || value === undefined)
         return String(value);
@@ -149,8 +240,11 @@ export class AsgrepText {
         this.#text = text;
     }
     invalidate() { }
-    render(_width) {
-        return this.#text.length === 0 ? [""] : this.#text.split("\n");
+    render(width) {
+        const maxWidth = Math.max(1, width);
+        if (this.#text.length === 0)
+            return [""];
+        return this.#text.split("\n").map((line) => truncateToWidth(line, maxWidth));
     }
 }
 export function presentText(formatted, last) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ast-sgrep",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Native Code Mode, structural, graph, and semantic code search for Pi",
   "type": "module",
   "license": "MIT",