omni-viewer-core 0.1.0

package/dist/parsers/blf/index.d.ts

@@ -0,0 +1 @@
+export { parseBlf } from '../automotive/index.js';

package/dist/parsers/blf/index.js

@@ -0,0 +1 @@
+export { parseBlf } from '../automotive/index.js';

package/dist/parsers/csv/delimiter.d.ts

@@ -0,0 +1,31 @@
+export type CsvDelimiter = ',' | ';' | '\t' | '|';
+export interface DelimiterDetectionResult {
+    delimiter: CsvDelimiter;
+    confidence: number;
+}
+/** Order matters — earlier candidates win priority ties. */
+export declare const DELIMITER_PRIORITY: readonly CsvDelimiter[];
+export interface DetectOptions {
+    /** Maximum number of leading lines to inspect (default 10). */
+    sampleLines?: number;
+}
+/**
+ * Detect the most likely delimiter in `text`.
+ *
+ * Always returns a result. When `text` has no candidates at all (e.g. a
+ * single-column CSV) we fall back to `,` with confidence 0 so callers can
+ * still parse deterministically.
+ */
+export declare function detectDelimiter(text: string, options?: DetectOptions): DelimiterDetectionResult;
+/**
+ * Count occurrences of `delimiter` in `line`, ignoring any inside a
+ * double-quoted span (`""` is the escaped quote and stays inside).
+ */
+export declare function countOutsideQuotes(line: string, delimiter: string): number;
+/** ASCII-only lowercase (determinism rule — no locale-dependent toLowerCase). */
+export declare function asciiLower(s: string): string;
+/**
+ * Extension shortcut: `.tsv` is unambiguously tab-delimited; anything else
+ * falls through to content-based detection.
+ */
+export declare function detectDelimiterForFile(fileName: string, text: string, options?: DetectOptions): DelimiterDetectionResult;

package/dist/parsers/csv/delimiter.js

@@ -0,0 +1,151 @@
+// CSV delimiter auto-detection. Ported unchanged (already pure and
+// deterministic) from omni-viewer-chrome `templates/csv/js/csvDelimiter.ts`,
+// except the file-extension shortcut uses ASCII-only lowercasing (ADR 41).
+/** Order matters — earlier candidates win priority ties. */
+export const DELIMITER_PRIORITY = [',', '\t', ';', '|'];
+const DEFAULT_SAMPLE_LINES = 10;
+const DEFAULT_DELIMITER = ',';
+/**
+ * Detect the most likely delimiter in `text`.
+ *
+ * Always returns a result. When `text` has no candidates at all (e.g. a
+ * single-column CSV) we fall back to `,` with confidence 0 so callers can
+ * still parse deterministically.
+ */
+export function detectDelimiter(text, options = {}) {
+    const sampleLines = options.sampleLines ?? DEFAULT_SAMPLE_LINES;
+    const lines = takeSampleLines(text, sampleLines);
+    if (lines.length === 0) {
+        return { delimiter: DEFAULT_DELIMITER, confidence: 0 };
+    }
+    const scores = DELIMITER_PRIORITY.map((delimiter, priorityIndex) => {
+        const counts = lines.map((line) => countOutsideQuotes(line, delimiter));
+        const positive = counts.filter((c) => c > 0);
+        const mean = positive.length === 0 ? 0 : sum(positive) / positive.length;
+        const variance = positive.length === 0
+            ? Number.POSITIVE_INFINITY
+            : varianceOf(positive, mean);
+        // Consistency factor squared: a delimiter firing on every line beats
+        // one firing on a single high-count outlier.
+        const consistency = positive.length / lines.length;
+        const score = mean * consistency * consistency;
+        return { delimiter, mean, variance, score, priorityIndex };
+    });
+    scores.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (a.variance !== b.variance)
+            return a.variance - b.variance;
+        return a.priorityIndex - b.priorityIndex;
+    });
+    const winner = scores[0];
+    if (!winner || winner.score === 0) {
+        return { delimiter: DEFAULT_DELIMITER, confidence: 0 };
+    }
+    const runnerUp = scores[1];
+    const runnerScore = runnerUp ? runnerUp.score : 0;
+    const total = winner.score + runnerScore;
+    const confidence = total === 0 ? 0 : (winner.score - runnerScore) / total;
+    return {
+        delimiter: winner.delimiter,
+        confidence: Math.max(0, Math.min(1, confidence))
+    };
+}
+/**
+ * Slice `text` into up to `max` logical lines: a `\n` only breaks a line when
+ * it falls outside an open double-quoted span.
+ */
+function takeSampleLines(text, max) {
+    if (!text || max <= 0)
+        return [];
+    const stripped = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    const normalized = stripped.replace(/\r\n?/g, '\n');
+    const out = [];
+    let buf = '';
+    let inQuotes = false;
+    for (let i = 0; i < normalized.length; i++) {
+        const ch = normalized[i];
+        if (ch === '"') {
+            if (inQuotes && normalized[i + 1] === '"') {
+                buf += '""';
+                i++;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            buf += ch;
+            continue;
+        }
+        if (ch === '\n' && !inQuotes) {
+            if (buf.length > 0)
+                out.push(buf);
+            buf = '';
+            if (out.length >= max)
+                return out;
+            continue;
+        }
+        buf += ch;
+    }
+    if (out.length < max && buf.length > 0)
+        out.push(buf);
+    return out;
+}
+/**
+ * Count occurrences of `delimiter` in `line`, ignoring any inside a
+ * double-quoted span (`""` is the escaped quote and stays inside).
+ */
+export function countOutsideQuotes(line, delimiter) {
+    if (!delimiter)
+        return 0;
+    let count = 0;
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                i++;
+                continue;
+            }
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (!inQuotes && ch === delimiter) {
+            count++;
+        }
+    }
+    return count;
+}
+function sum(values) {
+    let s = 0;
+    for (const v of values)
+        s += v;
+    return s;
+}
+function varianceOf(values, mean) {
+    if (values.length <= 1)
+        return 0;
+    let acc = 0;
+    for (const v of values) {
+        const d = v - mean;
+        acc += d * d;
+    }
+    return acc / values.length;
+}
+/** ASCII-only lowercase (determinism rule — no locale-dependent toLowerCase). */
+export function asciiLower(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        out += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : s[i];
+    }
+    return out;
+}
+/**
+ * Extension shortcut: `.tsv` is unambiguously tab-delimited; anything else
+ * falls through to content-based detection.
+ */
+export function detectDelimiterForFile(fileName, text, options = {}) {
+    if (asciiLower(fileName).endsWith('.tsv')) {
+        return { delimiter: '\t', confidence: 1 };
+    }
+    return detectDelimiter(text, options);
+}

package/dist/parsers/csv/index.d.ts

@@ -0,0 +1,30 @@
+import type { ParseOptions, ParseOutcome } from '../types.js';
+import { type CsvDelimiter } from './delimiter.js';
+export type { CsvDelimiter, DelimiterDetectionResult } from './delimiter.js';
+export { detectDelimiter, detectDelimiterForFile, DELIMITER_PRIORITY, asciiLower } from './delimiter.js';
+export * from './sort.js';
+export * from './statistics.js';
+export type { RawCsv } from './parseText.js';
+export interface CsvDocument {
+    headers: string[];
+    rows: string[][];
+    columnCount: number;
+    delimiter: CsvDelimiter;
+    detection: {
+        delimiter: CsvDelimiter;
+        confidence: number;
+        source: 'auto' | 'extension' | 'override';
+    };
+}
+export interface CsvParseOptions extends ParseOptions {
+    /** Explicit delimiter override; skips auto-detection. */
+    delimiter?: CsvDelimiter;
+    /** Used for the `.tsv` extension shortcut during auto-detection. */
+    fileName?: string;
+    /** First row is headers (default true). */
+    hasHeader?: boolean;
+}
+/** Input ownership: this parser borrows the input (DESIGN.md §3-① — the
+ *  caller keeps the bytes; nothing is transferred or mutated). */
+export declare const CSV_INPUT_OWNERSHIP: "borrows";
+export declare function parseCsv(input: Uint8Array | string, options?: CsvParseOptions): ParseOutcome<CsvDocument>;

package/dist/parsers/csv/index.js

@@ -0,0 +1,108 @@
+// CSV parser entry — the core contract surface (DESIGN.md §3-①).
+//
+// parseCsv(bytes or text) -> ParseOutcome<CsvDocument>. Input-caused failures
+// never throw; limits stop parsing with `partial` + a limit diagnostic.
+import { DEFAULT_LIMITS, LimitTracker, decodeUtf8, utf8ByteLength } from '../types.js';
+import { parseCsvText } from './parseText.js';
+import { detectDelimiter, detectDelimiterForFile, asciiLower } from './delimiter.js';
+export { detectDelimiter, detectDelimiterForFile, DELIMITER_PRIORITY, asciiLower } from './delimiter.js';
+export * from './sort.js';
+export * from './statistics.js';
+/** Input ownership: this parser borrows the input (DESIGN.md §3-① — the
+ *  caller keeps the bytes; nothing is transferred or mutated). */
+export const CSV_INPUT_OWNERSHIP = 'borrows';
+export function parseCsv(input, options = {}) {
+    const started = Date.now();
+    const limits = { ...DEFAULT_LIMITS, ...options.limits };
+    const diagnostics = [];
+    const finish = (result) => ({
+        result,
+        execution: {
+            workerUsed: false,
+            hardLimitEnforced: false,
+            elapsedMillis: Date.now() - started
+        }
+    });
+    const inputBytes = typeof input === 'string' ? utf8ByteLength(input) : input.byteLength;
+    if (inputBytes > limits.maxInputBytes) {
+        return finish({
+            status: 'failed',
+            failure: {
+                code: 'limit-exceeded',
+                retryable: false,
+                messageKey: 'diag.limit-exceeded.input',
+                args: { maxBytes: limits.maxInputBytes }
+            },
+            diagnostics
+        });
+    }
+    if (options.signal?.aborted) {
+        return finish({
+            status: 'failed',
+            failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' },
+            diagnostics
+        });
+    }
+    const text = typeof input === 'string' ? input : decodeUtf8(input);
+    let detection;
+    if (options.delimiter !== undefined) {
+        detection = { delimiter: options.delimiter, confidence: 1, source: 'override' };
+    }
+    else if (options.fileName !== undefined && asciiLower(options.fileName).endsWith('.tsv')) {
+        detection = { ...detectDelimiterForFile(options.fileName, text), source: 'extension' };
+    }
+    else {
+        detection = { ...detectDelimiter(text), source: 'auto' };
+    }
+    const tracker = new LimitTracker(limits, options.signal);
+    let violation = null;
+    const parseTextOptions = {
+        delimiter: detection.delimiter,
+        checkpoint: (recordCount) => {
+            tracker.addEntries(1);
+            // Amortize the time/abort checks: every 256 records.
+            if (recordCount % 256 !== 0 && recordCount <= limits.maxEntries) {
+                return true;
+            }
+            violation = tracker.checkpoint();
+            return violation === null;
+        }
+    };
+    if (options.hasHeader !== undefined) {
+        parseTextOptions.hasHeader = options.hasHeader;
+    }
+    const raw = parseCsvText(text, parseTextOptions);
+    if (raw.raggedRowCount > 0) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'csv.ragged-rows',
+            messageKey: 'diag.csv.ragged-rows',
+            args: { count: raw.raggedRowCount }
+        });
+    }
+    const document = {
+        headers: raw.headers,
+        rows: raw.rows,
+        columnCount: raw.columnCount,
+        delimiter: detection.delimiter,
+        detection
+    };
+    if (raw.stoppedEarly) {
+        const v = violation;
+        if (v && v.kind === 'aborted') {
+            return finish({
+                status: 'failed',
+                failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' },
+                diagnostics
+            });
+        }
+        diagnostics.push({
+            severity: 'warning',
+            code: 'limit-exceeded',
+            messageKey: 'diag.limit-exceeded.rows',
+            args: { count: document.rows.length }
+        });
+        return finish({ status: 'partial', document, diagnostics });
+    }
+    return finish({ status: 'ok', document, diagnostics });
+}

package/dist/parsers/csv/parseText.d.ts

@@ -0,0 +1,20 @@
+export interface RawCsv {
+    headers: string[];
+    rows: string[][];
+    columnCount: number;
+    /** Rows whose cell count differed from columnCount (padded/truncated). */
+    raggedRowCount: number;
+    /** True when the record loop was stopped early by the checkpoint. */
+    stoppedEarly: boolean;
+}
+export interface ParseTextOptions {
+    delimiter?: string;
+    /** First row is headers (default true); otherwise headers are generated. */
+    hasHeader?: boolean;
+    /**
+     * Called after each completed record with the running record count.
+     * Return false to stop parsing (limit hit / aborted).
+     */
+    checkpoint?: (recordCount: number) => boolean;
+}
+export declare function parseCsvText(text: string, options?: ParseTextOptions): RawCsv;

package/dist/parsers/csv/parseText.js

@@ -0,0 +1,108 @@
+// RFC-4180-ish CSV text parser. Ported from omni-viewer-chrome
+// `templates/csv/js/csvParser.ts` with two changes for the core contract:
+//   - ragged rows (padded / truncated to columnCount) are counted so the
+//     caller can emit a `diag.csv.ragged-rows` diagnostic,
+//   - the record loop reports through a cooperative checkpoint callback so
+//     limits / cancellation can stop parsing mid-file (DESIGN.md §3-①).
+export function parseCsvText(text, options = {}) {
+    const delimiter = options.delimiter ?? ',';
+    const hasHeader = options.hasHeader ?? true;
+    const checkpoint = options.checkpoint;
+    // Strip BOM so the first header doesn't carry a leading U+FEFF.
+    const stripped = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+    const normalized = stripped.replace(/\r\n?/g, '\n');
+    const records = [];
+    let field = '';
+    let row = [];
+    let inQuotes = false;
+    let stoppedEarly = false;
+    for (let i = 0; i < normalized.length; i++) {
+        const ch = normalized[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (normalized[i + 1] === '"') {
+                    field += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                field += ch;
+            }
+            continue;
+        }
+        if (ch === '"' && field.length === 0) {
+            inQuotes = true;
+            continue;
+        }
+        if (ch === delimiter) {
+            row.push(field);
+            field = '';
+            continue;
+        }
+        if (ch === '\n') {
+            row.push(field);
+            field = '';
+            records.push(row);
+            row = [];
+            if (checkpoint && !checkpoint(records.length)) {
+                stoppedEarly = true;
+                break;
+            }
+            continue;
+        }
+        field += ch;
+    }
+    // Flush the last field/row unless we stopped early mid-record. Drop a
+    // trailing empty row produced by a final newline. The flushed record goes
+    // through the same checkpoint as the loop, so a file without a trailing
+    // newline cannot slip one record past the entry limit unreported.
+    if (!stoppedEarly && (field.length > 0 || row.length > 0)) {
+        row.push(field);
+        records.push(row);
+        if (checkpoint && !checkpoint(records.length)) {
+            stoppedEarly = true;
+        }
+    }
+    if (records.length === 0) {
+        return { headers: [], rows: [], columnCount: 0, raggedRowCount: 0, stoppedEarly };
+    }
+    let headers;
+    let dataRows;
+    if (hasHeader) {
+        headers = records[0] ?? [];
+        dataRows = records.slice(1);
+    }
+    else {
+        headers = [];
+        dataRows = records;
+    }
+    let columnCount = headers.length;
+    for (const r of dataRows) {
+        if (r.length > columnCount)
+            columnCount = r.length;
+    }
+    if (!hasHeader) {
+        headers = Array.from({ length: columnCount }, (_, i) => `Column ${i + 1}`);
+    }
+    else {
+        while (headers.length < columnCount) {
+            headers.push(`Column ${headers.length + 1}`);
+        }
+    }
+    let raggedRowCount = 0;
+    const padded = dataRows.map((r) => {
+        if (r.length === columnCount)
+            return r;
+        raggedRowCount++;
+        if (r.length > columnCount)
+            return r.slice(0, columnCount);
+        const out = r.slice();
+        while (out.length < columnCount)
+            out.push('');
+        return out;
+    });
+    return { headers, rows: padded, columnCount, raggedRowCount, stoppedEarly };
+}

package/dist/parsers/csv/sort.d.ts

@@ -0,0 +1,26 @@
+export type SortDirection = 'asc' | 'desc' | null;
+export interface SortState {
+    columnIndex: number | null;
+    direction: SortDirection;
+}
+export type ColumnType = 'number' | 'date' | 'text';
+/** Cycle asc -> desc -> none; switching column restarts at asc. */
+export declare function nextSortState(current: SortState, columnIndex: number): SortState;
+/** Parse a supported date shape to epoch millis; null when not date-shaped. */
+export declare function parseDateKey(value: string): number | null;
+/**
+ * Detect the type of a column from its values. Empty strings are ignored —
+ * they sort separately at the end.
+ */
+export declare function detectColumnType(values: readonly string[]): ColumnType;
+/**
+ * Deterministic natural compare: splits both strings into digit / non-digit
+ * runs; digit runs compare numerically ("10" > "9"), other runs compare by
+ * code point over the Unicode-default lowercased form.
+ */
+export declare function naturalCompare(a: string, b: string): number;
+/**
+ * Produce a sorted copy of `rowIndices` according to `state`. Stable; never
+ * mutates the input; empties end up at the bottom in both directions.
+ */
+export declare function applySort(rowIndices: readonly number[], state: SortState, getCell: (rowIndex: number, columnIndex: number) => string, columnType?: ColumnType): number[];