@lapis-notes/csv 0.0.0-stage → 0.2.0

package/dist/lib/components/csv-status-bar.svelte

@@ -0,0 +1,101 @@
+<script lang="ts">
+  import FileCodeIcon from "@lucide/svelte/icons/file-code";
+  import GridIcon from "@lucide/svelte/icons/grid-3x3";
+  import SearchIcon from "@lucide/svelte/icons/search";
+  import TableIcon from "@lucide/svelte/icons/table";
+  import { csvStatusLabel } from "../model/csv-search";
+
+  let {
+    columns,
+    rows,
+    shownRows = undefined,
+    searchOpen = false,
+    mode = "table",
+    onToggleSearch,
+    onToggleMode,
+    onShowCanvas,
+    onShowTable,
+  }: {
+    columns: number;
+    rows: number;
+    shownRows?: number;
+    searchOpen?: boolean;
+    mode?: "table" | "canvas" | "source";
+    onToggleSearch: () => void;
+    onToggleMode?: () => void;
+    onShowCanvas?: () => void;
+    onShowTable?: () => void;
+  } = $props();
+
+  const label = $derived(csvStatusLabel(columns, rows, shownRows));
+  const modeLabel = $derived(
+    mode === "source" ? "View CSV table" : "View CSV source",
+  );
+</script>
+
+<footer class="csv-status-bar" data-testid="csv-status-bar">
+  <button
+    type="button"
+    class={["csv-status-bar__icon", { "csv-status-bar__icon--pressed": searchOpen }]}
+    aria-label="Find and replace"
+    aria-pressed={searchOpen}
+    title="Find and replace"
+    onclick={(event) => {
+      event.stopPropagation();
+      onToggleSearch();
+    }}
+  >
+    <SearchIcon aria-hidden="true" />
+  </button>
+  <span class="csv-status-bar__text">{label}</span>
+  {#if onShowCanvas || onShowTable || onToggleMode}
+    <div class="csv-status-bar__modes">
+      {#if onShowCanvas}
+        <button
+          type="button"
+          class="csv-status-bar__icon"
+          aria-label="View CSV canvas"
+          title="View CSV canvas"
+          onclick={(event) => {
+            event.stopPropagation();
+            onShowCanvas();
+          }}
+        >
+          <GridIcon aria-hidden="true" />
+        </button>
+      {/if}
+      {#if onShowTable}
+        <button
+          type="button"
+          class="csv-status-bar__icon"
+          aria-label="View CSV table"
+          title="View CSV table"
+          onclick={(event) => {
+            event.stopPropagation();
+            onShowTable();
+          }}
+        >
+          <TableIcon aria-hidden="true" />
+        </button>
+      {/if}
+      {#if onToggleMode}
+        <button
+          type="button"
+          class="csv-status-bar__icon csv-status-bar__mode"
+          aria-label={modeLabel}
+          title={modeLabel}
+          onclick={(event) => {
+            event.stopPropagation();
+            onToggleMode();
+          }}
+        >
+          {#if mode === "source"}
+            <TableIcon aria-hidden="true" />
+          {:else}
+            <FileCodeIcon aria-hidden="true" />
+          {/if}
+        </button>
+      {/if}
+    </div>
+  {/if}
+</footer>

package/dist/lib/components/csv-status-bar.svelte.d.ts

@@ -0,0 +1,14 @@
+type $$ComponentProps = {
+    columns: number;
+    rows: number;
+    shownRows?: number;
+    searchOpen?: boolean;
+    mode?: "table" | "canvas" | "source";
+    onToggleSearch: () => void;
+    onToggleMode?: () => void;
+    onShowCanvas?: () => void;
+    onShowTable?: () => void;
+};
+declare const CsvStatusBar: import("svelte").Component<$$ComponentProps, {}, "">;
+type CsvStatusBar = ReturnType<typeof CsvStatusBar>;
+export default CsvStatusBar;

package/dist/lib/components/csv-table-dnd.d.ts

@@ -0,0 +1,9 @@
+import { type TableDragData, type TableDragSource } from "@lapis-notes/ui/table-dnd/utils";
+export declare const CSV_TABLE_ROW_TYPE: string;
+export declare const CSV_TABLE_COL_TYPE: string;
+export type CsvTableDragType = typeof CSV_TABLE_ROW_TYPE | typeof CSV_TABLE_COL_TYPE;
+export type CsvTableDragSource = TableDragSource;
+export type CsvTableDragData = TableDragData;
+export declare function dropIndicatorClasses(dragSource: CsvTableDragSource | null, dragOverIndex: number | null, rowIndex: number, colIndex: number): string;
+export declare function isRowDragSource(dragSource: CsvTableDragSource | null, rowIndex: number): boolean;
+export declare function isColumnDragSource(dragSource: CsvTableDragSource | null, colIndex: number): boolean;

package/dist/lib/components/csv-table-dnd.js

@@ -0,0 +1,12 @@
+import { dropIndicatorClasses as dropIndicatorClassesBase, isColumnDragSource as isColumnDragSourceBase, isRowDragSource as isRowDragSourceBase, tableColDragType, tableRowDragType, } from "@lapis-notes/ui/table-dnd/utils";
+export const CSV_TABLE_ROW_TYPE = tableRowDragType("csv");
+export const CSV_TABLE_COL_TYPE = tableColDragType("csv");
+export function dropIndicatorClasses(dragSource, dragOverIndex, rowIndex, colIndex) {
+    return dropIndicatorClassesBase(dragSource, dragOverIndex, rowIndex, colIndex, CSV_TABLE_ROW_TYPE, CSV_TABLE_COL_TYPE);
+}
+export function isRowDragSource(dragSource, rowIndex) {
+    return isRowDragSourceBase(dragSource, rowIndex, CSV_TABLE_ROW_TYPE);
+}
+export function isColumnDragSource(dragSource, colIndex) {
+    return isColumnDragSourceBase(dragSource, colIndex, CSV_TABLE_COL_TYPE);
+}

package/dist/lib/components/csv-table-drag-measure.d.ts

@@ -0,0 +1,7 @@
+export type CsvDragOverlayMetrics = {
+    width: number;
+    height: number;
+    segmentSizes: number[];
+};
+export declare function measureRowOverlayMetrics(table: HTMLElement, rowIndex: number): CsvDragOverlayMetrics | null;
+export declare function measureColumnOverlayMetrics(table: HTMLElement, colIndex: number): CsvDragOverlayMetrics | null;

package/dist/lib/components/csv-table-drag-measure.js

@@ -0,0 +1,38 @@
+function readSize(element) {
+    return element.getBoundingClientRect().width;
+}
+function readHeight(element) {
+    return element.getBoundingClientRect().height;
+}
+export function measureRowOverlayMetrics(table, rowIndex) {
+    const row = table.querySelector(`tr[data-csv-row-index="${rowIndex}"]`);
+    if (!row) {
+        return null;
+    }
+    const cells = Array.from(row.querySelectorAll("td.csv-data-table__cell:not(.csv-data-table__cell--actions)"));
+    if (!cells.length) {
+        return null;
+    }
+    const segmentSizes = cells.map(readSize);
+    const height = Math.max(...cells.map(readHeight));
+    return {
+        width: segmentSizes.reduce((total, size) => total + size, 0),
+        height,
+        segmentSizes,
+    };
+}
+export function measureColumnOverlayMetrics(table, colIndex) {
+    const head = table.querySelector(`th[data-csv-col-index="${colIndex}"]`);
+    const bodyCells = Array.from(table.querySelectorAll(`td[data-csv-col-index="${colIndex}"]`));
+    const segments = head ? [head, ...bodyCells] : bodyCells;
+    if (!segments.length) {
+        return null;
+    }
+    const segmentSizes = segments.map(readHeight);
+    const width = Math.max(...segments.map(readSize));
+    return {
+        width,
+        height: segmentSizes.reduce((total, size) => total + size, 0),
+        segmentSizes,
+    };
+}

package/dist/lib/components/csv-table-selection.d.ts

@@ -0,0 +1,28 @@
+export type CsvCellCoord = [row: number, col: number];
+export type CsvSelectionState = {
+    start: CsvCellCoord;
+    end: CsvCellCoord;
+    isMouseDown: boolean;
+};
+export declare function createSelectionState(): CsvSelectionState;
+export type CsvSelectionRange = {
+    minRow: number;
+    maxRow: number;
+    minCol: number;
+    maxCol: number;
+};
+/** Inclusive bounds for a drag, including the anchor cell. */
+export declare function dragSelectionRange(start: CsvCellCoord, end: CsvCellCoord): CsvSelectionRange | null;
+export declare function selectionClassForCoord(range: CsvSelectionRange | null, row: number, col: number): string | undefined;
+export declare function coordFromTarget(target: EventTarget | null): CsvCellCoord;
+export declare function getCellsBetween(start: CsvCellCoord, end: CsvCellCoord): CsvCellCoord[];
+export declare function selectionClassesForCells(selected: CsvCellCoord[]): Record<string, string>;
+export declare function headerSelectionClassForColumn(colIndex: number, selected: CsvCellCoord[], headerRow: boolean, bodyRowIndices: number[]): string | undefined;
+export declare function columnSelection(rowCount: number, column: number): CsvCellCoord[];
+export declare function rowSelection(colCount: number, row: number): CsvCellCoord[];
+export declare function columnSelectionIncludingHeader(gridRowCount: number, column: number, headerRow: boolean, bodyRowIndices: number[]): CsvCellCoord[];
+export declare function fullRowsAndColumns(selectedCells: CsvCellCoord[], rowCount: number, colCount: number): {
+    fullRows: number[];
+    fullCols: number[];
+};
+export declare function coordsFromCellElement(cell: HTMLElement | null, currentTarget: EventTarget | null): CsvCellCoord;

package/dist/lib/components/csv-table-selection.js

@@ -0,0 +1,178 @@
+export function createSelectionState() {
+    return { start: [-1, -1], end: [-1, -1], isMouseDown: false };
+}
+/** Inclusive bounds for a drag, including the anchor cell. */
+export function dragSelectionRange(start, end) {
+    const [row1, col1] = start;
+    const [row2, col2] = end;
+    if (row1 < 0 || col1 < 0 || row2 < 0 || col2 < 0) {
+        return null;
+    }
+    return {
+        minRow: Math.min(row1, row2),
+        maxRow: Math.max(row1, row2),
+        minCol: Math.min(col1, col2),
+        maxCol: Math.max(col1, col2),
+    };
+}
+export function selectionClassForCoord(range, row, col) {
+    if (!range ||
+        row < range.minRow ||
+        row > range.maxRow ||
+        col < range.minCol ||
+        col > range.maxCol) {
+        return undefined;
+    }
+    const decorations = ["is-selected"];
+    if (row === range.minRow)
+        decorations.push("top");
+    if (col === range.minCol)
+        decorations.push("start");
+    if (row === range.maxRow)
+        decorations.push("bottom");
+    if (col === range.maxCol)
+        decorations.push("end");
+    return decorations.join(" ");
+}
+export function coordFromTarget(target) {
+    if (!(target instanceof Element)) {
+        return [-1, -1];
+    }
+    const cell = target.closest("[data-csv-cell]");
+    if (!(cell instanceof HTMLElement) || !cell.dataset.csvCell) {
+        return [-1, -1];
+    }
+    const [row, col] = cell.dataset.csvCell.split(":").map(Number);
+    if (!Number.isInteger(row) || !Number.isInteger(col)) {
+        return [-1, -1];
+    }
+    return [row, col];
+}
+export function getCellsBetween(start, end) {
+    const [row1, col1] = start;
+    const [row2, col2] = end;
+    if (row1 < 0 || col1 < 0 || row2 < 0 || col2 < 0) {
+        return [];
+    }
+    const minRow = Math.min(row1, row2);
+    const maxRow = Math.max(row1, row2);
+    const minCol = Math.min(col1, col2);
+    const maxCol = Math.max(col1, col2);
+    const cells = [];
+    for (let row = minRow; row <= maxRow; row += 1) {
+        for (let col = minCol; col <= maxCol; col += 1) {
+            cells.push([row, col]);
+        }
+    }
+    if (cells.length === 1) {
+        return [];
+    }
+    return cells;
+}
+export function selectionClassesForCells(selected) {
+    const data = {};
+    if (!selected.length) {
+        return data;
+    }
+    let minRow = selected[0][0];
+    let maxRow = selected[0][0];
+    let minCol = selected[0][1];
+    let maxCol = selected[0][1];
+    for (const [row, col] of selected) {
+        if (row < minRow)
+            minRow = row;
+        if (row > maxRow)
+            maxRow = row;
+        if (col < minCol)
+            minCol = col;
+        if (col > maxCol)
+            maxCol = col;
+    }
+    for (const pos of selected) {
+        const id = pos.join(",");
+        const [row, col] = pos;
+        const decorations = ["is-selected"];
+        if (row === minRow) {
+            decorations.push("top");
+        }
+        if (col === minCol) {
+            decorations.push("start");
+        }
+        if (row === maxRow) {
+            decorations.push("bottom");
+        }
+        if (col === maxCol) {
+            decorations.push("end");
+        }
+        data[id] = decorations.join(" ");
+    }
+    return data;
+}
+export function headerSelectionClassForColumn(colIndex, selected, headerRow, bodyRowIndices) {
+    if (headerRow) {
+        return selectionClassesForCells(selected)[`0,${colIndex}`];
+    }
+    if (bodyRowIndices.length === 0) {
+        return undefined;
+    }
+    const allBodyRowsSelected = bodyRowIndices.every((rowIndex) => selected.some(([row, col]) => row === rowIndex && col === colIndex));
+    if (!allBodyRowsSelected) {
+        return undefined;
+    }
+    return "is-selected top bottom start end";
+}
+export function columnSelection(rowCount, column) {
+    return Array.from({ length: rowCount }, (_, row) => [row, column]);
+}
+export function rowSelection(colCount, row) {
+    return Array.from({ length: colCount }, (_, col) => [row, col]);
+}
+export function columnSelectionIncludingHeader(gridRowCount, column, headerRow, bodyRowIndices) {
+    const coords = [];
+    if (headerRow && gridRowCount > 0) {
+        coords.push([0, column]);
+    }
+    for (const rowIndex of bodyRowIndices) {
+        coords.push([rowIndex, column]);
+    }
+    return coords;
+}
+export function fullRowsAndColumns(selectedCells, rowCount, colCount) {
+    const rowMap = new Map();
+    const colMap = new Map();
+    for (const [row, col] of selectedCells) {
+        if (!rowMap.has(row))
+            rowMap.set(row, new Set());
+        if (!colMap.has(col))
+            colMap.set(col, new Set());
+        rowMap.get(row).add(col);
+        colMap.get(col).add(row);
+    }
+    const fullRows = [];
+    const fullCols = [];
+    for (const [row, cols] of rowMap.entries()) {
+        if (cols.size === colCount) {
+            fullRows.push(row);
+        }
+    }
+    for (const [col, rows] of colMap.entries()) {
+        if (rows.size === rowCount) {
+            fullCols.push(col);
+        }
+    }
+    return { fullRows, fullCols };
+}
+export function coordsFromCellElement(cell, currentTarget) {
+    let tableCell = cell;
+    while (tableCell && !tableCell.dataset.csvCell) {
+        if (tableCell === currentTarget) {
+            return [-1, -1];
+        }
+        tableCell = tableCell.parentElement;
+    }
+    if (!tableCell?.dataset.csvCell) {
+        return [-1, -1];
+    }
+    const [row, col] = tableCell.dataset.csvCell.split(":").map(Number);
+    return [row, col];
+}

package/dist/lib/components/csv-table-view.svelte

@@ -0,0 +1,265 @@
+<script lang="ts">
+  import { ScrollArea } from "@lapismd/design-core/shadcn/scroll-area";
+  import { cn } from "@lapis-notes/ui";
+  import type { App, TFile } from "@lapis-notes/api";
+  import { onMount } from "svelte";
+  import type { Attachment } from "svelte/attachments";
+  import { CsvGrid } from "../model/csv-grid";
+  import { parseCsvText } from "../model/parse-csv";
+  import {
+    csvBodyCounts,
+    csvCellMatches,
+    csvSearchQuery,
+    csvShownRowCount,
+    isCsvFindShortcut,
+  } from "../model/csv-search";
+  import {
+    resolveDelimiter,
+    type CsvPluginSettings,
+    type CsvPluginSettingsPatch,
+  } from "../../csv-settings";
+  import CsvDataTable from "./csv-data-table.svelte";
+  import CsvFind from "./csv-find.svelte";
+  import { CSV_ROW_HEIGHT } from "./csv-row-virtualizer.svelte";
+  import CsvStatusBar from "./csv-status-bar.svelte";
+
+  type Props = {
+    app: App;
+    file: TFile;
+    content: string;
+    settings: CsvPluginSettings;
+    class?: string;
+    onContentChange?: (text: string) => void;
+    onSettingsChange?: (patch: CsvPluginSettingsPatch) => void;
+    onToggleSource?: () => void;
+    onShowCanvas?: () => void;
+  };
+
+  let {
+    app,
+    file,
+    content,
+    settings,
+    class: className,
+    onContentChange,
+    onSettingsChange,
+    onToggleSource,
+    onShowCanvas,
+  }: Props = $props();
+
+  let scrollViewport = $state<HTMLElement | null>(null);
+  let incoming = $state<string | null>(null);
+  let searchOpen = $state(false);
+  let searchRequest = $state(0);
+  let searchValue = $state("");
+  let replaceValue = $state("");
+  let caseSensitive = $state(false);
+  let wholeWord = $state(false);
+  let regexp = $state(false);
+  let active = $state(0);
+  const text = $derived(incoming ?? content);
+  const delimiter = $derived(resolveDelimiter(settings, file.extension));
+  const parsed = $derived.by(() => {
+    const source = text;
+    const result = parseCsvText(source, { delimiter });
+    return {
+      errors: result.errors.map(
+        (error) => `Row ${error.row ?? "?"}: ${error.message}`,
+      ),
+      grid:
+        result.rows.length > 0
+          ? CsvGrid.fromText(source, {
+              delimiter,
+              headerRow: settings.headerRow,
+            })
+          : CsvGrid.empty(),
+    };
+  });
+
+  const rows = $derived(parsed.grid.getRows());
+  const counts = $derived(
+    csvBodyCounts(
+      parsed.grid.getRowCount(),
+      parsed.grid.getColCount(),
+      settings.headerRow,
+    ),
+  );
+  const searchQuery = $derived(
+    csvSearchQuery({
+      search: searchValue,
+      replace: replaceValue,
+      caseSensitive,
+      wholeWord,
+      regexp,
+    }),
+  );
+  const filtering = $derived(
+    searchOpen && searchQuery.search.length > 0 && searchQuery.valid,
+  );
+  const searchMatches = $derived.by(() => {
+    if (!filtering) return [];
+    return csvCellMatches(rows, searchQuery);
+  });
+  const matchedRows = $derived(
+    new Set(searchMatches.map((match) => match.row)),
+  );
+  const filteredBodyIndexes = $derived.by(() => {
+    if (!filtering) return null;
+    const start = settings.headerRow ? 1 : 0;
+    const indexes: number[] = [];
+    for (let index = start; index < rows.length; index += 1) {
+      if (matchedRows.has(index)) indexes.push(index);
+    }
+    return indexes;
+  });
+  const shownRows = $derived(
+    filtering
+      ? csvShownRowCount(rows.length, settings.headerRow, searchMatches)
+      : undefined,
+  );
+  const searchCell = $derived.by(() => {
+    if (searchMatches.length === 0) return null;
+    const match = searchMatches[Math.min(active, searchMatches.length - 1)];
+    return match ? { row: match.row, col: match.col } : null;
+  });
+
+  function handleGridChange(nextGrid: CsvGrid) {
+    const next = nextGrid.toText({ delimiter });
+    incoming = next;
+    onContentChange?.(next);
+  }
+
+  function replaceCells(
+    edits: { row: number; col: number; value: string }[],
+  ) {
+    const next = parsed.grid.clone();
+    for (const edit of edits) next.updateCell(edit.row, edit.col, edit.value);
+    handleGridChange(next);
+  }
+
+  function openSearch() {
+    searchOpen = true;
+    searchRequest += 1;
+  }
+
+  function toggleSearch() {
+    if (searchOpen) {
+      searchOpen = false;
+      return;
+    }
+    openSearch();
+  }
+
+  function onFindShortcut(event: KeyboardEvent) {
+    if (!isCsvFindShortcut(event)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    openSearch();
+  }
+
+  const findShortcut: Attachment<HTMLElement> = (node) => {
+    node.addEventListener("keydown", onFindShortcut, true);
+    return () => node.removeEventListener("keydown", onFindShortcut, true);
+  };
+
+  const scrollToSearch: Attachment<HTMLElement> = () => {
+    const viewport = scrollViewport;
+    if (!viewport) return;
+    const target = searchCell;
+    if (!target) {
+      if (filtering) viewport.scrollTop = 0;
+      return;
+    }
+    if (settings.headerRow && target.row === 0) return;
+    const bodyIndex = filteredBodyIndexes
+      ? filteredBodyIndexes.indexOf(target.row)
+      : settings.headerRow
+        ? target.row - 1
+        : target.row;
+    if (bodyIndex < 0) return;
+    const top = Math.max(0, bodyIndex) * CSV_ROW_HEIGHT;
+    const bottom = top + CSV_ROW_HEIGHT;
+    const viewTop = viewport.scrollTop;
+    const viewBottom = viewTop + viewport.clientHeight;
+    if (top >= viewTop && bottom <= viewBottom) return;
+    viewport.scrollTop = Math.max(
+      0,
+      top - Math.floor(viewport.clientHeight / 3),
+    );
+  };
+
+  const searchScrollKey = $derived.by(() => {
+    if (!filtering) return "";
+    if (!searchCell) return "none";
+    const bodyIndex = filteredBodyIndexes?.indexOf(searchCell.row) ?? -1;
+    return `${bodyIndex}:${searchCell.col}`;
+  });
+
+  onMount(() => {
+    const currentApp = app;
+    const currentFile = file;
+    const modified = currentApp.vault.on("modify", (candidate) => {
+      if (candidate.path !== currentFile.path) return;
+      void currentApp.vault.cachedRead(currentFile).then((next) => {
+        incoming = next;
+      });
+    });
+    return () => {
+      currentApp.vault.offref(modified);
+    };
+  });
+</script>
+
+<div class={cn("csv-table-view", className)} {@attach findShortcut}>
+  {#if parsed.errors.length > 0}
+    <div class="csv-table-view__errors" role="status">
+      {#each parsed.errors as error (error)}
+        <p>{error}</p>
+      {/each}
+    </div>
+  {/if}
+
+  <CsvFind
+    bind:open={searchOpen}
+    bind:searchValue
+    bind:replaceValue
+    bind:caseSensitive
+    bind:wholeWord
+    bind:regexp
+    bind:active
+    {searchRequest}
+    {rows}
+    onReplaceCells={replaceCells}
+  />
+  {#key searchScrollKey}
+    <span hidden {@attach scrollToSearch}></span>
+  {/key}
+
+  <ScrollArea
+    class="csv-table-view__scroll"
+    orientation="both"
+    bind:viewportRef={scrollViewport}
+  >
+    <CsvDataTable
+      grid={parsed.grid}
+      headerRow={settings.headerRow}
+      showRowNumbers={settings.showRowNumbers}
+      {scrollViewport}
+      rowFilter={filtering ? matchedRows : null}
+      {searchCell}
+      onChange={handleGridChange}
+      {onSettingsChange}
+      {onToggleSource}
+    />
+  </ScrollArea>
+  <CsvStatusBar
+    columns={counts.columns}
+    rows={counts.rows}
+    {shownRows}
+    {searchOpen}
+    mode="table"
+    onToggleSearch={toggleSearch}
+    onToggleMode={onToggleSource}
+    {onShowCanvas}
+  />
+</div>

package/dist/lib/components/csv-table-view.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { App, TFile } from "@lapis-notes/api";
+import { type CsvPluginSettings, type CsvPluginSettingsPatch } from "../../csv-settings";
+type Props = {
+    app: App;
+    file: TFile;
+    content: string;
+    settings: CsvPluginSettings;
+    class?: string;
+    onContentChange?: (text: string) => void;
+    onSettingsChange?: (patch: CsvPluginSettingsPatch) => void;
+    onToggleSource?: () => void;
+    onShowCanvas?: () => void;
+};
+declare const CsvTableView: import("svelte").Component<Props, {}, "">;
+type CsvTableView = ReturnType<typeof CsvTableView>;
+export default CsvTableView;

package/dist/lib/csv-plugin.d.ts

@@ -0,0 +1,9 @@
+import { Plugin, type App, type PluginManifest } from "@lapis-notes/api";
+import { CSV_FILENAME_PATTERNS, CSV_PLUGIN_ID, CSV_VIEW_TYPE } from "./ids";
+export { CSV_PLUGIN_ID, CSV_VIEW_TYPE, CSV_FILENAME_PATTERNS };
+export declare class CSVPlugin extends Plugin {
+    constructor(app: App, manifest?: PluginManifest);
+    onload(): void;
+    private openTable;
+}
+export default CSVPlugin;