@cj-tech-master/excelts 4.2.3-canary.20260115111903.b80904d → 4.2.3-canary.20260122073152.a9bb6b0

package/dist/types/modules/csv/csv-core.d.ts

@@ -58,15 +58,6 @@ export interface CsvParseOptions {
     renameHeaders?: boolean;
     /** Comment character - lines starting with this are ignored */
     comment?: string;
-    /**
-     * Decimal separator used when parsing numbers from CSV (default: ".").
-     *
-     * Note: core CSV parsing returns strings; number conversion is handled by higher-level
-     * consumers (e.g. the default value mapper in the CSV module).
-     *
-     * @deprecated Use CsvReadOptions.valueMapperOptions.decimalSeparator instead.
-     */
-    decimalSeparator?: "." | ",";
     /** Maximum number of data rows to parse (excluding header) */
     maxRows?: number;
     /** Number of lines to skip at the beginning (before header detection) */

package/dist/types/modules/excel/utils/passthrough-manager.d.ts

@@ -0,0 +1,77 @@
+/**
+ * PassthroughManager - Manages passthrough files for round-trip preservation
+ *
+ * This module handles files that are not fully parsed by the library but need to be
+ * preserved during read/write cycles (e.g., charts, sparklines, slicers).
+ */
+/**
+ * Content type entry for ZIP content types
+ */
+export interface PassthroughContentType {
+    partName: string;
+    contentType: string;
+}
+/**
+ * ZIP writer interface for passthrough files
+ */
+export interface IPassthroughZipWriter {
+    append(data: Uint8Array, options: {
+        name: string;
+    }): void;
+}
+/**
+ * PassthroughManager handles storage and retrieval of passthrough files
+ * that need to be preserved during Excel read/write cycles.
+ */
+export declare class PassthroughManager {
+    private files;
+    /**
+     * Check if a path should be treated as passthrough
+     */
+    static isPassthroughPath(path: string): boolean;
+    /**
+     * Get the content type for a passthrough file path
+     * @returns Content type string or undefined if unknown
+     */
+    static getContentType(path: string): string | undefined;
+    /**
+     * Add a file to passthrough storage
+     */
+    add(path: string, data: Uint8Array): void;
+    /**
+     * Get a file from passthrough storage
+     */
+    get(path: string): Uint8Array | undefined;
+    /**
+     * Check if a file exists in passthrough storage
+     */
+    has(path: string): boolean;
+    /**
+     * Get all stored paths
+     */
+    getPaths(): string[];
+    /**
+     * Get all files as a record (for serialization)
+     */
+    toRecord(): Record<string, Uint8Array>;
+    /**
+     * Load files from a record (for deserialization)
+     */
+    fromRecord(record: Record<string, Uint8Array>): void;
+    /**
+     * Get content types for all stored files that have known types
+     */
+    getContentTypes(): PassthroughContentType[];
+    /**
+     * Write all passthrough files to a ZIP writer
+     */
+    writeToZip(zip: IPassthroughZipWriter): void;
+    /**
+     * Clear all stored files
+     */
+    clear(): void;
+    /**
+     * Get the number of stored files
+     */
+    get size(): number;
+}

package/dist/types/modules/excel/workbook.d.ts

@@ -55,6 +55,10 @@ export interface WorkbookModel {
     /** Loaded pivot tables from file - used during reconciliation */
     loadedPivotTables?: any[];
     calcProperties: Partial<CalculationProperties>;
+    /** Passthrough files (charts, etc.) preserved for round-trip */
+    passthrough?: Record<string, Uint8Array>;
+    /** Raw drawing XML data for passthrough (when drawing contains chart references) */
+    rawDrawings?: Record<string, Uint8Array>;
 }
 declare class Workbook {
     /**
@@ -94,6 +98,10 @@ declare class Workbook {
     private _worksheets;
     private _definedNames;
     private _themes?;
+    /** Passthrough files (charts, etc.) preserved for round-trip */
+    private _passthrough;
+    /** Raw drawing XML data for passthrough (when drawing contains chart references) */
+    private _rawDrawings;
     private _xlsx?;
     private _csv?;
     constructor();

package/dist/types/modules/excel/worksheet.d.ts

@@ -111,6 +111,8 @@ interface WorksheetModel {
     dimensions?: Range;
     merges?: string[];
     mergeCells?: string[];
+    /** Loaded drawing data (for charts, etc.) - preserved for round-trip */
+    drawing?: any;
 }
 declare class Worksheet {
     private _workbook;
@@ -139,6 +141,8 @@ declare class Worksheet {
     conditionalFormattings: ConditionalFormattingOptions[];
     formControls: FormCheckbox[];
     private _headerRowCount?;
+    /** Loaded drawing data (for charts, etc.) - preserved for round-trip */
+    private _drawing;
     constructor(options: WorksheetOptions);
     get name(): string;
     set name(name: string | undefined);

package/dist/types/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.d.ts

@@ -67,26 +67,45 @@ interface ParsedPivotTableModel {
     compact?: boolean;
     compactData?: boolean;
     multipleFieldFilters?: boolean;
-    rowItems?: any[];
-    colItems?: any[];
+    outline?: boolean;
+    outlineData?: boolean;
+    chartFormat?: number;
+    rowItems?: RowColItem[];
+    colItems?: RowColItem[];
+    chartFormats?: ChartFormatItem[];
     isLoaded?: boolean;
     extensions?: any[];
 }
+/**
+ * Row or column item in pivot table
+ */
+interface RowColItem {
+    t?: string;
+    x: Array<{
+        v: number;
+    }>;
+}
+/**
+ * Chart format item for pivot charts
+ */
+interface ChartFormatItem {
+    chart: number;
+    format: number;
+    series?: boolean;
+    pivotAreaXml?: string;
+}
 declare class PivotTableXform extends BaseXform {
     map: {
         [key: string]: any;
     };
     model: ParsedPivotTableModel | null;
-    private inPivotFields;
-    private inRowFields;
-    private inColFields;
-    private inDataFields;
-    private inRowItems;
-    private inColItems;
-    private inLocation;
+    private state;
     private currentPivotField;
-    private inItems;
-    private inPivotTableStyleInfo;
+    private currentRowItem;
+    private currentColItem;
+    private currentChartFormat;
+    private pivotAreaXmlBuffer;
+    private pivotAreaDepth;
     constructor();
     prepare(_model: any): void;
     get tag(): string;
@@ -104,6 +123,10 @@ declare class PivotTableXform extends BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     private renderLoaded;
+    /**
+     * Render a row or column item element
+     */
+    private renderRowColItem;
     /**
      * Render a loaded pivot field
      */

package/dist/types/modules/excel/xlsx/xlsx.browser.d.ts

@@ -144,6 +144,30 @@ declare class XLSX {
      * This is the foundation for TRUE streaming reads on platforms that have a
      * streaming ZIP parser (e.g. Node.js `modules/archive` Parse).
      */
+    /**
+     * Create an empty model for parsing XLSX files.
+     * Shared by loadFromZipEntries and loadFromFiles.
+     */
+    private createEmptyModel;
+    /**
+     * Collect all data from a stream into a single Uint8Array.
+     * Reusable helper for passthrough and drawing processing.
+     */
+    protected collectStreamData(stream: IParseStream): Promise<Uint8Array>;
+    /**
+     * Check if a drawing has chart references in its relationships
+     */
+    private drawingHasChartReference;
+    /**
+     * Check if a drawing rels list references charts.
+     * Used to decide whether we need to keep raw drawing XML for passthrough.
+     */
+    private drawingRelsHasChartReference;
+    /**
+     * Process a known OOXML entry (workbook, styles, shared strings, etc.)
+     * Returns true if handled, false if should be passed to _processDefaultEntry
+     */
+    protected _processKnownEntry(stream: IParseStream, model: any, entryName: string, options?: XlsxOptions): Promise<boolean>;
     protected loadFromZipEntries(entries: AsyncIterable<ZipEntryLike>, options?: XlsxOptions): Promise<any>;
     /**
      * Write workbook to buffer
@@ -189,8 +213,14 @@ declare class XLSX {
     loadFromFiles(zipData: Record<string, Uint8Array>, options?: any): Promise<any>;
     /**
      * Process default entries (drawings, comments, tables, etc.)
+     * @param rawData Optional raw entry data for passthrough preservation (used by loadFromFiles)
      */
-    protected _processDefaultEntry(stream: IParseStream, model: any, entryName: string): Promise<boolean>;
+    protected _processDefaultEntry(stream: IParseStream, model: any, entryName: string, rawData?: Uint8Array): Promise<boolean>;
+    /**
+     * Store a passthrough file for preservation during read/write cycles.
+     * These files are not parsed but stored as raw bytes to be written back unchanged.
+     */
+    _processPassthroughEntry(stream: IParseStream, model: any, entryName: string): Promise<void>;
     addContentTypes(zip: IZipWriter, model: any): Promise<void>;
     addApp(zip: IZipWriter, model: any): Promise<void>;
     addCore(zip: IZipWriter, model: any): Promise<void>;
@@ -204,6 +234,11 @@ declare class XLSX {
     addWorksheets(zip: IZipWriter, model: any): Promise<void>;
     addDrawings(zip: IZipWriter, model: any): void;
     addTables(zip: IZipWriter, model: any): void;
+    /**
+     * Write passthrough files (charts, etc.) that were preserved during read.
+     * These files are written back unchanged to preserve unsupported features.
+     */
+    addPassthrough(zip: IZipWriter, model: any): void;
     addPivotTables(zip: IZipWriter, model: any): void;
     _finalize(zip: IZipWriter): Promise<this>;
     prepareModel(model: any, options: any): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "4.2.3-canary.20260115111903.b80904d",
+  "version": "4.2.3-canary.20260122073152.a9bb6b0",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "publishConfig": {
@@ -120,7 +120,7 @@
   "scripts": {
     "example": "node scripts/run-examples.ts",
     "check": "concurrently --raw \"npm run type\" \"npm run lint\"",
-    "test": "vitest run && npm run test:browser",
+    "test": "vitest run && npm run test:browser --",
     "test:browser": "rimraf dist && npm run build:browser:bundle && vitest run --config vitest.browser.config.ts",
     "test:watch": "vitest",
     "build": "rimraf dist && concurrently \"npm run build:esm\" \"npm run build:cjs\" \"npm run build:browser\" \"npm run build:browser:bundle\" && npm run build:verify",