@niicojs/excel 0.3.0 → 0.3.1

package/src/range.ts

@@ -1,154 +1,154 @@
-import type { CellValue, CellStyle, RangeAddress } from './types';
-import type { Worksheet } from './worksheet';
-import { toAddress, normalizeRange } from './utils/address';
-
-/**
- * Represents a range of cells in a worksheet
- */
-export class Range {
-  private _worksheet: Worksheet;
-  private _range: RangeAddress;
-
-  constructor(worksheet: Worksheet, range: RangeAddress) {
-    this._worksheet = worksheet;
-    this._range = normalizeRange(range);
-  }
-
-  /**
-   * Get the range address as a string
-   */
-  get address(): string {
-    const start = toAddress(this._range.start.row, this._range.start.col);
-    const end = toAddress(this._range.end.row, this._range.end.col);
-    if (start === end) return start;
-    return `${start}:${end}`;
-  }
-
-  /**
-   * Get the number of rows in the range
-   */
-  get rowCount(): number {
-    return this._range.end.row - this._range.start.row + 1;
-  }
-
-  /**
-   * Get the number of columns in the range
-   */
-  get colCount(): number {
-    return this._range.end.col - this._range.start.col + 1;
-  }
-
-  /**
-   * Get all values in the range as a 2D array
-   */
-  get values(): CellValue[][] {
-    return this.getValues();
-  }
-
-  /**
-   * Get all values in the range as a 2D array with options
-   */
-  getValues(options: { createMissing?: boolean } = {}): CellValue[][] {
-    const { createMissing = true } = options;
-    const result: CellValue[][] = [];
-    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
-      const row: CellValue[] = [];
-      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
-        if (createMissing) {
-          const cell = this._worksheet.cell(r, c);
-          row.push(cell.value);
-        } else {
-          const cell = this._worksheet.getCellIfExists(r, c);
-          row.push(cell?.value ?? null);
-        }
-      }
-      result.push(row);
-    }
-    return result;
-  }
-
-  /**
-   * Set values in the range from a 2D array
-   */
-  set values(data: CellValue[][]) {
-    for (let r = 0; r < data.length && r < this.rowCount; r++) {
-      const row = data[r];
-      for (let c = 0; c < row.length && c < this.colCount; c++) {
-        const cell = this._worksheet.cell(this._range.start.row + r, this._range.start.col + c);
-        cell.value = row[c];
-      }
-    }
-  }
-
-  /**
-   * Get all formulas in the range as a 2D array
-   */
-  get formulas(): (string | undefined)[][] {
-    const result: (string | undefined)[][] = [];
-    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
-      const row: (string | undefined)[] = [];
-      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
-        const cell = this._worksheet.cell(r, c);
-        row.push(cell.formula);
-      }
-      result.push(row);
-    }
-    return result;
-  }
-
-  /**
-   * Set formulas in the range from a 2D array
-   */
-  set formulas(data: (string | undefined)[][]) {
-    for (let r = 0; r < data.length && r < this.rowCount; r++) {
-      const row = data[r];
-      for (let c = 0; c < row.length && c < this.colCount; c++) {
-        const cell = this._worksheet.cell(this._range.start.row + r, this._range.start.col + c);
-        cell.formula = row[c];
-      }
-    }
-  }
-
-  /**
-   * Get the style of the top-left cell
-   */
-  get style(): CellStyle {
-    return this._worksheet.cell(this._range.start.row, this._range.start.col).style;
-  }
-
-  /**
-   * Set style for all cells in the range
-   */
-  set style(style: CellStyle) {
-    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
-      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
-        const cell = this._worksheet.cell(r, c);
-        cell.style = style;
-      }
-    }
-  }
-
-  /**
-   * Iterate over all cells in the range
-   */
-  *[Symbol.iterator]() {
-    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
-      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
-        yield this._worksheet.cell(r, c);
-      }
-    }
-  }
-
-  /**
-   * Iterate over cells row by row
-   */
-  *rows() {
-    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
-      const row = [];
-      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
-        row.push(this._worksheet.cell(r, c));
-      }
-      yield row;
-    }
-  }
-}
+import type { CellValue, CellStyle, RangeAddress } from './types';
+import type { Worksheet } from './worksheet';
+import { toAddress, normalizeRange } from './utils/address';
+
+/**
+ * Represents a range of cells in a worksheet
+ */
+export class Range {
+  private _worksheet: Worksheet;
+  private _range: RangeAddress;
+
+  constructor(worksheet: Worksheet, range: RangeAddress) {
+    this._worksheet = worksheet;
+    this._range = normalizeRange(range);
+  }
+
+  /**
+   * Get the range address as a string
+   */
+  get address(): string {
+    const start = toAddress(this._range.start.row, this._range.start.col);
+    const end = toAddress(this._range.end.row, this._range.end.col);
+    if (start === end) return start;
+    return `${start}:${end}`;
+  }
+
+  /**
+   * Get the number of rows in the range
+   */
+  get rowCount(): number {
+    return this._range.end.row - this._range.start.row + 1;
+  }
+
+  /**
+   * Get the number of columns in the range
+   */
+  get colCount(): number {
+    return this._range.end.col - this._range.start.col + 1;
+  }
+
+  /**
+   * Get all values in the range as a 2D array
+   */
+  get values(): CellValue[][] {
+    return this.getValues();
+  }
+
+  /**
+   * Get all values in the range as a 2D array with options
+   */
+  getValues(options: { createMissing?: boolean } = {}): CellValue[][] {
+    const { createMissing = true } = options;
+    const result: CellValue[][] = [];
+    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
+      const row: CellValue[] = [];
+      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
+        if (createMissing) {
+          const cell = this._worksheet.cell(r, c);
+          row.push(cell.value);
+        } else {
+          const cell = this._worksheet.getCellIfExists(r, c);
+          row.push(cell?.value ?? null);
+        }
+      }
+      result.push(row);
+    }
+    return result;
+  }
+
+  /**
+   * Set values in the range from a 2D array
+   */
+  set values(data: CellValue[][]) {
+    for (let r = 0; r < data.length && r < this.rowCount; r++) {
+      const row = data[r];
+      for (let c = 0; c < row.length && c < this.colCount; c++) {
+        const cell = this._worksheet.cell(this._range.start.row + r, this._range.start.col + c);
+        cell.value = row[c];
+      }
+    }
+  }
+
+  /**
+   * Get all formulas in the range as a 2D array
+   */
+  get formulas(): (string | undefined)[][] {
+    const result: (string | undefined)[][] = [];
+    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
+      const row: (string | undefined)[] = [];
+      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
+        const cell = this._worksheet.cell(r, c);
+        row.push(cell.formula);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+
+  /**
+   * Set formulas in the range from a 2D array
+   */
+  set formulas(data: (string | undefined)[][]) {
+    for (let r = 0; r < data.length && r < this.rowCount; r++) {
+      const row = data[r];
+      for (let c = 0; c < row.length && c < this.colCount; c++) {
+        const cell = this._worksheet.cell(this._range.start.row + r, this._range.start.col + c);
+        cell.formula = row[c];
+      }
+    }
+  }
+
+  /**
+   * Get the style of the top-left cell
+   */
+  get style(): CellStyle {
+    return this._worksheet.cell(this._range.start.row, this._range.start.col).style;
+  }
+
+  /**
+   * Set style for all cells in the range
+   */
+  set style(style: CellStyle) {
+    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
+      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
+        const cell = this._worksheet.cell(r, c);
+        cell.style = style;
+      }
+    }
+  }
+
+  /**
+   * Iterate over all cells in the range
+   */
+  *[Symbol.iterator]() {
+    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
+      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
+        yield this._worksheet.cell(r, c);
+      }
+    }
+  }
+
+  /**
+   * Iterate over cells row by row
+   */
+  *rows() {
+    for (let r = this._range.start.row; r <= this._range.end.row; r++) {
+      const row = [];
+      for (let c = this._range.start.col; c <= this._range.end.col; c++) {
+        row.push(this._worksheet.cell(r, c));
+      }
+      yield row;
+    }
+  }
+}

package/src/shared-strings.ts

@@ -1,178 +1,178 @@
-import {
-  parseXml,
-  findElement,
-  getChildren,
-  getAttr,
-  XmlNode,
-  stringifyXml,
-  createElement,
-  createText,
-} from './utils/xml';
-
-/**
- * Manages the shared strings table from xl/sharedStrings.xml
- * Excel stores strings in a shared table to reduce file size
- */
-export class SharedStrings {
-  private entries: SharedStringEntry[] = [];
-  private stringToIndex: Map<string, number> = new Map();
-  private _dirty = false;
-  private _totalCount = 0;
-
-  /**
-   * Parse shared strings from XML content
-   */
-  static parse(xml: string): SharedStrings {
-    const ss = new SharedStrings();
-    const parsed = parseXml(xml);
-    const sst = findElement(parsed, 'sst');
-    if (!sst) return ss;
-
-    const countAttr = getAttr(sst, 'count');
-    if (countAttr) {
-      const total = parseInt(countAttr, 10);
-      if (Number.isFinite(total) && total >= 0) {
-        ss._totalCount = total;
-      }
-    }
-
-    const children = getChildren(sst, 'sst');
-    for (const child of children) {
-      if ('si' in child) {
-        const siChildren = getChildren(child, 'si');
-        const text = ss.extractText(siChildren);
-        ss.entries.push({ text, node: child });
-        ss.stringToIndex.set(text, ss.entries.length - 1);
-      }
-    }
-
-    if (ss._totalCount === 0 && ss.entries.length > 0) {
-      ss._totalCount = ss.entries.length;
-    }
-
-    return ss;
-  }
-
-  /**
-   * Extract text from a string item (si element)
-   * Handles both simple <t> elements and rich text <r> elements
-   */
-  private extractText(nodes: XmlNode[]): string {
-    let text = '';
-    for (const node of nodes) {
-      if ('t' in node) {
-        // Simple text: <t>value</t>
-        const tChildren = getChildren(node, 't');
-        for (const child of tChildren) {
-          if ('#text' in child) {
-            text += child['#text'] as string;
-          }
-        }
-      } else if ('r' in node) {
-        // Rich text: <r><t>value</t></r>
-        const rChildren = getChildren(node, 'r');
-        for (const rChild of rChildren) {
-          if ('t' in rChild) {
-            const tChildren = getChildren(rChild, 't');
-            for (const child of tChildren) {
-              if ('#text' in child) {
-                text += child['#text'] as string;
-              }
-            }
-          }
-        }
-      }
-    }
-    return text;
-  }
-
-  /**
-   * Get a string by index
-   */
-  getString(index: number): string | undefined {
-    return this.entries[index]?.text;
-  }
-
-  /**
-   * Add a string and return its index
-   * If the string already exists, returns the existing index
-   */
-  addString(str: string): number {
-    const existing = this.stringToIndex.get(str);
-    if (existing !== undefined) {
-      this._totalCount++;
-      this._dirty = true;
-      return existing;
-    }
-    const index = this.entries.length;
-    const tElement = createElement('t', str.startsWith(' ') || str.endsWith(' ') ? { 'xml:space': 'preserve' } : {}, [
-      createText(str),
-    ]);
-    const siElement = createElement('si', {}, [tElement]);
-    this.entries.push({ text: str, node: siElement });
-    this.stringToIndex.set(str, index);
-    this._totalCount++;
-    this._dirty = true;
-    return index;
-  }
-
-  /**
-   * Check if the shared strings table has been modified
-   */
-  get dirty(): boolean {
-    return this._dirty;
-  }
-
-  /**
-   * Get the count of strings
-   */
-  get count(): number {
-    return this.entries.length;
-  }
-
-  /**
-   * Get total usage count of shared strings
-   */
-  get totalCount(): number {
-    return Math.max(this._totalCount, this.entries.length);
-  }
-
-  /**
-   * Generate XML for the shared strings table
-   */
-  toXml(): string {
-    const siElements: XmlNode[] = [];
-    for (const entry of this.entries) {
-      if (entry.node) {
-        siElements.push(entry.node);
-      } else {
-        const str = entry.text;
-        const tElement = createElement(
-          't',
-          str.startsWith(' ') || str.endsWith(' ') ? { 'xml:space': 'preserve' } : {},
-          [createText(str)],
-        );
-        const siElement = createElement('si', {}, [tElement]);
-        siElements.push(siElement);
-      }
-    }
-
-    const totalCount = Math.max(this._totalCount, this.entries.length);
-    const sst = createElement(
-      'sst',
-      {
-        xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
-        count: String(totalCount),
-        uniqueCount: String(this.entries.length),
-      },
-      siElements,
-    );
-
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([sst])}`;
-  }
-}
-
-interface SharedStringEntry {
-  text: string;
-  node?: XmlNode;
-}
+import {
+  parseXml,
+  findElement,
+  getChildren,
+  getAttr,
+  XmlNode,
+  stringifyXml,
+  createElement,
+  createText,
+} from './utils/xml';
+
+/**
+ * Manages the shared strings table from xl/sharedStrings.xml
+ * Excel stores strings in a shared table to reduce file size
+ */
+export class SharedStrings {
+  private entries: SharedStringEntry[] = [];
+  private stringToIndex: Map<string, number> = new Map();
+  private _dirty = false;
+  private _totalCount = 0;
+
+  /**
+   * Parse shared strings from XML content
+   */
+  static parse(xml: string): SharedStrings {
+    const ss = new SharedStrings();
+    const parsed = parseXml(xml);
+    const sst = findElement(parsed, 'sst');
+    if (!sst) return ss;
+
+    const countAttr = getAttr(sst, 'count');
+    if (countAttr) {
+      const total = parseInt(countAttr, 10);
+      if (Number.isFinite(total) && total >= 0) {
+        ss._totalCount = total;
+      }
+    }
+
+    const children = getChildren(sst, 'sst');
+    for (const child of children) {
+      if ('si' in child) {
+        const siChildren = getChildren(child, 'si');
+        const text = ss.extractText(siChildren);
+        ss.entries.push({ text, node: child });
+        ss.stringToIndex.set(text, ss.entries.length - 1);
+      }
+    }
+
+    if (ss._totalCount === 0 && ss.entries.length > 0) {
+      ss._totalCount = ss.entries.length;
+    }
+
+    return ss;
+  }
+
+  /**
+   * Extract text from a string item (si element)
+   * Handles both simple <t> elements and rich text <r> elements
+   */
+  private extractText(nodes: XmlNode[]): string {
+    let text = '';
+    for (const node of nodes) {
+      if ('t' in node) {
+        // Simple text: <t>value</t>
+        const tChildren = getChildren(node, 't');
+        for (const child of tChildren) {
+          if ('#text' in child) {
+            text += child['#text'] as string;
+          }
+        }
+      } else if ('r' in node) {
+        // Rich text: <r><t>value</t></r>
+        const rChildren = getChildren(node, 'r');
+        for (const rChild of rChildren) {
+          if ('t' in rChild) {
+            const tChildren = getChildren(rChild, 't');
+            for (const child of tChildren) {
+              if ('#text' in child) {
+                text += child['#text'] as string;
+              }
+            }
+          }
+        }
+      }
+    }
+    return text;
+  }
+
+  /**
+   * Get a string by index
+   */
+  getString(index: number): string | undefined {
+    return this.entries[index]?.text;
+  }
+
+  /**
+   * Add a string and return its index
+   * If the string already exists, returns the existing index
+   */
+  addString(str: string): number {
+    const existing = this.stringToIndex.get(str);
+    if (existing !== undefined) {
+      this._totalCount++;
+      this._dirty = true;
+      return existing;
+    }
+    const index = this.entries.length;
+    const tElement = createElement('t', str.startsWith(' ') || str.endsWith(' ') ? { 'xml:space': 'preserve' } : {}, [
+      createText(str),
+    ]);
+    const siElement = createElement('si', {}, [tElement]);
+    this.entries.push({ text: str, node: siElement });
+    this.stringToIndex.set(str, index);
+    this._totalCount++;
+    this._dirty = true;
+    return index;
+  }
+
+  /**
+   * Check if the shared strings table has been modified
+   */
+  get dirty(): boolean {
+    return this._dirty;
+  }
+
+  /**
+   * Get the count of strings
+   */
+  get count(): number {
+    return this.entries.length;
+  }
+
+  /**
+   * Get total usage count of shared strings
+   */
+  get totalCount(): number {
+    return Math.max(this._totalCount, this.entries.length);
+  }
+
+  /**
+   * Generate XML for the shared strings table
+   */
+  toXml(): string {
+    const siElements: XmlNode[] = [];
+    for (const entry of this.entries) {
+      if (entry.node) {
+        siElements.push(entry.node);
+      } else {
+        const str = entry.text;
+        const tElement = createElement(
+          't',
+          str.startsWith(' ') || str.endsWith(' ') ? { 'xml:space': 'preserve' } : {},
+          [createText(str)],
+        );
+        const siElement = createElement('si', {}, [tElement]);
+        siElements.push(siElement);
+      }
+    }
+
+    const totalCount = Math.max(this._totalCount, this.entries.length);
+    const sst = createElement(
+      'sst',
+      {
+        xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+        count: String(totalCount),
+        uniqueCount: String(this.entries.length),
+      },
+      siElements,
+    );
+
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([sst])}`;
+  }
+}
+
+interface SharedStringEntry {
+  text: string;
+  node?: XmlNode;
+}