to-spreadsheet 1.1.5 → 1.3.0

package/README.md

@@ -3,11 +3,12 @@ npm package to create spreadsheet in node environment and in browser
 
 
 [![npm version](https://img.shields.io/npm/v/to-spreadsheet.svg)](https://www.npmjs.com/package/to-spreadsheet)
-[![minified](https://badgen.net/bundlephobia/min/to-spreadsheet)](https://bundlephobia.com/result?p=to-spreadsheet)
-[![minified + gzipped](https://badgen.net/bundlephobia/minzip/to-spreadsheet)](https://bundlephobia.com/result?p=to-spreadsheet)
+[![minified](https://badgen.net/bundlephobia/min/to-spreadsheet)](https://badgen.net/bundlephobia/min/to-spreadsheet)
+[![minified + gzipped](https://badgen.net/bundlephobia/minzip/to-spreadsheet)](https://badgen.net/bundlephobia/minzip/to-spreadsheet)
 
 [![GitHub stars](https://img.shields.io/github/stars/maifeeulasad/to-spreadsheet)](https://github.com/maifeeulasad/to-spreadsheet/stargazers)
 [![GitHub watchers](https://img.shields.io/github/watchers/maifeeulasad/to-spreadsheet)](https://github.com/maifeeulasad/to-spreadsheet/watchers)
+[![Commits after release](https://img.shields.io/github/commits-since/maifeeulasad/to-spreadsheet/latest/main?include_prereleases)](https://img.shields.io/github/commits-since/maifeeulasad/to-spreadsheet/latest/main?include_prereleases)
 
 # NPM
 ```
@@ -39,8 +40,371 @@ generateExcel(sampleData); // <-- by default generate XLSX for node
 generateExcel(sampleData, EnvironmentType.BROWSER); // <-- for browser
 ```
 
+# Cell Features
+
+## Dates
+
+You can create date cells that are properly formatted in Excel:
+
+### Basic Date Usage
+
+```ts
+import { 
+  generateExcel, 
+  createDateCell, 
+  createBorderedDateCell,
+  createBackgroundDateCell 
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'DateDemo',
+    content: [
+      [
+        'Event',
+        'Date',
+        'Styled Date'
+      ],
+      [
+        'Project Start',
+        createDateCell(new Date('2024-01-01')),
+        createBorderedDateCell(new Date('2024-01-15'), createAllBorders())
+      ],
+      [
+        'Milestone',
+        createDateCell(new Date()),
+        createBackgroundDateCell(new Date('2024-12-25'), '#FFCCCC')
+      ]
+    ]
+  }
+];
+```
+
+### Date Helper Functions
+
+- `createDateCell(date, style?)` - Creates a date cell with optional styling
+- `createBorderedDateCell(date, border)` - Creates a date cell with borders
+- `createBackgroundDateCell(date, backgroundColor)` - Creates a date cell with background color
+
+## Colors
+
+You can add background and foreground colors to cells:
+
+### Basic Color Usage
+
+```ts
+import { 
+  generateExcel, 
+  createBackgroundCell, 
+  createForegroundCell, 
+  createColoredCell,
+  createStyledCell
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'ColorDemo',
+    content: [
+      [
+        'Feature',
+        'Background Color',
+        'Foreground Color',
+        'Both Colors'
+      ],
+      [
+        'Yellow Background',
+        createBackgroundCell('Highlighted', '#FFFF00'),
+        createForegroundCell('Red Text', '#FF0000'),
+        createColoredCell('Green BG, Red Text', '#00FF00', '#FF0000')
+      ],
+      [
+        'Complex Styling',
+        createStyledCell('Full Style', {
+          backgroundColor: '#FFFFCC',
+          foregroundColor: '#0000FF',
+          border: createAllBorders(BorderStyle.thick, '#000000')
+        }),
+        'Regular cell',
+        42
+      ]
+    ]
+  }
+];
+```
+
+### Color Helper Functions
+
+- `createBackgroundCell(value, backgroundColor)` - Creates cell with background color
+- `createForegroundCell(value, foregroundColor)` - Creates cell with text color
+- `createColoredCell(value, backgroundColor, foregroundColor)` - Creates cell with both colors
+- `createStyledCell(value, style)` - Creates cell with full styling options
+
 # Features
  - [x] Multiple sheet support
  - [x] Equations
- - [ ] Cell styling
- - [ ] Sheet styling
+ - [x] Cell borders
+ - [x] Cell styling (background colors, foreground colors, dates)
+ - [x] Date cells with proper Excel formatting
+ - [x] Cell alignment (horizontal and vertical)
+ - [ ] Sheet styling
+
+## Cell Borders
+
+You can add borders to cells using the border functionality:
+
+### Basic Border Usage
+
+```ts
+import { 
+  generateExcel, 
+  createBorderedCell, 
+  createAllBorders, 
+  createTopBorder, 
+  createBottomBorder, 
+  createLeftBorder, 
+  createRightBorder,
+  BorderStyle 
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'BorderDemo',
+    content: [
+      [
+        // Create cells with all borders
+        createBorderedCell('Header 1', createAllBorders(BorderStyle.thick, '#000000')),
+        createBorderedCell('Header 2', createAllBorders(BorderStyle.thick, '#000000'))
+      ],
+      [
+        // Create cells with specific borders
+        createBorderedCell('Data 1', createTopBorder()),
+        createBorderedCell(100, createRightBorder()),
+        createBorderedCell('Final', createBottomBorder())
+      ]
+    ]
+  }
+];
+
+generateExcel(data);
+```
+
+### Border Styles
+
+Available border styles:
+- `BorderStyle.none` - No border
+- `BorderStyle.thin` - Thin border (default)
+- `BorderStyle.medium` - Medium border
+- `BorderStyle.thick` - Thick border  
+- `BorderStyle.double` - Double border
+- `BorderStyle.dotted` - Dotted border
+- `BorderStyle.dashed` - Dashed border
+
+### Border Helper Functions
+
+**Border Creation:**
+- `createAllBorders(style?, color?)` - Creates borders on all sides
+- `createTopBorder(style?, color?)` - Creates only top border
+- `createBottomBorder(style?, color?)` - Creates only bottom border
+- `createLeftBorder(style?, color?)` - Creates only left border
+- `createRightBorder(style?, color?)` - Creates only right border
+- `createBorder(borderConfig)` - Creates custom border configuration
+
+**Cell Creation:**
+- `createBorderedCell(value, border)` - Creates a cell with border
+- `createStyledCell(value, style)` - Creates a cell with custom styling
+
+### Advanced Border Usage
+
+```ts
+import { createStyledCell, BorderStyle } from 'to-spreadsheet/lib/index';
+
+// Custom border configuration
+const customCell = createStyledCell('Custom', {
+  border: {
+    left: BorderStyle.double,
+    top: BorderStyle.thin,
+    right: BorderStyle.dashed,
+    bottom: BorderStyle.thick,
+    color: '#FF0000' // Red borders
+  }
+});
+
+// Mix styled and regular cells
+const data = [
+  {
+    title: 'Mixed',
+    content: [
+      [customCell, 'Regular Cell', 42]
+    ]
+  }
+];
+```
+
+## Combined Styling
+
+All styling features can be combined together:
+
+```ts
+import { 
+  createStyledCell, 
+  createAllBorders, 
+  BorderStyle 
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'CombinedDemo',
+    content: [
+      [
+        // Cell with background color, text color, and borders
+        createStyledCell('Fully Styled', {
+          backgroundColor: '#FFFFCC',    // Light yellow background
+          foregroundColor: '#0000FF',    // Blue text
+          border: createAllBorders(BorderStyle.thick, '#FF0000') // Red thick border
+        }),
+        
+        // Date with background and border
+        createDateCell(new Date(), {
+          backgroundColor: '#CCFFCC',    // Light green background
+          border: createAllBorders(BorderStyle.double, '#008000') // Green double border
+        }),
+        
+        // Regular cells for comparison
+        'Plain text',
+        42
+      ]
+    ]
+  }
+];
+```
+
+### Color Format
+
+Colors should be specified in hex format:
+- `#FF0000` - Red
+- `#00FF00` - Green  
+- `#0000FF` - Blue
+- `#FFFF00` - Yellow
+- `#FF00FF` - Magenta
+- `#00FFFF` - Cyan
+- `#000000` - Black
+- `#FFFFFF` - White
+- `#CCCCCC` - Light gray
+
+## Cell Alignment
+
+You can align cell content both horizontally and vertically:
+
+### Basic Alignment Usage
+
+```ts
+import { 
+  generateExcel, 
+  createHorizontallyAlignedCell, 
+  createVerticallyAlignedCell, 
+  createAlignedCell,
+  createCenteredCell,
+  HorizontalAlignment, 
+  VerticalAlignment 
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'AlignmentDemo',
+    content: [
+      [
+        'Feature',
+        'Horizontal',
+        'Vertical',
+        'Both'
+      ],
+      [
+        'Left Align',
+        createHorizontallyAlignedCell('Left Text', HorizontalAlignment.left),
+        createVerticallyAlignedCell('Top Text', VerticalAlignment.top),
+        createAlignedCell('Top-Left', HorizontalAlignment.left, VerticalAlignment.top)
+      ],
+      [
+        'Center Align',
+        createHorizontallyAlignedCell('Center Text', HorizontalAlignment.center),
+        createVerticallyAlignedCell('Center Text', VerticalAlignment.center),
+        createCenteredCell('Full Center')
+      ],
+      [
+        'Right Align',
+        createHorizontallyAlignedCell('Right Text', HorizontalAlignment.right),
+        createVerticallyAlignedCell('Bottom Text', VerticalAlignment.bottom),
+        createAlignedCell('Bottom-Right', HorizontalAlignment.right, VerticalAlignment.bottom)
+      ]
+    ]
+  }
+];
+```
+
+### Horizontal Alignment Options
+
+- `HorizontalAlignment.general` - General alignment (Excel default)
+- `HorizontalAlignment.left` - Left alignment
+- `HorizontalAlignment.center` - Center alignment  
+- `HorizontalAlignment.right` - Right alignment
+- `HorizontalAlignment.fill` - Fill alignment
+- `HorizontalAlignment.justify` - Justify alignment
+- `HorizontalAlignment.centerContinuous` - Center across selection
+- `HorizontalAlignment.distributed` - Distributed alignment
+
+### Vertical Alignment Options
+
+- `VerticalAlignment.top` - Top alignment
+- `VerticalAlignment.center` - Center alignment
+- `VerticalAlignment.bottom` - Bottom alignment
+- `VerticalAlignment.justify` - Justify alignment
+- `VerticalAlignment.distributed` - Distributed alignment
+
+### Alignment Helper Functions
+
+- `createHorizontallyAlignedCell(value, alignment)` - Creates cell with horizontal alignment
+- `createVerticallyAlignedCell(value, alignment)` - Creates cell with vertical alignment
+- `createAlignedCell(value, horizontal, vertical)` - Creates cell with both alignments
+- `createCenteredCell(value)` - Creates center-aligned cell (convenience function)
+
+### Combined with Other Features
+
+Alignment works seamlessly with all other styling features:
+
+```ts
+import { 
+  createStyledCell, 
+  HorizontalAlignment, 
+  VerticalAlignment,
+  createAllBorders, 
+  BorderStyle 
+} from 'to-spreadsheet/lib/index';
+
+const data = [
+  {
+    title: 'ComplexStyling',
+    content: [
+      [
+        // Full styling with alignment, colors, and borders
+        createStyledCell('Complete Style', {
+          horizontalAlignment: HorizontalAlignment.center,
+          verticalAlignment: VerticalAlignment.center,
+          backgroundColor: '#CCFFCC',
+          foregroundColor: '#FF0000',
+          border: createAllBorders(BorderStyle.thick, '#000000')
+        }),
+        
+        // Aligned date cell
+        createDateCell(new Date(), {
+          horizontalAlignment: HorizontalAlignment.right,
+          verticalAlignment: VerticalAlignment.center,
+          backgroundColor: '#FFFFCC'
+        }),
+        
+        // Simple centered text
+        createCenteredCell('Centered')
+      ]
+    ]
+  }
+];
+```

package/lib/generate-excel.js

@@ -14,7 +14,23 @@ const sheet_xml_1 = require("./xl/worksheets/sheet.xml");
 const index_1 = require("./index");
 const util_1 = require("./util");
 const generateTree = (workbook) => {
-    return Object.assign({ "[Content_Types].xml": (0, content_types_xml_1.generateContentTypesXml)(workbook), "_rels/.rels": (0, _rels_1.generateRels)(), "docProps/app.xml": (0, app_xml_1.generateAppXml)(workbook), "docProps/core.xml": (0, core_xml_1.generateCoreXml)({}), "xl/_rels/workbook.xml.rels": (0, workbook_xml_rels_1.generateWorkBookXmlRels)(workbook), "xl/sharedStrings.xml": (0, sharedStrings_xml_1.generateSharedStrings)(workbook), "xl/styles.xml": (0, styles_xml_1.generateStyleXml)(), "xl/theme/theme1.xml": (0, theme1_xml_1.generateTheme1)(), "xl/workbook.xml": (0, workbook_xml_1.generateWorkBookXml)(workbook) }, workbook.sheets.reduce((acc, sheet, idx) => (Object.assign(Object.assign({}, acc), { [`xl/worksheets/sheet${idx + 1}.xml`]: (0, sheet_xml_1.generateSheetXml)(sheet) })), {}));
+    const styleMap = new Map();
+    styleMap.set("default", {});
+    let hasDateCells = false;
+    workbook.sheets.forEach(sheet => {
+        sheet.rows.forEach(row => {
+            row.cells.forEach(cell => {
+                if (cell.type === index_1.ICellType.date) {
+                    hasDateCells = true;
+                }
+                if ('style' in cell && cell.style) {
+                    const styleKey = (0, util_1.getStyleKey)(cell.style);
+                    styleMap.set(styleKey, cell.style);
+                }
+            });
+        });
+    });
+    return Object.assign({ "[Content_Types].xml": (0, content_types_xml_1.generateContentTypesXml)(workbook), "_rels/.rels": (0, _rels_1.generateRels)(), "docProps/app.xml": (0, app_xml_1.generateAppXml)(workbook), "docProps/core.xml": (0, core_xml_1.generateCoreXml)({}), "xl/_rels/workbook.xml.rels": (0, workbook_xml_rels_1.generateWorkBookXmlRels)(workbook), "xl/sharedStrings.xml": (0, sharedStrings_xml_1.generateSharedStrings)(workbook), "xl/styles.xml": (0, styles_xml_1.generateStyleXml)(styleMap, hasDateCells), "xl/theme/theme1.xml": (0, theme1_xml_1.generateTheme1)(), "xl/workbook.xml": (0, workbook_xml_1.generateWorkBookXml)(workbook) }, workbook.sheets.reduce((acc, sheet, idx) => (Object.assign(Object.assign({}, acc), { [`xl/worksheets/sheet${idx + 1}.xml`]: (0, sheet_xml_1.generateSheetXml)(sheet, styleMap, hasDateCells) })), {}));
 };
 var EnvironmentType;
 (function (EnvironmentType) {
@@ -26,9 +42,10 @@ const generateExcel = (dump, environmentType = EnvironmentType.NODE) => {
     const strings = [];
     const sheets = dump.map(({ title, content }) => {
         const rows = content.map(row => {
-            const cells = row.flatMap(content => {
+            const cells = [];
+            row.forEach(content => {
                 if (typeof content === 'number') {
-                    return { type: index_1.ICellType.number, value: content };
+                    cells.push({ type: index_1.ICellType.number, value: content });
                 }
                 else if (typeof content === 'string') {
                     const type = index_1.ICellType.string;
@@ -37,16 +54,32 @@ const generateExcel = (dump, environmentType = EnvironmentType.NODE) => {
                         strings.push(content);
                         value = strings.length - 1;
                     }
-                    return { type: index_1.ICellType.string, value };
+                    cells.push({ type: index_1.ICellType.string, value });
                 }
                 else if (content instanceof util_1.SkipCell) {
-                    return new Array(content.getSkipCell()).fill({ type: index_1.ICellType.skip, value: undefined });
+                    for (let i = 0; i < content.getSkipCell(); i++) {
+                        cells.push({ type: index_1.ICellType.skip, value: undefined });
+                    }
                 }
                 else if (content instanceof util_1.Equation) {
-                    return { type: index_1.ICellType.equation, value: content };
+                    cells.push({ type: index_1.ICellType.equation, value: content });
+                }
+                else if (content && typeof content === 'object' && 'type' in content) {
+                    const cell = content;
+                    if (cell.type === index_1.ICellType.string && typeof cell.value === 'string') {
+                        let stringIndex = strings.indexOf(cell.value);
+                        if (stringIndex === -1) {
+                            strings.push(cell.value);
+                            stringIndex = strings.length - 1;
+                        }
+                        cells.push(Object.assign(Object.assign({}, cell), { value: stringIndex }));
+                    }
+                    else {
+                        cells.push(cell);
+                    }
                 }
                 else {
-                    return { type: index_1.ICellType.skip };
+                    cells.push({ type: index_1.ICellType.skip });
                 }
             });
             return { cells };

package/lib/index.d.ts

@@ -1,18 +1,61 @@
 import { generateExcel, EnvironmentType } from "./generate-excel";
-import { SkipCell, skipCell, Equation, writeEquation } from "./util";
+import { SkipCell, skipCell, Equation, writeEquation, createBorder, createAllBorders, createTopBorder, createBottomBorder, createLeftBorder, createRightBorder, createStyledCell, createBorderedCell, createDateCell, createBorderedDateCell, createBackgroundCell, createForegroundCell, createColoredCell, createBackgroundDateCell, createHorizontallyAlignedCell, createVerticallyAlignedCell, createAlignedCell, createCenteredCell } from "./util";
 declare enum ICellType {
     string = "s",
     number = "n",
+    date = "d",
     skip = "skip",
     equation = "equation"
 }
+declare enum BorderStyle {
+    none = "none",
+    thin = "thin",
+    medium = "medium",
+    thick = "thick",
+    double = "double",
+    dotted = "dotted",
+    dashed = "dashed"
+}
+declare enum HorizontalAlignment {
+    general = "general",
+    left = "left",
+    center = "center",
+    right = "right",
+    fill = "fill",
+    justify = "justify",
+    centerContinuous = "centerContinuous",
+    distributed = "distributed"
+}
+declare enum VerticalAlignment {
+    top = "top",
+    center = "center",
+    bottom = "bottom",
+    justify = "justify",
+    distributed = "distributed"
+}
+interface IBorder {
+    top?: BorderStyle;
+    right?: BorderStyle;
+    bottom?: BorderStyle;
+    left?: BorderStyle;
+    color?: string;
+}
+interface ICellStyle {
+    border?: IBorder;
+    backgroundColor?: string;
+    foregroundColor?: string;
+    horizontalAlignment?: HorizontalAlignment;
+    verticalAlignment?: VerticalAlignment;
+}
 interface ICellString {
     type: ICellType.string;
     value: number;
+    style?: ICellStyle;
 }
 interface ICellNumber {
     type: ICellType.number;
     value: number;
+    style?: ICellStyle;
 }
 interface ICellSkip {
     type: ICellType.skip;
@@ -20,8 +63,14 @@ interface ICellSkip {
 interface ICellEquation {
     type: ICellType.equation;
     value: Equation;
+    style?: ICellStyle;
+}
+interface ICellDate {
+    type: ICellType.date;
+    value: Date;
+    style?: ICellStyle;
 }
-declare type ICell = ICellString | ICellNumber | ICellSkip | ICellEquation;
+declare type ICell = ICellString | ICellNumber | ICellDate | ICellSkip | ICellEquation;
 interface IRows {
     cells: ICell[];
 }
@@ -36,9 +85,9 @@ interface IWorkbook {
 }
 interface IPage {
     title: string;
-    content: (string | number | undefined | SkipCell | Equation)[][];
+    content: (string | number | undefined | SkipCell | Equation | ICell)[][];
 }
-export { ICell, ISheet, IWorkbook, IRows, ICellType, IPage };
+export { ICell, ISheet, IWorkbook, IRows, ICellType, IPage, BorderStyle, IBorder, ICellStyle, ICellDate, HorizontalAlignment, VerticalAlignment };
 declare const sampleData: ({
     title: string;
     content: (string[] | (number | Equation)[])[];
@@ -48,5 +97,8 @@ declare const sampleData: ({
 } | {
     title: string;
     content: (string | undefined)[][];
+} | {
+    title: string;
+    content: (string | number | ICell)[][];
 })[];
-export { generateExcel, sampleData, EnvironmentType, skipCell, writeEquation };
+export { generateExcel, sampleData, EnvironmentType, skipCell, writeEquation, createBorder, createAllBorders, createTopBorder, createBottomBorder, createLeftBorder, createRightBorder, createStyledCell, createBorderedCell, createDateCell, createBorderedDateCell, createBackgroundCell, createForegroundCell, createColoredCell, createBackgroundDateCell, createHorizontallyAlignedCell, createVerticallyAlignedCell, createAlignedCell, createCenteredCell };

package/lib/index.js

@@ -1,20 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeEquation = exports.skipCell = exports.EnvironmentType = exports.sampleData = exports.generateExcel = exports.ICellType = void 0;
+exports.createCenteredCell = exports.createAlignedCell = exports.createVerticallyAlignedCell = exports.createHorizontallyAlignedCell = exports.createBackgroundDateCell = exports.createColoredCell = exports.createForegroundCell = exports.createBackgroundCell = exports.createBorderedDateCell = exports.createDateCell = exports.createBorderedCell = exports.createStyledCell = exports.createRightBorder = exports.createLeftBorder = exports.createBottomBorder = exports.createTopBorder = exports.createAllBorders = exports.createBorder = exports.writeEquation = exports.skipCell = exports.EnvironmentType = exports.sampleData = exports.generateExcel = exports.VerticalAlignment = exports.HorizontalAlignment = exports.BorderStyle = exports.ICellType = void 0;
 const generate_excel_1 = require("./generate-excel");
 Object.defineProperty(exports, "generateExcel", { enumerable: true, get: function () { return generate_excel_1.generateExcel; } });
 Object.defineProperty(exports, "EnvironmentType", { enumerable: true, get: function () { return generate_excel_1.EnvironmentType; } });
 const util_1 = require("./util");
 Object.defineProperty(exports, "skipCell", { enumerable: true, get: function () { return util_1.skipCell; } });
 Object.defineProperty(exports, "writeEquation", { enumerable: true, get: function () { return util_1.writeEquation; } });
+Object.defineProperty(exports, "createBorder", { enumerable: true, get: function () { return util_1.createBorder; } });
+Object.defineProperty(exports, "createAllBorders", { enumerable: true, get: function () { return util_1.createAllBorders; } });
+Object.defineProperty(exports, "createTopBorder", { enumerable: true, get: function () { return util_1.createTopBorder; } });
+Object.defineProperty(exports, "createBottomBorder", { enumerable: true, get: function () { return util_1.createBottomBorder; } });
+Object.defineProperty(exports, "createLeftBorder", { enumerable: true, get: function () { return util_1.createLeftBorder; } });
+Object.defineProperty(exports, "createRightBorder", { enumerable: true, get: function () { return util_1.createRightBorder; } });
+Object.defineProperty(exports, "createStyledCell", { enumerable: true, get: function () { return util_1.createStyledCell; } });
+Object.defineProperty(exports, "createBorderedCell", { enumerable: true, get: function () { return util_1.createBorderedCell; } });
+Object.defineProperty(exports, "createDateCell", { enumerable: true, get: function () { return util_1.createDateCell; } });
+Object.defineProperty(exports, "createBorderedDateCell", { enumerable: true, get: function () { return util_1.createBorderedDateCell; } });
+Object.defineProperty(exports, "createBackgroundCell", { enumerable: true, get: function () { return util_1.createBackgroundCell; } });
+Object.defineProperty(exports, "createForegroundCell", { enumerable: true, get: function () { return util_1.createForegroundCell; } });
+Object.defineProperty(exports, "createColoredCell", { enumerable: true, get: function () { return util_1.createColoredCell; } });
+Object.defineProperty(exports, "createBackgroundDateCell", { enumerable: true, get: function () { return util_1.createBackgroundDateCell; } });
+Object.defineProperty(exports, "createHorizontallyAlignedCell", { enumerable: true, get: function () { return util_1.createHorizontallyAlignedCell; } });
+Object.defineProperty(exports, "createVerticallyAlignedCell", { enumerable: true, get: function () { return util_1.createVerticallyAlignedCell; } });
+Object.defineProperty(exports, "createAlignedCell", { enumerable: true, get: function () { return util_1.createAlignedCell; } });
+Object.defineProperty(exports, "createCenteredCell", { enumerable: true, get: function () { return util_1.createCenteredCell; } });
 var ICellType;
 (function (ICellType) {
     ICellType["string"] = "s";
     ICellType["number"] = "n";
+    ICellType["date"] = "d";
     ICellType["skip"] = "skip";
     ICellType["equation"] = "equation";
 })(ICellType || (ICellType = {}));
 exports.ICellType = ICellType;
+var BorderStyle;
+(function (BorderStyle) {
+    BorderStyle["none"] = "none";
+    BorderStyle["thin"] = "thin";
+    BorderStyle["medium"] = "medium";
+    BorderStyle["thick"] = "thick";
+    BorderStyle["double"] = "double";
+    BorderStyle["dotted"] = "dotted";
+    BorderStyle["dashed"] = "dashed";
+})(BorderStyle || (BorderStyle = {}));
+exports.BorderStyle = BorderStyle;
+var HorizontalAlignment;
+(function (HorizontalAlignment) {
+    HorizontalAlignment["general"] = "general";
+    HorizontalAlignment["left"] = "left";
+    HorizontalAlignment["center"] = "center";
+    HorizontalAlignment["right"] = "right";
+    HorizontalAlignment["fill"] = "fill";
+    HorizontalAlignment["justify"] = "justify";
+    HorizontalAlignment["centerContinuous"] = "centerContinuous";
+    HorizontalAlignment["distributed"] = "distributed";
+})(HorizontalAlignment || (HorizontalAlignment = {}));
+exports.HorizontalAlignment = HorizontalAlignment;
+var VerticalAlignment;
+(function (VerticalAlignment) {
+    VerticalAlignment["top"] = "top";
+    VerticalAlignment["center"] = "center";
+    VerticalAlignment["bottom"] = "bottom";
+    VerticalAlignment["justify"] = "justify";
+    VerticalAlignment["distributed"] = "distributed";
+})(VerticalAlignment || (VerticalAlignment = {}));
+exports.VerticalAlignment = VerticalAlignment;
 const sampleData = [
     {
         title: 'Maifee1', content: [
@@ -26,6 +77,146 @@ const sampleData = [
         ]
     },
     { title: 'Maifee2', content: [[1], [1, (0, util_1.skipCell)(3), 2]] },
-    { title: 'Maifee3', content: [['meaw', undefined, "meaw"], ["woof", 'woof']] }
+    { title: 'Maifee3', content: [['meaw', undefined, "meaw"], ["woof", 'woof']] },
+    {
+        title: 'BorderDemo',
+        content: [
+            [
+                (0, util_1.createBorderedCell)('Product', (0, util_1.createAllBorders)(BorderStyle.thick, '#000000')),
+                (0, util_1.createBorderedCell)('Price', (0, util_1.createAllBorders)(BorderStyle.thick, '#000000')),
+                (0, util_1.createBorderedCell)('Total', (0, util_1.createAllBorders)(BorderStyle.thick, '#000000'))
+            ],
+            [
+                (0, util_1.createBorderedCell)('Apple', (0, util_1.createLeftBorder)()),
+                (0, util_1.createBorderedCell)(10, (0, util_1.createTopBorder)()),
+                (0, util_1.createBorderedCell)(100, (0, util_1.createRightBorder)())
+            ],
+            [
+                (0, util_1.createStyledCell)('Custom', {
+                    border: {
+                        left: BorderStyle.double,
+                        bottom: BorderStyle.thin,
+                        color: '#0000FF'
+                    }
+                }),
+                200,
+                'No Border Cell'
+            ]
+        ]
+    },
+    {
+        title: 'DateDemo',
+        content: [
+            [
+                'Event',
+                'Date',
+                'Bordered Date'
+            ],
+            [
+                'Project Start',
+                (0, util_1.createDateCell)(new Date('2024-01-01')),
+                (0, util_1.createBorderedDateCell)(new Date('2024-01-15'), (0, util_1.createAllBorders)(BorderStyle.thin, '#000000'))
+            ],
+            [
+                'Milestone 1',
+                (0, util_1.createDateCell)(new Date()),
+                (0, util_1.createDateCell)(new Date('2024-12-31'))
+            ],
+            [
+                'Custom Date Style',
+                (0, util_1.createDateCell)(new Date('2024-06-15'), {
+                    border: {
+                        top: BorderStyle.thick,
+                        bottom: BorderStyle.double,
+                        color: '#FF0000'
+                    }
+                }),
+                'Mixed Content'
+            ]
+        ]
+    },
+    {
+        title: 'ColorDemo',
+        content: [
+            [
+                'Feature',
+                'Background Color',
+                'Foreground Color',
+                'Both Colors'
+            ],
+            [
+                'Yellow Background',
+                (0, util_1.createBackgroundCell)('Highlighted', '#FFFF00'),
+                (0, util_1.createForegroundCell)('Red Text', '#FF0000'),
+                (0, util_1.createColoredCell)('Both', '#00FF00', '#FF0000')
+            ],
+            [
+                'More Colors',
+                (0, util_1.createBackgroundCell)('Blue BG', '#0000FF'),
+                (0, util_1.createForegroundCell)('Green Text', '#00FF00'),
+                (0, util_1.createColoredCell)('Purple/White', '#800080', '#FFFFFF')
+            ],
+            [
+                'Date Colors',
+                (0, util_1.createBackgroundDateCell)(new Date(), '#FFCCCC'),
+                (0, util_1.createDateCell)(new Date('2024-12-25'), {
+                    backgroundColor: '#00FF00',
+                    foregroundColor: '#FF0000'
+                }),
+                'Mixed with dates'
+            ],
+            [
+                'With Borders',
+                (0, util_1.createStyledCell)('Complex', {
+                    backgroundColor: '#FFFFCC',
+                    foregroundColor: '#0000FF',
+                    border: (0, util_1.createAllBorders)(BorderStyle.thick, '#000000')
+                }),
+                'Plain text',
+                42
+            ]
+        ]
+    },
+    {
+        title: 'AlignmentDemo',
+        content: [
+            [
+                'Feature',
+                'Horizontal Alignment',
+                'Vertical Alignment',
+                'Both Alignments'
+            ],
+            [
+                'Left Align',
+                (0, util_1.createHorizontallyAlignedCell)('Left Text', HorizontalAlignment.left),
+                (0, util_1.createVerticallyAlignedCell)('Top Text', VerticalAlignment.top),
+                (0, util_1.createAlignedCell)('Top-Left', HorizontalAlignment.left, VerticalAlignment.top)
+            ],
+            [
+                'Center Align',
+                (0, util_1.createHorizontallyAlignedCell)('Center Text', HorizontalAlignment.center),
+                (0, util_1.createVerticallyAlignedCell)('Center Text', VerticalAlignment.center),
+                (0, util_1.createCenteredCell)('Full Center')
+            ],
+            [
+                'Right Align',
+                (0, util_1.createHorizontallyAlignedCell)('Right Text', HorizontalAlignment.right),
+                (0, util_1.createVerticallyAlignedCell)('Bottom Text', VerticalAlignment.bottom),
+                (0, util_1.createAlignedCell)('Bottom-Right', HorizontalAlignment.right, VerticalAlignment.bottom)
+            ],
+            [
+                'Complex Style',
+                (0, util_1.createStyledCell)('All Features', {
+                    horizontalAlignment: HorizontalAlignment.center,
+                    verticalAlignment: VerticalAlignment.center,
+                    backgroundColor: '#CCFFCC',
+                    foregroundColor: '#FF0000',
+                    border: (0, util_1.createAllBorders)(BorderStyle.thick, '#000000')
+                }),
+                (0, util_1.createAlignedCell)(new Date(), HorizontalAlignment.right, VerticalAlignment.center),
+                (0, util_1.createCenteredCell)(42)
+            ]
+        ]
+    }
 ];
 exports.sampleData = sampleData;

package/lib/util.d.ts

@@ -1,4 +1,4 @@
-import { IRows } from ".";
+import { IRows, IBorder, BorderStyle, ICellStyle, ICell, HorizontalAlignment, VerticalAlignment } from ".";
 declare const indexToVbIndex: (index: number) => number;
 declare const indexToVbRelationIndex: (index: number) => number;
 declare const indexToRowIndex: (index: number) => string;
@@ -16,4 +16,25 @@ declare class Equation {
     constructor(equation: string);
 }
 declare const writeEquation: (equation: string) => Equation;
-export { indexToVbIndex, indexToVbRelationIndex, indexToRowIndex, rowColumnToVbPosition, calculateExtant, SkipCell, skipCell, Equation, writeEquation };
+declare const createBorder: (border: IBorder) => IBorder;
+declare const createAllBorders: (style?: BorderStyle, color?: string) => IBorder;
+declare const createTopBorder: (style?: BorderStyle, color?: string) => IBorder;
+declare const createBottomBorder: (style?: BorderStyle, color?: string) => IBorder;
+declare const createLeftBorder: (style?: BorderStyle, color?: string) => IBorder;
+declare const createRightBorder: (style?: BorderStyle, color?: string) => IBorder;
+declare const getBorderKey: (border?: IBorder) => string;
+declare const getStyleKey: (style?: ICellStyle) => string;
+declare const createStyledCell: (value: string | number, style?: ICellStyle) => ICell;
+declare const createBorderedCell: (value: string | number, border: IBorder) => ICell;
+declare const dateToExcelSerial: (date: Date) => number;
+declare const createDateCell: (date: Date, style?: ICellStyle) => ICell;
+declare const createBorderedDateCell: (date: Date, border: IBorder) => ICell;
+declare const createBackgroundCell: (value: string | number, backgroundColor: string) => ICell;
+declare const createForegroundCell: (value: string | number, foregroundColor: string) => ICell;
+declare const createColoredCell: (value: string | number, backgroundColor: string, foregroundColor: string) => ICell;
+declare const createBackgroundDateCell: (date: Date, backgroundColor: string) => ICell;
+declare const createHorizontallyAlignedCell: (value: string | number | Date, alignment: HorizontalAlignment) => ICell;
+declare const createVerticallyAlignedCell: (value: string | number | Date, alignment: VerticalAlignment) => ICell;
+declare const createAlignedCell: (value: string | number | Date, horizontal: HorizontalAlignment, vertical: VerticalAlignment) => ICell;
+declare const createCenteredCell: (value: string | number | Date) => ICell;
+export { indexToVbIndex, indexToVbRelationIndex, indexToRowIndex, rowColumnToVbPosition, calculateExtant, SkipCell, skipCell, Equation, writeEquation, createBorder, createAllBorders, createTopBorder, createBottomBorder, createLeftBorder, createRightBorder, getBorderKey, getStyleKey, createStyledCell, createBorderedCell, dateToExcelSerial, createDateCell, createBorderedDateCell, createBackgroundCell, createForegroundCell, createColoredCell, createBackgroundDateCell, createHorizontallyAlignedCell, createVerticallyAlignedCell, createAlignedCell, createCenteredCell };

package/lib/util.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeEquation = exports.Equation = exports.skipCell = exports.SkipCell = exports.calculateExtant = exports.rowColumnToVbPosition = exports.indexToRowIndex = exports.indexToVbRelationIndex = exports.indexToVbIndex = void 0;
+exports.createCenteredCell = exports.createAlignedCell = exports.createVerticallyAlignedCell = exports.createHorizontallyAlignedCell = exports.createBackgroundDateCell = exports.createColoredCell = exports.createForegroundCell = exports.createBackgroundCell = exports.createBorderedDateCell = exports.createDateCell = exports.dateToExcelSerial = exports.createBorderedCell = exports.createStyledCell = exports.getStyleKey = exports.getBorderKey = exports.createRightBorder = exports.createLeftBorder = exports.createBottomBorder = exports.createTopBorder = exports.createAllBorders = exports.createBorder = exports.writeEquation = exports.Equation = exports.skipCell = exports.SkipCell = exports.calculateExtant = exports.rowColumnToVbPosition = exports.indexToRowIndex = exports.indexToVbRelationIndex = exports.indexToVbIndex = void 0;
+const _1 = require(".");
 const indexToVbIndex = (index) => index + 1;
 exports.indexToVbIndex = indexToVbIndex;
 const indexToVbRelationIndex = (index) => indexToVbIndex(index) + 2;
@@ -38,3 +39,146 @@ class Equation {
 exports.Equation = Equation;
 const writeEquation = (equation) => new Equation(equation);
 exports.writeEquation = writeEquation;
+const createBorder = (border) => border;
+exports.createBorder = createBorder;
+const createAllBorders = (style = _1.BorderStyle.thin, color = "#000000") => ({
+    top: style,
+    right: style,
+    bottom: style,
+    left: style,
+    color
+});
+exports.createAllBorders = createAllBorders;
+const createTopBorder = (style = _1.BorderStyle.thin, color = "#000000") => ({
+    top: style,
+    color
+});
+exports.createTopBorder = createTopBorder;
+const createBottomBorder = (style = _1.BorderStyle.thin, color = "#000000") => ({
+    bottom: style,
+    color
+});
+exports.createBottomBorder = createBottomBorder;
+const createLeftBorder = (style = _1.BorderStyle.thin, color = "#000000") => ({
+    left: style,
+    color
+});
+exports.createLeftBorder = createLeftBorder;
+const createRightBorder = (style = _1.BorderStyle.thin, color = "#000000") => ({
+    right: style,
+    color
+});
+exports.createRightBorder = createRightBorder;
+const getBorderKey = (border) => {
+    if (!border)
+        return "none";
+    const parts = [
+        border.top || "none",
+        border.right || "none",
+        border.bottom || "none",
+        border.left || "none",
+        border.color || "#000000"
+    ];
+    return parts.join("-");
+};
+exports.getBorderKey = getBorderKey;
+const getStyleKey = (style) => {
+    if (!style)
+        return "default";
+    const parts = [
+        getBorderKey(style.border),
+        style.backgroundColor || "no-bg",
+        style.foregroundColor || "no-fg",
+        style.horizontalAlignment || "no-halign",
+        style.verticalAlignment || "no-valign"
+    ];
+    return parts.join("|");
+};
+exports.getStyleKey = getStyleKey;
+const createStyledCell = (value, style) => {
+    if (typeof value === 'string') {
+        return {
+            type: _1.ICellType.string,
+            value: value,
+            style
+        };
+    }
+    else {
+        return {
+            type: _1.ICellType.number,
+            value,
+            style
+        };
+    }
+};
+exports.createStyledCell = createStyledCell;
+const createBorderedCell = (value, border) => {
+    return createStyledCell(value, { border });
+};
+exports.createBorderedCell = createBorderedCell;
+const dateToExcelSerial = (date) => {
+    const excelEpoch = new Date(1900, 0, 1);
+    const diffTime = date.getTime() - excelEpoch.getTime();
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    return diffDays + (date >= new Date(1900, 1, 29) ? 2 : 1);
+};
+exports.dateToExcelSerial = dateToExcelSerial;
+const createDateCell = (date, style) => {
+    return {
+        type: _1.ICellType.date,
+        value: date,
+        style
+    };
+};
+exports.createDateCell = createDateCell;
+const createBorderedDateCell = (date, border) => {
+    return createDateCell(date, { border });
+};
+exports.createBorderedDateCell = createBorderedDateCell;
+const createBackgroundCell = (value, backgroundColor) => {
+    return createStyledCell(value, { backgroundColor });
+};
+exports.createBackgroundCell = createBackgroundCell;
+const createForegroundCell = (value, foregroundColor) => {
+    return createStyledCell(value, { foregroundColor });
+};
+exports.createForegroundCell = createForegroundCell;
+const createColoredCell = (value, backgroundColor, foregroundColor) => {
+    return createStyledCell(value, { backgroundColor, foregroundColor });
+};
+exports.createColoredCell = createColoredCell;
+const createBackgroundDateCell = (date, backgroundColor) => {
+    return createDateCell(date, { backgroundColor });
+};
+exports.createBackgroundDateCell = createBackgroundDateCell;
+const createHorizontallyAlignedCell = (value, alignment) => {
+    if (value instanceof Date) {
+        return createDateCell(value, { horizontalAlignment: alignment });
+    }
+    return createStyledCell(value, { horizontalAlignment: alignment });
+};
+exports.createHorizontallyAlignedCell = createHorizontallyAlignedCell;
+const createVerticallyAlignedCell = (value, alignment) => {
+    if (value instanceof Date) {
+        return createDateCell(value, { verticalAlignment: alignment });
+    }
+    return createStyledCell(value, { verticalAlignment: alignment });
+};
+exports.createVerticallyAlignedCell = createVerticallyAlignedCell;
+const createAlignedCell = (value, horizontal, vertical) => {
+    if (value instanceof Date) {
+        return createDateCell(value, {
+            horizontalAlignment: horizontal,
+            verticalAlignment: vertical
+        });
+    }
+    return createStyledCell(value, {
+        horizontalAlignment: horizontal,
+        verticalAlignment: vertical
+    });
+};
+exports.createAlignedCell = createAlignedCell;
+const createCenteredCell = (value) => {
+    return createAlignedCell(value, _1.HorizontalAlignment.center, _1.VerticalAlignment.center);
+};
+exports.createCenteredCell = createCenteredCell;

package/lib/xl/styles.xml.d.ts

@@ -1,2 +1,3 @@
-declare const generateStyleXml: () => string;
+import { ICellStyle } from "..";
+declare const generateStyleXml: (styleMap: Map<string, ICellStyle>, hasDateCells?: boolean) => string;
 export { generateStyleXml };

package/lib/xl/styles.xml.js

@@ -1,39 +1,159 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleXml = void 0;
-const generateStyleXml = () => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+const __1 = require("..");
+const generateBorderXml = (border) => {
+    const getColorXml = (color) => color ? `<color rgb="${color.replace('#', 'FF')}" />` : '';
+    const getBorderSideXml = (side, color) => {
+        if (!side || side === __1.BorderStyle.none) {
+            return '<left />';
+        }
+        return `<left style="${side}">${getColorXml(color)}</left>`;
+    };
+    const leftXml = !border.left || border.left === __1.BorderStyle.none
+        ? '<left />'
+        : `<left style="${border.left}">${getColorXml(border.color)}</left>`;
+    const rightXml = !border.right || border.right === __1.BorderStyle.none
+        ? '<right />'
+        : `<right style="${border.right}">${getColorXml(border.color)}</right>`;
+    const topXml = !border.top || border.top === __1.BorderStyle.none
+        ? '<top />'
+        : `<top style="${border.top}">${getColorXml(border.color)}</top>`;
+    const bottomXml = !border.bottom || border.bottom === __1.BorderStyle.none
+        ? '<bottom />'
+        : `<bottom style="${border.bottom}">${getColorXml(border.color)}</bottom>`;
+    return `
+    <border>
+      ${leftXml}
+      ${rightXml}
+      ${topXml}
+      ${bottomXml}
+      <diagonal />
+    </border>`;
+};
+const generateFontXml = (color) => {
+    const colorXml = color
+        ? `<color rgb="${color.replace('#', 'FF')}" />`
+        : '<color theme="1" />';
+    return `
+    <font>
+      <sz val="11" />
+      ${colorXml}
+      <name val="Calibri" />
+      <family val="2" />
+      <scheme val="minor" />
+    </font>`;
+};
+const generateFillXml = (color) => {
+    if (!color) {
+        return `
+    <fill>
+      <patternFill patternType="none" />
+    </fill>`;
+    }
+    return `
+    <fill>
+      <patternFill patternType="solid">
+        <fgColor rgb="${color.replace('#', 'FF')}" />
+        <bgColor indexed="64" />
+      </patternFill>
+    </fill>`;
+};
+const generateAlignmentXml = (style) => {
+    const hasAlignment = style.horizontalAlignment || style.verticalAlignment;
+    if (!hasAlignment) {
+        return '';
+    }
+    let alignmentAttrs = '';
+    if (style.horizontalAlignment) {
+        alignmentAttrs += ` horizontal="${style.horizontalAlignment}"`;
+    }
+    if (style.verticalAlignment) {
+        alignmentAttrs += ` vertical="${style.verticalAlignment}"`;
+    }
+    return `<alignment${alignmentAttrs} />`;
+};
+const generateStyleXml = (styleMap, hasDateCells = false) => {
+    const styles = Array.from(styleMap.values());
+    const styleCount = styles.length;
+    const uniqueBorders = new Map();
+    const uniqueFonts = new Map();
+    const uniqueFills = new Map();
+    uniqueBorders.set("none", {});
+    uniqueFonts.set("default", "");
+    uniqueFills.set("none", "");
+    uniqueFills.set("gray125", "");
+    styles.forEach(style => {
+        if (style.border) {
+            uniqueBorders.set(JSON.stringify(style.border), style.border);
+        }
+        if (style.foregroundColor) {
+            uniqueFonts.set(style.foregroundColor, style.foregroundColor);
+        }
+        if (style.backgroundColor) {
+            uniqueFills.set(style.backgroundColor, style.backgroundColor);
+        }
+    });
+    const borderArray = Array.from(uniqueBorders.values());
+    const fontArray = Array.from(uniqueFonts.values());
+    const fillArray = Array.from(uniqueFills.values());
+    const bordersXml = borderArray.map(border => generateBorderXml(border)).join('');
+    const fontsXml = fontArray.map(color => generateFontXml(color || undefined)).join('');
+    const fillsXml = fillArray.map(color => generateFillXml(color || undefined)).join('');
+    const numFmtsXml = hasDateCells
+        ? `<numFmts count="1">
+        <numFmt numFmtId="164" formatCode="mm/dd/yyyy" />
+    </numFmts>`
+        : '';
+    let cellXfsXml = '';
+    let cellXfsCount = styleCount;
+    if (hasDateCells) {
+        cellXfsXml += styles.map((style, index) => {
+            const borderIndex = Array.from(uniqueBorders.keys()).indexOf(JSON.stringify(style.border || {}));
+            const fontIndex = Array.from(uniqueFonts.keys()).indexOf(style.foregroundColor || "default");
+            const fillIndex = Array.from(uniqueFills.keys()).indexOf(style.backgroundColor || "none");
+            const alignmentXml = generateAlignmentXml(style);
+            const applyAlignment = style.horizontalAlignment || style.verticalAlignment ? ' applyAlignment="1"' : '';
+            return `<xf numFmtId="0" fontId="${fontIndex}" fillId="${fillIndex}" borderId="${borderIndex}" xfId="0"${applyAlignment}>${alignmentXml}</xf>`;
+        }).join('\n        ');
+        cellXfsXml += '\n        ';
+        cellXfsXml += styles.map((style, index) => {
+            const borderIndex = Array.from(uniqueBorders.keys()).indexOf(JSON.stringify(style.border || {}));
+            const fontIndex = Array.from(uniqueFonts.keys()).indexOf(style.foregroundColor || "default");
+            const fillIndex = Array.from(uniqueFills.keys()).indexOf(style.backgroundColor || "none");
+            const alignmentXml = generateAlignmentXml(style);
+            const applyAlignment = style.horizontalAlignment || style.verticalAlignment ? ' applyAlignment="1"' : '';
+            return `<xf numFmtId="164" fontId="${fontIndex}" fillId="${fillIndex}" borderId="${borderIndex}" xfId="0"${applyAlignment}>${alignmentXml}</xf>`;
+        }).join('\n        ');
+        cellXfsCount = styleCount * 2;
+    }
+    else {
+        cellXfsXml = styles.map((style, index) => {
+            const borderIndex = Array.from(uniqueBorders.keys()).indexOf(JSON.stringify(style.border || {}));
+            const fontIndex = Array.from(uniqueFonts.keys()).indexOf(style.foregroundColor || "default");
+            const fillIndex = Array.from(uniqueFills.keys()).indexOf(style.backgroundColor || "none");
+            const alignmentXml = generateAlignmentXml(style);
+            const applyAlignment = style.horizontalAlignment || style.verticalAlignment ? ' applyAlignment="1"' : '';
+            return `<xf numFmtId="0" fontId="${fontIndex}" fillId="${fillIndex}" borderId="${borderIndex}" xfId="0"${applyAlignment}>${alignmentXml}</xf>`;
+        }).join('\n        ');
+    }
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x14ac x16r2 xr" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac" xmlns:x16r2="http://schemas.microsoft.com/office/spreadsheetml/2015/02/main" xmlns:xr="http://schemas.microsoft.com/office/spreadsheetml/2014/revision">
-    <fonts count="1" x14ac:knownFonts="1">
-        <font>
-            <sz val="11" />
-            <color theme="1" />
-            <name val="Calibri" />
-            <family val="2" />
-            <scheme val="minor" />
-        </font>
+    ${numFmtsXml}
+    <fonts count="${fontArray.length}" x14ac:knownFonts="1">
+        ${fontsXml}
     </fonts>
-    <fills count="2">
-        <fill>
-            <patternFill patternType="none" />
-        </fill>
-        <fill>
-            <patternFill patternType="gray125" />
-        </fill>
+    <fills count="${fillArray.length}">
+        ${fillsXml}
     </fills>
-    <borders count="1">
-        <border>
-            <left />
-            <right />
-            <top />
-            <bottom />
-            <diagonal />
-        </border>
+    <borders count="${borderArray.length}">
+        ${bordersXml}
     </borders>
     <cellStyleXfs count="1">
         <xf numFmtId="0" fontId="0" fillId="0" borderId="0" />
     </cellStyleXfs>
-    <cellXfs count="1">
-        <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0" />
+    <cellXfs count="${cellXfsCount}">
+        ${cellXfsXml}
     </cellXfs>
     <cellStyles count="1">
         <cellStyle name="Normal" xfId="0" builtinId="0" />
@@ -50,4 +170,5 @@ const generateStyleXml = () => `<?xml version="1.0" encoding="UTF-8" standalone=
     </extLst>
 </styleSheet>
 `;
+};
 exports.generateStyleXml = generateStyleXml;

package/lib/xl/worksheets/sheet.xml.d.ts

@@ -1,3 +1,3 @@
-import { ISheet } from "../..";
-declare const generateSheetXml: (sheet: ISheet) => string;
+import { ISheet, ICellStyle } from "../..";
+declare const generateSheetXml: (sheet: ISheet, styleMap: Map<string, ICellStyle>, hasDateCells?: boolean) => string;
 export { generateSheetXml };

package/lib/xl/worksheets/sheet.xml.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSheetXml = void 0;
 const __1 = require("../..");
 const util_1 = require("../../util");
-const generateSheetXml = (sheet) => {
+const generateSheetXml = (sheet, styleMap, hasDateCells = false) => {
+    const styleToIndex = new Map();
+    Array.from(styleMap.keys()).forEach((key, index) => {
+        styleToIndex.set(key, index);
+    });
     return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <worksheet
   xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
@@ -28,15 +32,37 @@ const generateSheetXml = (sheet) => {
             if (cellType !== __1.ICellType.skip) {
                 const cellPosition = (0, util_1.rowColumnToVbPosition)(cellIndex, rowIndex);
                 const cellValue = cell.value || '';
+                let styleIndex = 0;
+                let isDateCell = cell.type === __1.ICellType.date;
+                if ('style' in cell && cell.style) {
+                    const styleKey = (0, util_1.getStyleKey)(cell.style);
+                    const baseStyleIndex = styleToIndex.get(styleKey) || 0;
+                    if (isDateCell && hasDateCells) {
+                        styleIndex = baseStyleIndex + styleMap.size;
+                    }
+                    else {
+                        styleIndex = baseStyleIndex;
+                    }
+                }
+                else if (isDateCell && hasDateCells) {
+                    styleIndex = styleMap.size;
+                }
                 if (cell.type === __1.ICellType.equation) {
                     rowContent += `
-              <c r="${cellPosition}" t="n">
+              <c r="${cellPosition}" t="n" s="${styleIndex}">
                 <f aca="false">${cell.value.getEquation()}</f>
+              </c>\n`;
+                }
+                else if (cell.type === __1.ICellType.date) {
+                    const excelDateValue = (0, util_1.dateToExcelSerial)(cell.value);
+                    rowContent += `
+              <c r="${cellPosition}" t="n" s="${styleIndex}">
+                <v>${excelDateValue}</v>
               </c>\n`;
                 }
                 else {
                     rowContent += `
-              <c r="${cellPosition}" t="${cellType}">
+              <c r="${cellPosition}" t="${cellType}" s="${styleIndex}">
                 <v>${cellValue}</v>
               </c>\n`;
                 }

package/package.json

@@ -1,8 +1,35 @@
 {
   "name": "to-spreadsheet",
-  "version": "1.1.5",
+  "version": "1.3.0",
   "description": "npm package to create spreadsheet in node environment and in browser",
+  "keywords": [
+    "excel",
+    "xlsx",
+    "spreadsheet",
+    "workbook",
+    "worksheet",
+    "cell",
+    "border",
+    "color",
+    "date",
+    "formula",
+    "equation",
+    "export",
+    "generate",
+    "browser",
+    "node",
+    "typescript",
+    "javascript",
+    "office",
+    "microsoft",
+    "csv",
+    "data-export",
+    "file-generation",
+    "styling",
+    "formatting"
+  ],
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
     "prepare": "npm run build",
     "build": "tsc",
@@ -14,6 +41,9 @@
   },
   "author": "Maifee Ul Asad <maifeeulasad@gmail.com>",
   "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "bugs": {
     "url": "https://github.com/maifeeulasad/to-spreadsheet/issues"
   },
@@ -24,7 +54,9 @@
     "jszip": "^3.10.1"
   },
   "files": [
-    "lib"
+    "lib",
+    "README.md",
+    "LICENSE"
   ],
   "devDependencies": {
     "@types/archiver": "^5.3.3",