shortcutxl 0.2.19 → 0.2.21

package/dist/tui/tui/components/truncated-text.js

@@ -1,51 +1,51 @@
-import { truncateToWidth, visibleWidth } from "../utils.js";
+import { truncateToWidth, visibleWidth } from '../utils.js';
 /**
  * Text component that truncates to fit viewport width
  */
 export class TruncatedText {
-    text;
-    paddingX;
-    paddingY;
-    constructor(text, paddingX = 0, paddingY = 0) {
-        this.text = text;
-        this.paddingX = paddingX;
-        this.paddingY = paddingY;
+  text;
+  paddingX;
+  paddingY;
+  constructor(text, paddingX = 0, paddingY = 0) {
+    this.text = text;
+    this.paddingX = paddingX;
+    this.paddingY = paddingY;
+  }
+  invalidate() {
+    // No cached state to invalidate currently
+  }
+  render(width) {
+    const result = [];
+    // Empty line padded to width
+    const emptyLine = ' '.repeat(width);
+    // Add vertical padding above
+    for (let i = 0; i < this.paddingY; i++) {
+      result.push(emptyLine);
     }
-    invalidate() {
-        // No cached state to invalidate currently
+    // Calculate available width after horizontal padding
+    const availableWidth = Math.max(1, width - this.paddingX * 2);
+    // Take only the first line (stop at newline)
+    let singleLineText = this.text;
+    const newlineIndex = this.text.indexOf('\n');
+    if (newlineIndex !== -1) {
+      singleLineText = this.text.substring(0, newlineIndex);
     }
-    render(width) {
-        const result = [];
-        // Empty line padded to width
-        const emptyLine = " ".repeat(width);
-        // Add vertical padding above
-        for (let i = 0; i < this.paddingY; i++) {
-            result.push(emptyLine);
-        }
-        // Calculate available width after horizontal padding
-        const availableWidth = Math.max(1, width - this.paddingX * 2);
-        // Take only the first line (stop at newline)
-        let singleLineText = this.text;
-        const newlineIndex = this.text.indexOf("\n");
-        if (newlineIndex !== -1) {
-            singleLineText = this.text.substring(0, newlineIndex);
-        }
-        // Truncate text if needed (accounting for ANSI codes)
-        const displayText = truncateToWidth(singleLineText, availableWidth);
-        // Add horizontal padding
-        const leftPadding = " ".repeat(this.paddingX);
-        const rightPadding = " ".repeat(this.paddingX);
-        const lineWithPadding = leftPadding + displayText + rightPadding;
-        // Pad line to exactly width characters
-        const lineVisibleWidth = visibleWidth(lineWithPadding);
-        const paddingNeeded = Math.max(0, width - lineVisibleWidth);
-        const finalLine = lineWithPadding + " ".repeat(paddingNeeded);
-        result.push(finalLine);
-        // Add vertical padding below
-        for (let i = 0; i < this.paddingY; i++) {
-            result.push(emptyLine);
-        }
-        return result;
+    // Truncate text if needed (accounting for ANSI codes)
+    const displayText = truncateToWidth(singleLineText, availableWidth);
+    // Add horizontal padding
+    const leftPadding = ' '.repeat(this.paddingX);
+    const rightPadding = ' '.repeat(this.paddingX);
+    const lineWithPadding = leftPadding + displayText + rightPadding;
+    // Pad line to exactly width characters
+    const lineVisibleWidth = visibleWidth(lineWithPadding);
+    const paddingNeeded = Math.max(0, width - lineVisibleWidth);
+    const finalLine = lineWithPadding + ' '.repeat(paddingNeeded);
+    result.push(finalLine);
+    // Add vertical padding below
+    for (let i = 0; i < this.paddingY; i++) {
+      result.push(emptyLine);
     }
+    return result;
+  }
 }
-//# sourceMappingURL=truncated-text.js.map
+//# sourceMappingURL=truncated-text.js.map

package/dist/tui/tui/editor-component.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=editor-component.js.map
+//# sourceMappingURL=editor-component.js.map

package/dist/tui/tui/fuzzy.js

@@ -4,104 +4,102 @@
  * Lower score = better match.
  */
 export function fuzzyMatch(query, text) {
-    const queryLower = query.toLowerCase();
-    const textLower = text.toLowerCase();
-    const matchQuery = (normalizedQuery) => {
-        if (normalizedQuery.length === 0) {
-            return { matches: true, score: 0 };
-        }
-        if (normalizedQuery.length > textLower.length) {
-            return { matches: false, score: 0 };
-        }
-        let queryIndex = 0;
-        let score = 0;
-        let lastMatchIndex = -1;
-        let consecutiveMatches = 0;
-        for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) {
-            if (textLower[i] === normalizedQuery[queryIndex]) {
-                const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]);
-                // Reward consecutive matches
-                if (lastMatchIndex === i - 1) {
-                    consecutiveMatches++;
-                    score -= consecutiveMatches * 5;
-                }
-                else {
-                    consecutiveMatches = 0;
-                    // Penalize gaps
-                    if (lastMatchIndex >= 0) {
-                        score += (i - lastMatchIndex - 1) * 2;
-                    }
-                }
-                // Reward word boundary matches
-                if (isWordBoundary) {
-                    score -= 10;
-                }
-                // Slight penalty for later matches
-                score += i * 0.1;
-                lastMatchIndex = i;
-                queryIndex++;
-            }
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  const matchQuery = (normalizedQuery) => {
+    if (normalizedQuery.length === 0) {
+      return { matches: true, score: 0 };
+    }
+    if (normalizedQuery.length > textLower.length) {
+      return { matches: false, score: 0 };
+    }
+    let queryIndex = 0;
+    let score = 0;
+    let lastMatchIndex = -1;
+    let consecutiveMatches = 0;
+    for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) {
+      if (textLower[i] === normalizedQuery[queryIndex]) {
+        const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]);
+        // Reward consecutive matches
+        if (lastMatchIndex === i - 1) {
+          consecutiveMatches++;
+          score -= consecutiveMatches * 5;
+        } else {
+          consecutiveMatches = 0;
+          // Penalize gaps
+          if (lastMatchIndex >= 0) {
+            score += (i - lastMatchIndex - 1) * 2;
+          }
         }
-        if (queryIndex < normalizedQuery.length) {
-            return { matches: false, score: 0 };
+        // Reward word boundary matches
+        if (isWordBoundary) {
+          score -= 10;
         }
-        return { matches: true, score };
-    };
-    const primaryMatch = matchQuery(queryLower);
-    if (primaryMatch.matches) {
-        return primaryMatch;
+        // Slight penalty for later matches
+        score += i * 0.1;
+        lastMatchIndex = i;
+        queryIndex++;
+      }
     }
-    const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
-    const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
-    const swappedQuery = alphaNumericMatch
-        ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}`
-        : numericAlphaMatch
-            ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}`
-            : "";
-    if (!swappedQuery) {
-        return primaryMatch;
+    if (queryIndex < normalizedQuery.length) {
+      return { matches: false, score: 0 };
     }
-    const swappedMatch = matchQuery(swappedQuery);
-    if (!swappedMatch.matches) {
-        return primaryMatch;
-    }
-    return { matches: true, score: swappedMatch.score + 5 };
+    return { matches: true, score };
+  };
+  const primaryMatch = matchQuery(queryLower);
+  if (primaryMatch.matches) {
+    return primaryMatch;
+  }
+  const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+  const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+  const swappedQuery = alphaNumericMatch
+    ? `${alphaNumericMatch.groups?.digits ?? ''}${alphaNumericMatch.groups?.letters ?? ''}`
+    : numericAlphaMatch
+      ? `${numericAlphaMatch.groups?.letters ?? ''}${numericAlphaMatch.groups?.digits ?? ''}`
+      : '';
+  if (!swappedQuery) {
+    return primaryMatch;
+  }
+  const swappedMatch = matchQuery(swappedQuery);
+  if (!swappedMatch.matches) {
+    return primaryMatch;
+  }
+  return { matches: true, score: swappedMatch.score + 5 };
 }
 /**
  * Filter and sort items by fuzzy match quality (best matches first).
  * Supports space-separated tokens: all tokens must match.
  */
 export function fuzzyFilter(items, query, getText) {
-    if (!query.trim()) {
-        return items;
-    }
-    const tokens = query
-        .trim()
-        .split(/\s+/)
-        .filter((t) => t.length > 0);
-    if (tokens.length === 0) {
-        return items;
+  if (!query.trim()) {
+    return items;
+  }
+  const tokens = query
+    .trim()
+    .split(/\s+/)
+    .filter((t) => t.length > 0);
+  if (tokens.length === 0) {
+    return items;
+  }
+  const results = [];
+  for (const item of items) {
+    const text = getText(item);
+    let totalScore = 0;
+    let allMatch = true;
+    for (const token of tokens) {
+      const match = fuzzyMatch(token, text);
+      if (match.matches) {
+        totalScore += match.score;
+      } else {
+        allMatch = false;
+        break;
+      }
     }
-    const results = [];
-    for (const item of items) {
-        const text = getText(item);
-        let totalScore = 0;
-        let allMatch = true;
-        for (const token of tokens) {
-            const match = fuzzyMatch(token, text);
-            if (match.matches) {
-                totalScore += match.score;
-            }
-            else {
-                allMatch = false;
-                break;
-            }
-        }
-        if (allMatch) {
-            results.push({ item, totalScore });
-        }
+    if (allMatch) {
+      results.push({ item, totalScore });
     }
-    results.sort((a, b) => a.totalScore - b.totalScore);
-    return results.map((r) => r.item);
+  }
+  results.sort((a, b) => a.totalScore - b.totalScore);
+  return results.map((r) => r.item);
 }
-//# sourceMappingURL=fuzzy.js.map
+//# sourceMappingURL=fuzzy.js.map

package/dist/tui/tui/get-east-asian-width/index.js

@@ -1,32 +1,28 @@
 // Vendored from get-east-asian-width@1.3.0
-import {getCategory, isAmbiguous, isFullWidth, isWide} from './lookup.js';
+import { getCategory, isAmbiguous, isFullWidth, isWide } from './lookup.js';
 
 function validate(codePoint) {
-	if (!Number.isSafeInteger(codePoint)) {
-		throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
-	}
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
 }
 
 export function eastAsianWidthType(codePoint) {
-	validate(codePoint);
+  validate(codePoint);
 
-	return getCategory(codePoint);
+  return getCategory(codePoint);
 }
 
-export function eastAsianWidth(codePoint, {ambiguousAsWide = false} = {}) {
-	validate(codePoint);
+export function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
 
-	if (
-		isFullWidth(codePoint)
-		|| isWide(codePoint)
-		|| (ambiguousAsWide && isAmbiguous(codePoint))
-	) {
-		return 2;
-	}
+  if (isFullWidth(codePoint) || isWide(codePoint) || (ambiguousAsWide && isAmbiguous(codePoint))) {
+    return 2;
+  }
 
-	return 1;
+  return 1;
 }
 
 // For Prettier. This doesn't count "ambiguous" characters or check for valid input.
 // https://github.com/sindresorhus/get-east-asian-width/pull/6
-export const _isNarrowWidth = codePoint => !(isFullWidth(codePoint) || isWide(codePoint));
+export const _isNarrowWidth = (codePoint) => !(isFullWidth(codePoint) || isWide(codePoint));