@fresh-editor/fresh-editor 0.1.4

package/plugins/color_highlighter.ts

@@ -0,0 +1,302 @@
+// TypeScript Color Highlighter Plugin
+// Highlights color codes in source code with a colored swatch
+// Supports: #RGB, #RRGGBB, rgb(), rgba(), hsl(), hsla(), Color::Rgb()
+
+interface ColorHighlighterConfig {
+  enabled: boolean;
+}
+
+// Plugin configuration
+const config: ColorHighlighterConfig = {
+  enabled: false, // Start disabled, use Enable or Toggle to activate
+};
+
+// Track which buffers need their virtual texts refreshed (content changed)
+const dirtyBuffers = new Set<number>();
+
+// Color block character for display
+const COLOR_BLOCK = "█";
+
+// Parse a hex color string to RGB
+function parseHexColor(hex: string): [number, number, number] | null {
+  // Remove # prefix
+  hex = hex.replace(/^#/, "");
+
+  let r: number, g: number, b: number;
+
+  if (hex.length === 3) {
+    // #RGB format
+    r = parseInt(hex[0] + hex[0], 16);
+    g = parseInt(hex[1] + hex[1], 16);
+    b = parseInt(hex[2] + hex[2], 16);
+  } else if (hex.length === 6 || hex.length === 8) {
+    // #RRGGBB or #RRGGBBAA format
+    r = parseInt(hex.substring(0, 2), 16);
+    g = parseInt(hex.substring(2, 4), 16);
+    b = parseInt(hex.substring(4, 6), 16);
+  } else {
+    return null;
+  }
+
+  if (isNaN(r) || isNaN(g) || isNaN(b)) {
+    return null;
+  }
+
+  return [r, g, b];
+}
+
+// Parse rgb() or rgba() color to RGB
+function parseRgbColor(match: string): [number, number, number] | null {
+  const rgbMatch = match.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+  if (!rgbMatch) {
+    return null;
+  }
+
+  const r = parseInt(rgbMatch[1], 10);
+  const g = parseInt(rgbMatch[2], 10);
+  const b = parseInt(rgbMatch[3], 10);
+
+  if (r > 255 || g > 255 || b > 255) {
+    return null;
+  }
+
+  return [r, g, b];
+}
+
+// Convert HSL to RGB
+function hslToRgb(h: number, s: number, l: number): [number, number, number] {
+  // Normalize h to 0-360, s and l to 0-1
+  h = h % 360;
+  if (h < 0) h += 360;
+  s = Math.max(0, Math.min(1, s / 100));
+  l = Math.max(0, Math.min(1, l / 100));
+
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = l - c / 2;
+
+  let r = 0, g = 0, b = 0;
+
+  if (h >= 0 && h < 60) {
+    r = c; g = x; b = 0;
+  } else if (h >= 60 && h < 120) {
+    r = x; g = c; b = 0;
+  } else if (h >= 120 && h < 180) {
+    r = 0; g = c; b = x;
+  } else if (h >= 180 && h < 240) {
+    r = 0; g = x; b = c;
+  } else if (h >= 240 && h < 300) {
+    r = x; g = 0; b = c;
+  } else {
+    r = c; g = 0; b = x;
+  }
+
+  return [
+    Math.round((r + m) * 255),
+    Math.round((g + m) * 255),
+    Math.round((b + m) * 255),
+  ];
+}
+
+// Parse hsl() or hsla() color to RGB
+function parseHslColor(match: string): [number, number, number] | null {
+  const hslMatch = match.match(/hsla?\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)%\s*,\s*(\d+(?:\.\d+)?)%/);
+  if (!hslMatch) {
+    return null;
+  }
+
+  const h = parseFloat(hslMatch[1]);
+  const s = parseFloat(hslMatch[2]);
+  const l = parseFloat(hslMatch[3]);
+
+  return hslToRgb(h, s, l);
+}
+
+// Parse Rust Color::Rgb(r, g, b) to RGB
+function parseRustRgbColor(match: string): [number, number, number] | null {
+  const rustMatch = match.match(/Color::Rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+  if (!rustMatch) {
+    return null;
+  }
+
+  const r = parseInt(rustMatch[1], 10);
+  const g = parseInt(rustMatch[2], 10);
+  const b = parseInt(rustMatch[3], 10);
+
+  if (r > 255 || g > 255 || b > 255) {
+    return null;
+  }
+
+  return [r, g, b];
+}
+
+// Color patterns to match
+const colorPatterns = [
+  {
+    // Hex colors: #RGB, #RRGGBB, #RRGGBBAA
+    regex: /#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})\b/g,
+    parse: parseHexColor,
+  },
+  {
+    // CSS rgb() and rgba()
+    regex: /rgba?\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*[\d.]+\s*)?\)/g,
+    parse: parseRgbColor,
+  },
+  {
+    // CSS hsl() and hsla()
+    regex: /hsla?\s*\(\s*-?\d+(?:\.\d+)?\s*,\s*\d+(?:\.\d+)?%\s*,\s*\d+(?:\.\d+)?%\s*(?:,\s*[\d.]+\s*)?\)/g,
+    parse: parseHslColor,
+  },
+  {
+    // Rust Color::Rgb(r, g, b)
+    regex: /Color::Rgb\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)/g,
+    parse: parseRustRgbColor,
+  },
+];
+
+// Process a single line for color highlighting
+function highlightLine(
+  bufferId: number,
+  lineNumber: number,
+  byteStart: number,
+  content: string
+): void {
+  // Search for color patterns
+  for (const pattern of colorPatterns) {
+    // Reset regex lastIndex
+    pattern.regex.lastIndex = 0;
+
+    let match;
+    while ((match = pattern.regex.exec(content)) !== null) {
+      const matchText = match[0];
+      const pos = match.index;
+      const color = pattern.parse(matchText);
+
+      if (color) {
+        const absolutePos = byteStart + pos;
+        const virtualTextId = `color-${bufferId}-${lineNumber}-${pos}`;
+
+        // Add virtual text with color swatch before the color code
+        editor.addVirtualText(
+          bufferId,
+          virtualTextId,
+          absolutePos,
+          COLOR_BLOCK + " ",
+          color[0],
+          color[1],
+          color[2],
+          true // before the character
+        );
+      }
+    }
+  }
+}
+
+// Clear color highlights for a buffer
+function clearHighlights(bufferId: number): void {
+  editor.removeVirtualTextsByPrefix(bufferId, "color-");
+}
+
+// Handle render-start events (only clear virtual texts if buffer content changed)
+globalThis.onColorRenderStart = function(data: { buffer_id: number }): void {
+  if (!config.enabled) return;
+
+  // Only clear and recreate virtual texts if the buffer content changed
+  if (dirtyBuffers.has(data.buffer_id)) {
+    clearHighlights(data.buffer_id);
+    dirtyBuffers.delete(data.buffer_id);
+  }
+};
+
+// Handle lines_changed events (batched for efficiency)
+globalThis.onColorLinesChanged = function(data: {
+  buffer_id: number;
+  lines: Array<{
+    line_number: number;
+    byte_start: number;
+    byte_end: number;
+    content: string;
+  }>;
+}): void {
+  if (!config.enabled) return;
+
+  // Process all changed lines
+  for (const line of data.lines) {
+    highlightLine(data.buffer_id, line.line_number, line.byte_start, line.content);
+  }
+};
+
+// Handle buffer content changes - mark buffer as needing virtual text refresh
+globalThis.onColorAfterInsert = function(data: { buffer_id: number }): void {
+  dirtyBuffers.add(data.buffer_id);
+};
+
+globalThis.onColorAfterDelete = function(data: { buffer_id: number }): void {
+  dirtyBuffers.add(data.buffer_id);
+};
+
+// Handle buffer close events
+globalThis.onColorBufferClosed = function(data: { buffer_id: number }): void {
+  dirtyBuffers.delete(data.buffer_id);
+};
+
+// Register hooks
+editor.on("render_start", "onColorRenderStart");
+editor.on("lines_changed", "onColorLinesChanged");
+editor.on("after-insert", "onColorAfterInsert");
+editor.on("after-delete", "onColorAfterDelete");
+editor.on("buffer_closed", "onColorBufferClosed");
+
+// Plugin commands
+globalThis.colorHighlighterEnable = function(): void {
+  config.enabled = true;
+  // Refresh lines so next render processes all visible lines
+  const bufferId = editor.getActiveBufferId();
+  editor.refreshLines(bufferId);
+  editor.setStatus("Color Highlighter: Enabled");
+};
+
+globalThis.colorHighlighterDisable = function(): void {
+  config.enabled = false;
+  const bufferId = editor.getActiveBufferId();
+  clearHighlights(bufferId);
+  editor.setStatus("Color Highlighter: Disabled");
+};
+
+globalThis.colorHighlighterToggle = function(): void {
+  config.enabled = !config.enabled;
+  const bufferId = editor.getActiveBufferId();
+  if (config.enabled) {
+    // Refresh lines so next render processes all visible lines
+    editor.refreshLines(bufferId);
+  } else {
+    clearHighlights(bufferId);
+  }
+  editor.setStatus(`Color Highlighter: ${config.enabled ? "Enabled" : "Disabled"}`);
+};
+
+// Register commands
+editor.registerCommand(
+  "Color Highlighter: Enable",
+  "Enable color code highlighting with swatches",
+  "colorHighlighterEnable",
+  "normal"
+);
+
+editor.registerCommand(
+  "Color Highlighter: Disable",
+  "Disable color code highlighting",
+  "colorHighlighterDisable",
+  "normal"
+);
+
+editor.registerCommand(
+  "Color Highlighter: Toggle",
+  "Toggle color code highlighting",
+  "colorHighlighterToggle",
+  "normal"
+);
+
+// Initialization
+editor.setStatus("Color Highlighter plugin loaded");
+editor.debug("Color Highlighter initialized - supports hex, rgb, hsl, and Rust Color::Rgb");

package/plugins/diagnostics_panel.ts

@@ -0,0 +1,308 @@
+/// <reference path="../types/fresh.d.ts" />
+
+/**
+ * Diagnostics Panel Plugin (TypeScript)
+ *
+ * Full diagnostics panel implementation with virtual buffer split view.
+ * Provides LSP-like diagnostics display with severity icons and navigation.
+ */
+
+// Panel state
+let panelOpen = false;
+let diagnosticsBufferId: number | null = null;
+let sourceSplitId: number | null = null; // The split where source code is displayed
+let currentDiagnostics: DiagnosticItem[] = [];
+let selectedIndex = 0;
+
+// Diagnostic item structure
+interface DiagnosticItem {
+  severity: "error" | "warning" | "info" | "hint";
+  message: string;
+  file: string;
+  line: number;
+  column: number;
+}
+
+// Severity icons
+const severityIcons: Record<string, string> = {
+  error: "[E]",
+  warning: "[W]",
+  info: "[I]",
+  hint: "[H]",
+};
+
+// Define the diagnostics mode with keybindings
+editor.defineMode(
+  "diagnostics-list",
+  null, // no parent mode
+  [
+    ["Return", "diagnostics_goto"],
+    ["n", "diagnostics_next"],
+    ["p", "diagnostics_prev"],
+    ["j", "diagnostics_next"],
+    ["k", "diagnostics_prev"],
+    ["q", "diagnostics_close"],
+    ["Escape", "diagnostics_close"],
+  ],
+  true // read-only
+);
+
+// Format a diagnostic for display
+function formatDiagnostic(item: DiagnosticItem, index: number): string {
+  const icon = severityIcons[item.severity] || "[?]";
+  const marker = index === selectedIndex ? ">" : " ";
+  return `${marker} ${icon} ${item.file}:${item.line}:${item.column} - ${item.message}\n`;
+}
+
+// Build entries for the virtual buffer
+function buildPanelEntries(): TextPropertyEntry[] {
+  const entries: TextPropertyEntry[] = [];
+
+  // Header
+  entries.push({
+    text: "═══ LSP Diagnostics ═══\n",
+    properties: { type: "header" },
+  });
+
+  if (currentDiagnostics.length === 0) {
+    entries.push({
+      text: "  No diagnostics available\n",
+      properties: { type: "empty" },
+    });
+  } else {
+    // Add each diagnostic
+    for (let i = 0; i < currentDiagnostics.length; i++) {
+      const diag = currentDiagnostics[i];
+      entries.push({
+        text: formatDiagnostic(diag, i),
+        properties: {
+          type: "diagnostic",
+          index: i,
+          severity: diag.severity,
+          location: {
+            file: diag.file,
+            line: diag.line,
+            column: diag.column,
+          },
+        },
+      });
+    }
+  }
+
+  // Footer with summary
+  const errorCount = currentDiagnostics.filter((d) => d.severity === "error").length;
+  const warningCount = currentDiagnostics.filter((d) => d.severity === "warning").length;
+  entries.push({
+    text: `───────────────────────\n`,
+    properties: { type: "separator" },
+  });
+  entries.push({
+    text: `Total: ${errorCount} error(s), ${warningCount} warning(s)\n`,
+    properties: { type: "summary" },
+  });
+
+  return entries;
+}
+
+// Update the panel content
+function updatePanelContent(): void {
+  if (diagnosticsBufferId !== null) {
+    const entries = buildPanelEntries();
+    editor.setVirtualBufferContent(diagnosticsBufferId, entries);
+  }
+}
+
+// Generate sample diagnostics for the current file
+function generateSampleDiagnostics(): DiagnosticItem[] {
+  const bufferId = editor.getActiveBufferId();
+  const filePath = editor.getBufferPath(bufferId);
+
+  // Return sample diagnostics
+  return [
+    {
+      severity: "error",
+      message: "unused import",
+      file: filePath || "unknown.rs",
+      line: 1,
+      column: 1,
+    },
+    {
+      severity: "warning",
+      message: "variable never used",
+      file: filePath || "unknown.rs",
+      line: 2,
+      column: 5,
+    },
+    {
+      severity: "info",
+      message: "consider using pattern matching",
+      file: filePath || "unknown.rs",
+      line: 3,
+      column: 10,
+    },
+  ];
+}
+
+// Show diagnostics panel
+globalThis.show_diagnostics_panel = async function (): Promise<void> {
+  if (panelOpen) {
+    editor.setStatus("Diagnostics panel already open");
+    updatePanelContent();
+    return;
+  }
+
+  // Save the current split ID before creating the diagnostics split
+  // This is where we'll open files when jumping to diagnostics
+  sourceSplitId = editor.getActiveSplitId();
+
+  // Generate sample diagnostics
+  currentDiagnostics = generateSampleDiagnostics();
+  selectedIndex = 0;
+
+  // Build panel entries
+  const entries = buildPanelEntries();
+
+  // Create virtual buffer in horizontal split
+  try {
+    diagnosticsBufferId = await editor.createVirtualBufferInSplit({
+      name: "*Diagnostics*",
+      mode: "diagnostics-list",
+      read_only: true,
+      entries: entries,
+      ratio: 0.7, // Original pane takes 70%, diagnostics takes 30%
+      panel_id: "diagnostics-panel",
+      show_line_numbers: false,
+      show_cursors: true,
+    });
+
+    panelOpen = true;
+    editor.setStatus(`Diagnostics: ${currentDiagnostics.length} item(s) - Press RET to jump, n/p to navigate, q to close`);
+    editor.debug(`Diagnostics panel opened with buffer ID ${diagnosticsBufferId}`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    editor.setStatus("Failed to open diagnostics panel");
+    editor.debug(`ERROR: createVirtualBufferInSplit failed: ${errorMessage}`);
+  }
+};
+
+// Hide diagnostics panel
+globalThis.hide_diagnostics_panel = function (): void {
+  if (!panelOpen) {
+    editor.setStatus("Diagnostics panel not open");
+    return;
+  }
+
+  panelOpen = false;
+  diagnosticsBufferId = null;
+  sourceSplitId = null;
+  selectedIndex = 0;
+  currentDiagnostics = [];
+  editor.setStatus("Diagnostics panel closed");
+};
+
+// Toggle diagnostics panel
+globalThis.toggle_diagnostics_panel = function (): void {
+  if (panelOpen) {
+    globalThis.hide_diagnostics_panel();
+  } else {
+    globalThis.show_diagnostics_panel();
+  }
+};
+
+// Show diagnostic count
+globalThis.show_diagnostics_count = function (): void {
+  const errorCount = currentDiagnostics.filter((d) => d.severity === "error").length;
+  const warningCount = currentDiagnostics.filter((d) => d.severity === "warning").length;
+  editor.setStatus(`Diagnostics: ${errorCount} errors, ${warningCount} warnings`);
+};
+
+// Navigation: go to selected diagnostic
+globalThis.diagnostics_goto = function (): void {
+  if (currentDiagnostics.length === 0) {
+    editor.setStatus("No diagnostics to jump to");
+    return;
+  }
+
+  if (sourceSplitId === null) {
+    editor.setStatus("Source split not available");
+    return;
+  }
+
+  const bufferId = editor.getActiveBufferId();
+  const props = editor.getTextPropertiesAtCursor(bufferId);
+
+  if (props.length > 0) {
+    const location = props[0].location as { file: string; line: number; column: number } | undefined;
+    if (location) {
+      // Open file in the source split, not the diagnostics split
+      editor.openFileInSplit(sourceSplitId, location.file, location.line, location.column || 0);
+      editor.setStatus(`Jumped to ${location.file}:${location.line}`);
+    } else {
+      editor.setStatus("No location info for this diagnostic");
+    }
+  } else {
+    // Fallback: use selectedIndex
+    const diag = currentDiagnostics[selectedIndex];
+    if (diag) {
+      // Open file in the source split, not the diagnostics split
+      editor.openFileInSplit(sourceSplitId, diag.file, diag.line, diag.column);
+      editor.setStatus(`Jumped to ${diag.file}:${diag.line}`);
+    }
+  }
+};
+
+// Navigation: next diagnostic
+globalThis.diagnostics_next = function (): void {
+  if (currentDiagnostics.length === 0) return;
+
+  selectedIndex = (selectedIndex + 1) % currentDiagnostics.length;
+  updatePanelContent();
+  editor.setStatus(`Diagnostic ${selectedIndex + 1}/${currentDiagnostics.length}`);
+};
+
+// Navigation: previous diagnostic
+globalThis.diagnostics_prev = function (): void {
+  if (currentDiagnostics.length === 0) return;
+
+  selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : currentDiagnostics.length - 1;
+  updatePanelContent();
+  editor.setStatus(`Diagnostic ${selectedIndex + 1}/${currentDiagnostics.length}`);
+};
+
+// Close the diagnostics panel
+globalThis.diagnostics_close = function (): void {
+  globalThis.hide_diagnostics_panel();
+};
+
+// Register commands
+editor.registerCommand(
+  "Show Diagnostics Panel",
+  "Open the diagnostics panel",
+  "show_diagnostics_panel",
+  "normal"
+);
+
+editor.registerCommand(
+  "Hide Diagnostics Panel",
+  "Close the diagnostics panel",
+  "hide_diagnostics_panel",
+  "normal"
+);
+
+editor.registerCommand(
+  "Toggle Diagnostics Panel",
+  "Toggle diagnostics panel visibility",
+  "toggle_diagnostics_panel",
+  "normal"
+);
+
+editor.registerCommand(
+  "Diagnostics Count",
+  "Show count of current diagnostics",
+  "show_diagnostics_count",
+  "normal"
+);
+
+// Plugin initialization
+editor.setStatus("Diagnostics Panel plugin loaded (TypeScript)");
+editor.debug("Diagnostics Panel plugin initialized - 4 commands registered");