AstralRinth/apps/frontend/src/store/console.ts

import { createGlobalState } from "@vueuse/core";
import { type Ref, shallowRef } from "vue";

/**
 * Maximum number of console output lines to store
 * @type {number}
 */
const maxLines = 10000;
const batchTimeout = 300; // ms
const initialBatchSize = 256;

/**
 * Provides a global console output state management system
 * Allows adding, storing, and clearing console output with a maximum line limit
 *
 * @returns {Object} Console state management methods and reactive state
 * @property {Ref<string[]>} consoleOutput - Reactive array of console output lines
 * @property {function(string): void} addConsoleOutput - Method to add a new console output line
 * @property {function(): void} clear - Method to clear all console output
 */
export const useModrinthServersConsole = createGlobalState(() => {
  /**
   * Reactive array storing console output lines
   * @type {Ref<string[]>}
   */
  const output: Ref<string[]> = shallowRef<string[]>([]);
  const searchQuery: Ref<string> = shallowRef("");
  const filteredOutput: Ref<string[]> = shallowRef([]);
  let searchRegex: RegExp | null = null;

  let lineBuffer: string[] = [];
  let batchTimer: NodeJS.Timeout | null = null;
  let isProcessingInitialBatch = false;

  let refilterTimer: NodeJS.Timeout | null = null;
  const refilterTimeout = 100; // ms

  const updateFilter = () => {
    if (!searchQuery.value) {
      filteredOutput.value = [];
      return;
    }

    if (!searchRegex) {
      searchRegex = new RegExp(searchQuery.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
    }

    filteredOutput.value = output.value.filter((line) => searchRegex?.test(line) ?? false);
  };

  const scheduleRefilter = () => {
    if (refilterTimer) clearTimeout(refilterTimer);
    refilterTimer = setTimeout(updateFilter, refilterTimeout);
  };

  const flushBuffer = () => {
    if (lineBuffer.length === 0) return;

    const processedLines = lineBuffer.flatMap((line) => line.split("\n").filter(Boolean));

    if (isProcessingInitialBatch && processedLines.length >= initialBatchSize) {
      isProcessingInitialBatch = false;
      output.value = processedLines.slice(-maxLines);
    } else {
      const newOutput = [...output.value, ...processedLines];
      output.value = newOutput.slice(-maxLines);
    }

    lineBuffer = [];
    batchTimer = null;

    if (searchQuery.value) {
      scheduleRefilter();
    }
  };

  /**
   * Adds a new output line to the console output
   * Automatically removes the oldest line if max output is exceeded
   *
   * @param {string} line - The console output line to add
   */
  const addLine = (line: string): void => {
    lineBuffer.push(line);

    if (!batchTimer) {
      batchTimer = setTimeout(flushBuffer, batchTimeout);
    }
  };

  /**
   * Adds multiple output lines to the console output
   * Automatically removes the oldest lines if max output is exceeded
   *
   * @param {string[]} lines - The console output lines to add
   * @returns {void}
   */
  const addLines = (lines: string[]): void => {
    if (output.value.length === 0 && lines.length >= initialBatchSize) {
      isProcessingInitialBatch = true;
      lineBuffer = lines;
      flushBuffer();
      return;
    }

    lineBuffer.push(...lines);

    if (!batchTimer) {
      batchTimer = setTimeout(flushBuffer, batchTimeout);
    }
  };

  /**
   * Sets the search query and filters the output based on the query
   *
   * @param {string} query - The search query
   */
  const setSearchQuery = (query: string): void => {
    searchQuery.value = query;
    searchRegex = null;
    updateFilter();
  };

  /**
   * Clears all console output lines
   */
  const clear = (): void => {
    output.value = [];
    filteredOutput.value = [];
    searchQuery.value = "";
    lineBuffer = [];
    isProcessingInitialBatch = false;
    if (batchTimer) {
      clearTimeout(batchTimer);
      batchTimer = null;
    }
    if (refilterTimer) {
      clearTimeout(refilterTimer);
      refilterTimer = null;
    }
    searchRegex = null;
  };

  /**
   * Finds the index of a line in the main output
   *
   * @param {string} line - The line to find
   * @returns {number} The index of the line, or -1 if not found
   */
  const findLineIndex = (line: string): number => {
    return output.value.findIndex((l) => l === line);
  };

  return {
    output,
    searchQuery,
    filteredOutput,
    addLine,
    addLines,
    setSearchQuery,
    clear,
    findLineIndex,
  };
});