@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/csv/worker/worker.entry.js

@@ -0,0 +1,413 @@
+/**
+ * CSV Worker Entry
+ *
+ * This file runs inside a Web Worker (classic script after bundling).
+ * It implements the worker message protocol used by CsvWorkerPool.
+ *
+ * IMPORTANT:
+ * - Keep this file browser/worker-safe (no Node.js APIs)
+ * - Parsing/formatting are delegated to the main CSV implementations to avoid drift.
+ */
+import { parseCsv } from "../parse/index.js";
+import { formatCsv } from "../format/index.js";
+const sessions = new Map();
+function getSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        throw new Error(`Session not found: ${sessionId}`);
+    }
+    return session;
+}
+function reply(taskId, start, data) {
+    self.postMessage({
+        type: "result",
+        taskId,
+        data,
+        duration: performance.now() - start
+    });
+}
+function replyError(taskId, start, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    self.postMessage({
+        type: "error",
+        taskId,
+        error: message,
+        duration: performance.now() - start
+    });
+}
+function toObjectRows(data, headers) {
+    if (!Array.isArray(data)) {
+        return { rows: [], headers: headers ?? [] };
+    }
+    if (data.length === 0) {
+        return { rows: [], headers: headers ?? [] };
+    }
+    const first = data[0];
+    // Already objects
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+        const inferredHeaders = headers ?? Object.keys(first);
+        return { rows: data, headers: inferredHeaders };
+    }
+    // Array rows
+    const arrayRows = data;
+    let resolvedHeaders;
+    let rows;
+    if (headers && headers.length > 0) {
+        resolvedHeaders = headers;
+        rows = arrayRows;
+    }
+    else {
+        resolvedHeaders = (arrayRows[0] ?? []).map(v => String(v));
+        rows = arrayRows.slice(1);
+    }
+    const objects = rows.map(row => {
+        const obj = {};
+        for (let i = 0; i < resolvedHeaders.length; i++) {
+            obj[resolvedHeaders[i]] = row[i];
+        }
+        return obj;
+    });
+    return { rows: objects, headers: resolvedHeaders };
+}
+// =============================================================================
+// Data operations (sort/filter/search/groupBy/aggregate/page/query)
+// =============================================================================
+function sortData(data, configs) {
+    const list = Array.isArray(configs) ? configs : [configs];
+    data.sort((a, b) => {
+        for (const config of list) {
+            const { column, order = "asc", comparator = "auto" } = config;
+            const aVal = a[column];
+            const bVal = b[column];
+            let result;
+            if (comparator === "number" ||
+                (comparator === "auto" && !Number.isNaN(Number(aVal)) && !Number.isNaN(Number(bVal)))) {
+                result = Number(aVal ?? 0) - Number(bVal ?? 0);
+            }
+            else if (comparator === "date") {
+                result = new Date(aVal ?? 0).getTime() - new Date(bVal ?? 0).getTime();
+            }
+            else {
+                result = String(aVal ?? "").localeCompare(String(bVal ?? ""));
+            }
+            if (result !== 0) {
+                return order === "desc" ? -result : result;
+            }
+        }
+        return 0;
+    });
+}
+function evaluateCondition(row, condition, compiledRegex) {
+    const { column, operator, value, ignoreCase = false } = condition;
+    let fieldValue = row?.[column];
+    let compareValue = value;
+    if (ignoreCase && typeof fieldValue === "string" && operator !== "regex") {
+        fieldValue = fieldValue.toLowerCase();
+        if (typeof compareValue === "string") {
+            compareValue = compareValue.toLowerCase();
+        }
+        else if (Array.isArray(compareValue)) {
+            compareValue = compareValue.map((v) => (typeof v === "string" ? v.toLowerCase() : v));
+        }
+    }
+    switch (operator) {
+        case "eq":
+            return fieldValue === compareValue;
+        case "neq":
+            return fieldValue !== compareValue;
+        case "gt":
+            return Number(fieldValue) > Number(compareValue);
+        case "gte":
+            return Number(fieldValue) >= Number(compareValue);
+        case "lt":
+            return Number(fieldValue) < Number(compareValue);
+        case "lte":
+            return Number(fieldValue) <= Number(compareValue);
+        case "contains": {
+            const fv = ignoreCase ? String(fieldValue).toLowerCase() : String(fieldValue);
+            const cv = ignoreCase ? String(compareValue).toLowerCase() : String(compareValue);
+            return fv.includes(cv);
+        }
+        case "startsWith": {
+            const fv = ignoreCase ? String(fieldValue).toLowerCase() : String(fieldValue);
+            const cv = ignoreCase ? String(compareValue).toLowerCase() : String(compareValue);
+            return fv.startsWith(cv);
+        }
+        case "endsWith": {
+            const fv = ignoreCase ? String(fieldValue).toLowerCase() : String(fieldValue);
+            const cv = ignoreCase ? String(compareValue).toLowerCase() : String(compareValue);
+            return fv.endsWith(cv);
+        }
+        case "regex": {
+            const re = compiledRegex ?? new RegExp(compareValue, ignoreCase ? "i" : "");
+            return re.test(String(fieldValue));
+        }
+        case "in":
+            return Array.isArray(compareValue) && compareValue.includes(fieldValue);
+        case "notIn":
+            return !Array.isArray(compareValue) || !compareValue.includes(fieldValue);
+        case "isNull":
+            return fieldValue === null || fieldValue === undefined || fieldValue === "";
+        case "notNull":
+            return fieldValue !== null && fieldValue !== undefined && fieldValue !== "";
+        default:
+            return true;
+    }
+}
+function filterData(data, config) {
+    const { conditions, logic = "and" } = config;
+    // Pre-compile regex patterns to avoid re-creating RegExp per row
+    const compiledRegexMap = new Map();
+    for (const cond of conditions) {
+        if (cond.operator === "regex") {
+            compiledRegexMap.set(cond, new RegExp(cond.value, cond.ignoreCase ? "i" : ""));
+        }
+    }
+    const evaluate = logic === "and"
+        ? (row) => conditions.every(cond => evaluateCondition(row, cond, compiledRegexMap.get(cond)))
+        : (row) => conditions.some(cond => evaluateCondition(row, cond, compiledRegexMap.get(cond)));
+    return data.filter(evaluate);
+}
+function searchData(data, config) {
+    const { query, columns, ignoreCase = true } = config;
+    const searchQuery = ignoreCase ? query.toLowerCase() : query;
+    const resolvedColumns = columns ?? Object.keys(data[0] ?? {});
+    return data.filter(row => {
+        return resolvedColumns.some(col => {
+            let value = String(row[col] ?? "");
+            if (ignoreCase) {
+                value = value.toLowerCase();
+            }
+            return value.includes(searchQuery);
+        });
+    });
+}
+function computeAggregate(rows, column, fn) {
+    if (fn === "count") {
+        return rows.length;
+    }
+    if (fn === "first") {
+        return rows.length > 0 ? rows[0]?.[column] : null;
+    }
+    if (fn === "last") {
+        return rows.length > 0 ? rows[rows.length - 1]?.[column] : null;
+    }
+    const nums = rows.map(r => Number(r?.[column])).filter(n => !Number.isNaN(n));
+    if (nums.length === 0) {
+        return fn === "avg" ? 0 : null;
+    }
+    if (fn === "sum" || fn === "avg") {
+        const sum = nums.reduce((a, b) => a + b, 0);
+        return fn === "avg" ? sum / nums.length : sum;
+    }
+    if (fn === "min") {
+        return nums.reduce((a, b) => (a < b ? a : b), nums[0]);
+    }
+    if (fn === "max") {
+        return nums.reduce((a, b) => (a > b ? a : b), nums[0]);
+    }
+    return null;
+}
+function groupByData(data, config) {
+    const { columns, aggregates } = config;
+    const groups = new Map();
+    for (const row of data) {
+        const keyValues = columns.map(col => row[col]);
+        const key = keyValues.join("\0");
+        const existing = groups.get(key);
+        if (existing) {
+            existing.rows.push(row);
+        }
+        else {
+            groups.set(key, { keyValues, rows: [row] });
+        }
+    }
+    const result = [];
+    for (const group of groups.values()) {
+        const obj = {};
+        columns.forEach((col, idx) => {
+            obj[String(col)] = group.keyValues[idx];
+        });
+        for (const { column, fn, alias } of aggregates) {
+            obj[alias || `${column}_${fn}`] = computeAggregate(group.rows, column, fn);
+        }
+        result.push(obj);
+    }
+    return result;
+}
+function aggregateData(data, configs) {
+    const result = {};
+    for (const config of configs) {
+        const { column, fn, alias } = config;
+        result[alias || `${column}_${fn}`] = computeAggregate(data, column, fn);
+    }
+    return result;
+}
+function getPageData(data, config) {
+    const page = Math.max(1, config.page);
+    let { pageSize } = config;
+    if (pageSize <= 0) {
+        pageSize = data.length || 1;
+    }
+    const start = (page - 1) * pageSize;
+    return {
+        data: data.slice(start, start + pageSize),
+        page,
+        pageSize,
+        totalRows: data.length,
+        totalPages: Math.ceil(data.length / pageSize)
+    };
+}
+function executeQuery(session, config) {
+    let data = config.sort ? [...session.originalData] : session.originalData;
+    const result = { data: [] };
+    if (config.sort) {
+        sortData(data, config.sort);
+    }
+    if (config.filter) {
+        data = filterData(data, config.filter);
+        result.matchCount = data.length;
+    }
+    if (config.search) {
+        data = searchData(data, config.search);
+        result.matchCount = data.length;
+    }
+    if (config.groupBy) {
+        data = groupByData(data, config.groupBy);
+        result.groupCount = data.length;
+    }
+    else if (config.aggregate) {
+        result.aggregates = aggregateData(data, config.aggregate);
+    }
+    if (config.page) {
+        const pageResult = getPageData(data, config.page);
+        result.data = pageResult.data;
+        result.page = pageResult.page;
+        result.pageSize = pageResult.pageSize;
+        result.totalRows = pageResult.totalRows;
+        result.totalPages = pageResult.totalPages;
+    }
+    else {
+        result.data = data;
+    }
+    return result;
+}
+// =============================================================================
+// Message handler
+// =============================================================================
+self.onmessage = (event) => {
+    const msg = event.data;
+    const taskId = msg.taskId ?? 0;
+    const start = performance.now();
+    try {
+        switch (msg.type) {
+            case "parse": {
+                const result = parseCsv(msg.data, msg.options);
+                if (msg.sessionId) {
+                    const isObj = result && result.headers;
+                    sessions.set(msg.sessionId, {
+                        data: isObj ? result.rows : result,
+                        headers: isObj ? result.headers : null,
+                        originalData: isObj ? [...result.rows] : [...result]
+                    });
+                }
+                reply(taskId, start, result);
+                break;
+            }
+            case "format": {
+                reply(taskId, start, formatCsv(msg.data, msg.options));
+                break;
+            }
+            case "load": {
+                const { rows, headers } = toObjectRows(msg.data, msg.headers ?? null);
+                sessions.set(msg.sessionId, {
+                    data: rows,
+                    headers: headers ?? null,
+                    originalData: [...rows]
+                });
+                reply(taskId, start, { rowCount: rows.length, headers });
+                break;
+            }
+            case "getData": {
+                const session = getSession(msg.sessionId);
+                reply(taskId, start, {
+                    data: session.data,
+                    headers: session.headers || [],
+                    rowCount: session.data.length
+                });
+                break;
+            }
+            case "clear": {
+                if (msg.sessionId) {
+                    sessions.delete(msg.sessionId);
+                }
+                else {
+                    sessions.clear();
+                }
+                reply(taskId, start, undefined);
+                break;
+            }
+            case "sort": {
+                const session = getSession(msg.sessionId);
+                sortData(session.data, msg.config);
+                session.originalData = [...session.data];
+                reply(taskId, start, { rowCount: session.data.length });
+                break;
+            }
+            case "filter": {
+                const session = getSession(msg.sessionId);
+                const totalCount = session.originalData.length;
+                session.data = filterData(session.originalData, msg.config);
+                reply(taskId, start, {
+                    data: session.data,
+                    matchCount: session.data.length,
+                    totalCount
+                });
+                break;
+            }
+            case "search": {
+                const session = getSession(msg.sessionId);
+                const totalCount = session.originalData.length;
+                session.data = searchData(session.originalData, msg.config);
+                reply(taskId, start, {
+                    data: session.data,
+                    matchCount: session.data.length,
+                    totalCount
+                });
+                break;
+            }
+            case "groupBy": {
+                const session = getSession(msg.sessionId);
+                const groups = groupByData(session.data, msg.config);
+                reply(taskId, start, { data: groups, groupCount: groups.length });
+                break;
+            }
+            case "aggregate": {
+                const session = getSession(msg.sessionId);
+                reply(taskId, start, { data: aggregateData(session.data, msg.config) });
+                break;
+            }
+            case "getPage": {
+                const session = getSession(msg.sessionId);
+                reply(taskId, start, getPageData(session.data, msg.config));
+                break;
+            }
+            case "query": {
+                const session = getSession(msg.sessionId);
+                reply(taskId, start, executeQuery(session, msg.config));
+                break;
+            }
+            case "terminate": {
+                sessions.clear();
+                break;
+            }
+            default:
+                throw new Error(`Unknown message type: ${msg.type}`);
+        }
+    }
+    catch (error) {
+        replyError(taskId, start, error);
+    }
+};
+// Signal ready
+self.postMessage({ type: "ready" });

package/dist/browser/modules/excel/anchor.d.ts

@@ -1,4 +1,4 @@
-import type { Worksheet } from "@excel/worksheet";
+import type { Worksheet } from "./worksheet.js";
 interface AnchorModel {
     nativeCol: number;
     nativeRow: number;

package/dist/browser/modules/excel/cell.d.ts

@@ -1,10 +1,10 @@
-import type { ValueType, FormulaType } from "@excel/enums";
-import { Note } from "@excel/note";
-import type { Row } from "@excel/row";
-import type { Column } from "@excel/column";
-import type { Worksheet } from "@excel/worksheet";
-import type { Workbook } from "@excel/workbook";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellHyperlinkValue } from "@excel/types";
+import type { ValueType, FormulaType } from "./enums.js";
+import { Note } from "./note.js";
+import type { Row } from "./row.js";
+import type { Column } from "./column.js";
+import type { Worksheet } from "./worksheet.js";
+import type { Workbook } from "./workbook.js";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellHyperlinkValue } from "./types.js";
 export type FormulaResult = string | number | boolean | Date | CellErrorValue;
 export interface FormulaValueData {
     shareType?: string;

package/dist/browser/modules/excel/cell.js

@@ -3,6 +3,7 @@ import { Enums } from "./enums.js";
 import { Note } from "./note.js";
 import { escapeHtml } from "./utils/under-dash.js";
 import { slideFormula } from "./utils/shared-formula.js";
+import { ExcelError, InvalidValueTypeError } from "./errors.js";
 // Returns true if the value is a non-empty object (has at least one own key),
 // or any truthy non-object value. Returns false for undefined, null, false, 0,
 // empty string, and empty objects `{}`. This is used to prevent an empty `{}`
@@ -15,7 +16,7 @@ const hasOwnKeys = (v) => !!v && (typeof v !== "object" || Object.keys(v).length
 class Cell {
     constructor(row, column, address) {
         if (!row || !column) {
-            throw new Error("A Cell needs a Row");
+            throw new ExcelError("A Cell needs a Row");
         }
         this._row = row;
         this._column = column;
@@ -672,7 +673,7 @@ class FormulaValue {
             case Cell.Types.Hyperlink:
             case Cell.Types.Formula:
             default:
-                throw new Error("Cannot process that type of result value");
+                throw new InvalidValueTypeError(String(Value.getType(value)), "Cannot process that type of result value");
         }
     }
     get dependencies() {
@@ -989,7 +990,7 @@ const Value = {
     create(type, cell, value) {
         const T = this.types[type];
         if (!T) {
-            throw new Error(`Could not create Value of type ${type}`);
+            throw new InvalidValueTypeError(String(type), "Could not create Value");
         }
         return new T(cell, value);
     }

package/dist/browser/modules/excel/column.d.ts

@@ -1,6 +1,6 @@
-import type { Cell, CellValueType } from "@excel/cell";
-import type { Worksheet } from "@excel/worksheet";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue } from "@excel/types";
+import type { Cell, CellValueType } from "./cell.js";
+import type { Worksheet } from "./worksheet.js";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue } from "./types.js";
 /** Header value type - can be a single value or array for multi-row headers */
 export type ColumnHeaderValue = CellValue | CellValue[];
 export interface ColumnDefn {

package/dist/browser/modules/excel/defined-names.d.ts

@@ -1,7 +1,7 @@
-import { type DecodedRange } from "@excel/utils/col-cache";
-import { CellMatrix } from "@excel/utils/cell-matrix";
-import { Range } from "@excel/range";
-import type { Address } from "@excel/types";
+import { type DecodedRange } from "./utils/col-cache.js";
+import { CellMatrix } from "./utils/cell-matrix.js";
+import { Range } from "./range.js";
+import type { Address } from "./types.js";
 interface DefinedNameCell {
     sheetName?: string;
     address: string;

package/dist/browser/modules/excel/errors.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Excel module error types.
+ *
+ * All Excel-related errors extend ExcelError.
+ */
+import { BaseError, type BaseErrorOptions } from "../../utils/errors.js";
+/**
+ * Base class for all Excel-related errors.
+ */
+export declare class ExcelError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+/**
+ * Check if an error is an Excel error.
+ */
+export declare function isExcelError(err: unknown): err is ExcelError;
+/**
+ * Error thrown when worksheet name validation fails.
+ */
+export declare class WorksheetNameError extends ExcelError {
+    name: string;
+}
+/**
+ * Error thrown when a cell address or range is invalid.
+ */
+export declare class InvalidAddressError extends ExcelError {
+    readonly address: string;
+    name: string;
+    constructor(address: string, details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when a column number or letter is out of bounds.
+ */
+export declare class ColumnOutOfBoundsError extends ExcelError {
+    readonly column: number | string;
+    name: string;
+    constructor(column: number | string, details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when a row number is out of bounds.
+ */
+export declare class RowOutOfBoundsError extends ExcelError {
+    readonly row: number;
+    name: string;
+    constructor(row: number, details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when trying to merge already merged cells.
+ */
+export declare class MergeConflictError extends ExcelError {
+    name: string;
+    constructor(details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when a value type cannot be processed.
+ */
+export declare class InvalidValueTypeError extends ExcelError {
+    readonly valueType: string;
+    name: string;
+    constructor(valueType: string, details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when XML parsing encounters unexpected content.
+ */
+export declare class XmlParseError extends ExcelError {
+    readonly context: string;
+    name: string;
+    constructor(context: string, details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when an operation is not supported.
+ */
+export declare class ExcelNotSupportedError extends ExcelError {
+    readonly operation: string;
+    readonly reason?: string;
+    name: string;
+    constructor(operation: string, reason?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when a file operation fails.
+ */
+export declare class ExcelFileError extends ExcelError {
+    readonly path: string;
+    readonly operation: "read" | "write";
+    name: string;
+    constructor(path: string, operation: "read" | "write", details?: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when a streaming operation fails due to invalid state.
+ */
+export declare class ExcelStreamStateError extends ExcelError {
+    readonly operation: string;
+    readonly state: string;
+    name: string;
+    constructor(operation: string, state: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when an HTTP download fails.
+ */
+export declare class ExcelDownloadError extends ExcelError {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    name: string;
+    constructor(url: string, status: number, statusText: string, options?: BaseErrorOptions);
+}
+/**
+ * Error thrown when pivot table configuration is invalid.
+ */
+export declare class PivotTableError extends ExcelError {
+    name: string;
+}
+/**
+ * Error thrown when table configuration or operation is invalid.
+ */
+export declare class TableError extends ExcelError {
+    name: string;
+}
+/**
+ * Error thrown when image processing fails.
+ */
+export declare class ImageError extends ExcelError {
+    name: string;
+}
+/**
+ * Error thrown when max items limit is exceeded.
+ */
+export declare class MaxItemsExceededError extends ExcelError {
+    readonly itemType: string;
+    readonly maxItems: number;
+    name: string;
+    constructor(itemType: string, maxItems: number, options?: BaseErrorOptions);
+}