@cj-tech-master/excelts 1.6.3-canary.20251224193747.e89b618 → 1.6.3-canary.20251226035947.ef0b4f2

package/dist/types/doc/worksheet.d.ts

@@ -7,7 +7,7 @@ import { Table, type TableModel } from "./table";
 import { DataValidations } from "./data-validations";
 import { type PivotTable, type PivotTableModel } from "./pivot-table";
 import type { Workbook } from "./workbook";
-import type { AddImageRange, AutoFilter, CellValue, ConditionalFormattingOptions, DataValidation, RowBreak, RowValues, TableProperties, WorksheetProperties, WorksheetView } from "../types";
+import type { AddImageRange, AutoFilter, CellValue, ColBreak, ConditionalFormattingOptions, DataValidation, RowBreak, RowValues, TableProperties, WorksheetProperties, WorksheetView } from "../types";
 type DataValidationModel = {
     [address: string]: DataValidation | undefined;
 };
@@ -96,6 +96,7 @@ interface WorksheetModel {
     pageSetup: PageSetup;
     headerFooter: HeaderFooter;
     rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
     views: Partial<WorksheetView>[];
     autoFilter: AutoFilter | null;
     media: ImageModel[];
@@ -120,6 +121,7 @@ declare class Worksheet {
     private _keys;
     private _merges;
     rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
     properties: Partial<WorksheetProperties>;
     pageSetup: PageSetup;
     headerFooter: HeaderFooter;

package/dist/types/stream/xlsx/workbook-writer.d.ts

@@ -1,5 +1,5 @@
 import fs from "fs";
-import { Zip } from "fflate";
+import { Zip } from "../../utils/zip/streaming-zip";
 import { StreamBuf } from "../../utils/stream-buf";
 import { StylesXform } from "../../xlsx/xform/style/styles-xform";
 import { SharedStrings } from "../../utils/shared-strings";

package/dist/types/stream/xlsx/worksheet-writer.d.ts

@@ -6,7 +6,7 @@ import { SheetRelsWriter } from "./sheet-rels-writer";
 import { SheetCommentsWriter } from "./sheet-comments-writer";
 import { DataValidations } from "../../doc/data-validations";
 import type { StreamBuf } from "../../utils/stream-buf";
-import type { RowBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions } from "../../types";
+import type { RowBreak, ColBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions } from "../../types";
 interface WorksheetWriterOptions {
     id: number;
     name?: string;
@@ -46,6 +46,7 @@ declare class WorksheetWriter {
     _siFormulae: number;
     conditionalFormatting: ConditionalFormattingOptions[];
     rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
     properties: Partial<WorksheetProperties> & {
         defaultRowHeight: number;
         dyDescent: number;
@@ -123,6 +124,7 @@ declare class WorksheetWriter {
     _writeHyperlinks(): void;
     _writeConditionalFormatting(): void;
     _writeRowBreaks(): void;
+    _writeColBreaks(): void;
     _writeDataValidations(): void;
     _writeSheetProtection(): void;
     _writePageMargins(): void;

package/dist/types/types.d.ts

@@ -509,4 +509,10 @@ export interface RowBreak {
     min?: number;
     man: number;
 }
+export interface ColBreak {
+    id: number;
+    max: number;
+    min?: number;
+    man: number;
+}
 export {};

package/dist/types/utils/datetime.d.ts

@@ -0,0 +1,85 @@
+/**
+ * High-performance native date parsing and formatting utilities
+ *
+ * Zero external dependencies. Optimized for CSV batch processing.
+ * Uses character code operations and lookup tables for maximum speed.
+ */
+/** Supported date format strings */
+export type DateFormat = "YYYY-MM-DD[T]HH:mm:ssZ" | "YYYY-MM-DD[T]HH:mm:ss" | "YYYY-MM-DD[T]HH:mm:ss.SSSZ" | "YYYY-MM-DD" | "YYYY-MM-DD HH:mm:ss" | "MM-DD-YYYY" | "MM-DD-YYYY HH:mm:ss" | "MM/DD/YYYY HH:mm:ss" | "DD-MM-YYYY" | "DD-MM-YYYY HH:mm:ss" | "DD/MM/YYYY HH:mm:ss";
+/**
+ * Quick pre-filter to reject non-date strings
+ */
+export declare function mightBeDate(s: string): boolean;
+/**
+ * Parse a date string
+ *
+ * @param value - String to parse
+ * @param formats - Specific formats to try (optional, auto-detects ISO if omitted)
+ * @returns Date object or null
+ *
+ * @example
+ * parseDate("2024-12-26")                    // auto-detect ISO
+ * parseDate("12-26-2024", ["MM-DD-YYYY"])   // explicit US format
+ */
+export declare function parseDate(value: string, formats?: DateFormat[]): Date | null;
+/**
+ * Format a Date to string
+ *
+ * @param date - Date to format
+ * @param format - Format template (optional, defaults to ISO)
+ * @param utc - Use UTC time (default: false)
+ * @returns Formatted string or empty string if invalid
+ *
+ * @example
+ * formatDate(date)                        // "2024-12-26T10:30:00.000+08:00"
+ * formatDate(date, "YYYY-MM-DD", true)   // "2024-12-26"
+ */
+export declare function formatDate(date: Date, format?: string, utc?: boolean): string;
+/**
+ * Optimized date parser for batch processing
+ *
+ * @example
+ * const parser = DateParser.create(["YYYY-MM-DD"]);
+ * const dates = parser.parseAll(csvStrings);
+ */
+export declare class DateParser {
+    private readonly fns;
+    private readonly single;
+    private readonly fn0;
+    private constructor();
+    /** Create parser for specific formats */
+    static create(formats: readonly DateFormat[]): DateParser;
+    /** Create parser for auto-detecting ISO formats */
+    static iso(): DateParser;
+    /** Parse single value */
+    parse: (value: string) => Date | null;
+    /** Parse array of values */
+    parseAll(values: string[]): (Date | null)[];
+    /** Parse and filter valid dates */
+    parseValid(values: string[]): Date[];
+}
+/**
+ * Optimized date formatter for batch processing
+ *
+ * @example
+ * const formatter = DateFormatter.create("YYYY-MM-DD", { utc: true });
+ * const strings = formatter.formatAll(dates);
+ */
+export declare class DateFormatter {
+    private readonly fn;
+    private constructor();
+    /** Create ISO formatter (fastest) */
+    static iso(utc?: boolean): DateFormatter;
+    /** Create custom format formatter */
+    static create(format: string, options?: {
+        utc?: boolean;
+    }): DateFormatter;
+    /** Generic formatter for arbitrary formats */
+    private static createGeneric;
+    /** Format single date */
+    format: (date: Date) => string;
+    /** Format array of dates */
+    formatAll(dates: Date[]): string[];
+}
+/** Get supported format strings */
+export declare function getSupportedFormats(): DateFormat[];

package/dist/types/utils/parse-sax.d.ts

@@ -1,6 +1,113 @@
-interface SaxEvent {
+/**
+ * High-performance SAX XML parser
+ *
+ * Minimal implementation optimized for Excel XML parsing.
+ * Supports: opentag, text, closetag, error events.
+ * Zero external dependencies.
+ *
+ * Based on XML 1.0 specification with optimizations for common Excel XML patterns.
+ */
+export interface SaxEvent {
     eventType: "opentag" | "text" | "closetag";
     value: any;
 }
+export interface SaxesTagPlain {
+    name: string;
+    attributes: Record<string, string>;
+    isSelfClosing: boolean;
+}
+export interface SaxesOptions {
+    xmlns?: boolean;
+    position?: boolean;
+    fileName?: string;
+    fragment?: boolean;
+}
+type TextHandler = (text: string) => void;
+type OpenTagHandler = (tag: SaxesTagPlain) => void;
+type CloseTagHandler = (tag: SaxesTagPlain) => void;
+type ErrorHandler = (err: Error) => void;
+export declare class SaxesParser {
+    private trackPosition;
+    private fileName?;
+    private fragment;
+    private state;
+    private chunk;
+    private i;
+    private prevI;
+    private text;
+    private name;
+    private q;
+    private tags;
+    private tag;
+    private attribList;
+    private entity;
+    private entityReturnState;
+    private openWakaBang;
+    private sawRoot;
+    private closedRoot;
+    private carriedFromPrevious?;
+    private _closed;
+    private reportedTextBeforeRoot;
+    private reportedTextAfterRoot;
+    line: number;
+    column: number;
+    private positionAtNewLine;
+    private chunkPosition;
+    ENTITIES: Record<string, string>;
+    private textHandler?;
+    private openTagHandler?;
+    private closeTagHandler?;
+    private errorHandler?;
+    constructor(opt?: SaxesOptions);
+    get closed(): boolean;
+    get position(): number;
+    private _init;
+    on(name: "text", handler: TextHandler): void;
+    on(name: "opentag", handler: OpenTagHandler): void;
+    on(name: "closetag", handler: CloseTagHandler): void;
+    on(name: "error", handler: ErrorHandler): void;
+    off(name: string): void;
+    private makeError;
+    fail(message: string): this;
+    write(chunk: string | null): this;
+    close(): this;
+    private getCode;
+    private unget;
+    private processState;
+    private sText;
+    private handleTextInRoot;
+    private handleTextOutsideRoot;
+    private sOpenWaka;
+    private sOpenWakaBang;
+    private sOpenTag;
+    private sOpenTagSlash;
+    private sAttrib;
+    private sAttribName;
+    private sAttribNameSawWhite;
+    private sAttribValue;
+    private sAttribValueQuoted;
+    private sAttribValueClosed;
+    private sCloseTag;
+    private sCloseTagSawWhite;
+    private sComment;
+    private sCommentEnding;
+    private sCommentEnded;
+    private sCData;
+    private sCDataEnding;
+    private sCDataEnding2;
+    private sPI;
+    private sPIEnding;
+    private sDoctype;
+    private sDoctypeQuote;
+    private sDoctypeDTD;
+    private sDoctypeDTDQuoted;
+    private sEntity;
+    private parseEntity;
+    private skipSpaces;
+    private openTag;
+    private openSelfClosingTag;
+    private closeTag;
+    private end;
+}
 declare function parseSax(iterable: any): AsyncGenerator<SaxEvent[]>;
 export { parseSax };

package/dist/types/utils/unzip/zip-parser.d.ts

@@ -85,6 +85,11 @@ export declare class ZipParser {
      * Extract all files (async)
      */
     extractAll(): Promise<Map<string, Uint8Array>>;
+    /**
+     * Extract all files (sync, Node.js only)
+     * Returns object with file paths as keys and Uint8Array content as values
+     */
+    extractAllSync(): Record<string, Uint8Array>;
     /**
      * Iterate over entries with async callback
      */

package/dist/types/utils/zip/compress.base.d.ts

@@ -4,6 +4,9 @@
  *
  * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
  * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ *
+ * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
+ * see deflate-fallback.ts for pure JS implementation
  */
 /**
  * Compression options

package/dist/types/utils/zip/compress.browser.d.ts

@@ -1,17 +1,28 @@
 /**
- * Browser compression utilities using Web Streams API
+ * Browser compression utilities
  *
- * Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
- * with "deflate-raw" format (required for ZIP files)
+ * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
+ * Fallback: Pure JS DEFLATE implementation for older browsers
+ *
+ * Supported browsers with fallback:
+ * - Chrome >= 85
+ * - Firefox >= 79
+ * - Safari >= 14
+ * - Edge >= 85
+ */
+import { type CompressOptions } from "./compress.base";
+export { type CompressOptions };
+/**
+ * Check if CompressionStream with "deflate-raw" is available
+ * Note: Chrome 80-102 has CompressionStream but not deflate-raw support
  */
-import { type CompressOptions, hasCompressionStream } from "./compress.base";
-export { type CompressOptions, hasCompressionStream };
+export declare function hasCompressionStream(): boolean;
 /**
  * Check if native zlib is available (always false in browser)
  */
 export declare function hasNativeZlib(): boolean;
 /**
- * Compress data using browser's native CompressionStream
+ * Compress data using browser's native CompressionStream or JS fallback
  *
  * @param data - Data to compress
  * @param options - Compression options
@@ -27,28 +38,26 @@ export declare function compress(data: Uint8Array, options?: {
     level?: number;
 }): Promise<Uint8Array>;
 /**
- * Compress data synchronously
- * Not available in browser - throws error
+ * Compress data synchronously using pure JS implementation
  *
- * @param _data - Data to compress
- * @param _options - Compression options
- * @throws Error always - sync compression not available in browser
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
  */
-export declare function compressSync(_data: Uint8Array, _options?: {
+export declare function compressSync(data: Uint8Array, options?: {
     level?: number;
 }): Uint8Array;
 /**
- * Decompress data using browser's native DecompressionStream
+ * Decompress data using browser's native DecompressionStream or JS fallback
  *
  * @param data - Compressed data (deflate-raw format)
  * @returns Decompressed data
  */
 export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
 /**
- * Decompress data synchronously
- * Not available in browser - throws error
+ * Decompress data synchronously using pure JS implementation
  *
- * @param _data - Compressed data
- * @throws Error always - sync decompression not available in browser
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
  */
-export declare function decompressSync(_data: Uint8Array): Uint8Array;
+export declare function decompressSync(data: Uint8Array): Uint8Array;

package/dist/types/utils/zip/deflate-fallback.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pure JavaScript DEFLATE implementation for browsers without CompressionStream support
+ *
+ * This fallback supports:
+ * - Decompression: Full DEFLATE decompression (RFC 1951)
+ * - Compression: STORE mode only (no compression, but valid DEFLATE format)
+ *
+ * Used automatically when CompressionStream with "deflate-raw" is unavailable:
+ * - Firefox < 113
+ * - Safari < 16.4
+ * - Chrome < 103
+ */
+/**
+ * Decompress DEFLATE data (raw format, no zlib header)
+ *
+ * @param data - Compressed data in deflate-raw format
+ * @returns Decompressed data
+ */
+export declare function inflateRaw(data: Uint8Array): Uint8Array;
+/**
+ * Compress data using DEFLATE STORE mode (no compression)
+ *
+ * This creates valid DEFLATE data but without actual compression.
+ * Files will be larger but this works on all browsers.
+ *
+ * @param data - Data to "compress"
+ * @returns DEFLATE-formatted data (stored, not compressed)
+ */
+export declare function deflateRawStore(data: Uint8Array): Uint8Array;
+/**
+ * Compress data using DEFLATE with fixed Huffman codes
+ *
+ * This provides real compression using LZ77 + fixed Huffman codes.
+ * Not as efficient as full DEFLATE but much better than STORE mode.
+ *
+ * @param data - Data to compress
+ * @returns Compressed data in deflate-raw format
+ */
+export declare function deflateRawCompressed(data: Uint8Array): Uint8Array;

package/dist/types/utils/zip/streaming-zip.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Streaming ZIP creator - fflate-compatible API
+ *
+ * This module provides a streaming ZIP API compatible with fflate's Zip/ZipDeflate,
+ * but uses native zlib compression for better performance.
+ *
+ * Usage:
+ * ```ts
+ * const zip = new StreamingZip((err, data, final) => {
+ *   if (err) handleError(err);
+ *   else {
+ *     stream.write(data);
+ *     if (final) stream.end();
+ *   }
+ * });
+ *
+ * const file = new ZipDeflateFile("path/file.txt", { level: 6 });
+ * zip.add(file);
+ * file.push(data1);
+ * file.push(data2, true); // true = final chunk
+ *
+ * zip.end();
+ * ```
+ */
+/**
+ * Internal entry info for central directory
+ */
+interface ZipEntryInfo {
+    name: Uint8Array;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    offset: number;
+}
+/**
+ * ZipDeflate-compatible file stream
+ * Collects data chunks, compresses on finalization
+ */
+export declare class ZipDeflateFile {
+    private chunks;
+    private totalSize;
+    private finalized;
+    private _ondata;
+    readonly name: string;
+    readonly level: number;
+    constructor(name: string, options?: {
+        level?: number;
+    });
+    /**
+     * Set data callback (called by StreamingZip)
+     */
+    set ondata(cb: (data: Uint8Array, final: boolean) => void);
+    /**
+     * Push data to the file
+     * @param data - Data chunk
+     * @param final - Whether this is the final chunk
+     */
+    push(data: Uint8Array, final?: boolean): void;
+    /**
+     * Flush collected data through compression and emit
+     */
+    private _flush;
+    /**
+     * Get entry info (called by StreamingZip after finalization)
+     */
+    getEntryInfo(): ZipEntryInfo | null;
+}
+/**
+ * Streaming ZIP - fflate Zip-compatible API
+ * Creates ZIP files in a streaming manner
+ */
+export declare class StreamingZip {
+    private callback;
+    private entries;
+    private currentOffset;
+    private ended;
+    /**
+     * Create a streaming ZIP
+     * @param callback - Called with (err, data, final) as data becomes available
+     */
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
+    /**
+     * Add a file to the ZIP
+     * @param file - ZipDeflateFile instance
+     */
+    add(file: ZipDeflateFile): void;
+    /**
+     * Finalize the ZIP
+     * Writes central directory and end-of-central-directory record
+     */
+    end(): void;
+}
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };

package/dist/types/xlsx/xform/sheet/col-breaks-xform.d.ts

@@ -0,0 +1,16 @@
+import { ListXform } from "../list-xform";
+/**
+ * Xform for column page breaks (colBreaks element in worksheet XML)
+ * Used to define manual page breaks between columns when printing.
+ *
+ * XML structure:
+ * <colBreaks count="3" manualBreakCount="3">
+ *   <brk id="3" max="1048575" man="1"/>
+ *   <brk id="6" max="1048575" man="1"/>
+ * </colBreaks>
+ */
+declare class ColBreaksXform extends ListXform {
+    constructor();
+    render(xmlStream: any, model: any): void;
+}
+export { ColBreaksXform };

package/dist/types/xlsx/xform/sheet/page-breaks-xform.d.ts

@@ -1,4 +1,8 @@
 import { BaseXform } from "../base-xform";
+/**
+ * Xform for individual page break (brk element)
+ * Used by both RowBreaksXform and ColBreaksXform
+ */
 declare class PageBreaksXform extends BaseXform {
     model: any;
     get tag(): string;

package/dist/types/xlsx/xform/sheet/row-breaks-xform.d.ts

@@ -1,4 +1,8 @@
 import { ListXform } from "../list-xform";
+/**
+ * Xform for row page breaks (rowBreaks element in worksheet XML)
+ * Used to define manual page breaks between rows when printing.
+ */
 declare class RowBreaksXform extends ListXform {
     constructor();
     render(xmlStream: any, model: any): void;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "1.6.3-canary.20251224193747.e89b618",
+  "version": "1.6.3-canary.20251226035947.ef0b4f2",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
-  "private": false,
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
@@ -26,15 +26,14 @@
   "bugs": {
     "url": "https://github.com/cjnoname/excelts/issues"
   },
-  "type": "module",
   "engines": {
     "node": ">=20.0.0"
   },
   "browserslist": [
     "chrome >= 85",
     "edge >= 85",
-    "firefox >= 113",
-    "safari >= 16.4",
+    "firefox >= 79",
+    "safari >= 14",
     "opera >= 71"
   ],
   "exports": {
@@ -50,13 +49,7 @@
       "require": {
         "types": "./dist/types/index.d.ts",
         "default": "./dist/cjs/index.js"
-      },
-      "default": "./dist/esm/index.js"
-    },
-    "./browser": {
-      "types": "./dist/types/index.browser.d.ts",
-      "import": "./dist/browser/excelts.esm.js",
-      "default": "./dist/browser/excelts.esm.js"
+      }
     },
     "./package.json": "./package.json"
   },
@@ -97,18 +90,12 @@
     "esm",
     "xlsx"
   ],
-  "dependencies": {
-    "dayjs": "^1.11.19",
-    "fflate": "^0.8.2",
-    "saxes": "^6.0.0"
-  },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@oxc-node/core": "^0.0.35",
     "@types/node": "^25.0.3",
     "@typescript-eslint/eslint-plugin": "^8.50.1",
     "@typescript-eslint/parser": "^8.50.1",
-    "@typescript/native-preview": "^7.0.0-dev.20251223.1",
+    "@typescript/native-preview": "^7.0.0-dev.20251225.1",
     "@vitest/browser": "^4.0.16",
     "@vitest/browser-playwright": "^4.0.16",
     "@vitest/ui": "^4.0.16",
@@ -120,26 +107,19 @@
     "eslint-plugin-import-x": "^4.16.1",
     "eslint-plugin-oxlint": "^1.35.0",
     "eslint-plugin-unused-imports": "^4.3.0",
-    "express": "^5.2.1",
-    "fast-xml-parser": "^5.3.3",
     "husky": "^9.1.7",
-    "node-stdlib-browser": "^1.3.1",
-    "nodemon": "^3.1.11",
     "oxlint": "^1.35.0",
     "playwright": "^1.57.0",
     "prettier": "^3.7.4",
     "rimraf": "^6.1.2",
     "rolldown": "^1.0.0-beta.57",
-    "rollup-plugin-visualizer": "^6.0.5",
-    "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.50.1",
     "vite-tsconfig-paths": "^6.0.3",
     "vitest": "^4.0.16"
   },
   "scripts": {
-    "local": "nodemon src/local.ts",
-    "example": "nodemon scripts/run-examples.ts",
+    "example": "node scripts/run-examples.ts",
     "check": "concurrently --raw \"npm run type\" \"npm run lint\"",
     "test": "vitest run && npm run test:browser",
     "test:browser": "rimraf dist && npm run build:browser && vitest run --config vitest.browser.config.ts",
@@ -154,7 +134,6 @@
     "build:esm": "tsc --project tsconfig.esm.json && node scripts/fix-esm-imports.mjs",
     "build:cjs": "tsc --project tsconfig.cjs.json && node scripts/fix-cjs-imports.mjs",
     "build:browser": "rolldown -c rolldown.config.js",
-    "analyze": "cross-env ANALYZE=1 rolldown -c rolldown.config.js",
     "preversion": "npm run lint && npm run type && npm run build && npm run test"
   }
 }