react-native-nitro-xlsx 0.2.6 → 0.2.7

package/src/__tests__/index.test.ts

@@ -18,32 +18,124 @@ import {
 } from '../index';
 
 describe('NitroXlsx', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('should export NitroXlsx object', () => {
     expect(NitroXlsx).toBeDefined();
     expect(typeof NitroXlsx).toBe('object');
   });
 
-  it('should have createWorkbook method', () => {
-    expect(NitroXlsx.createWorkbook).toBeDefined();
-    expect(typeof NitroXlsx.createWorkbook).toBe('function');
+  it('createWorkbook returns a workbook implementing the spec surface', () => {
+    const wb = NitroXlsx.createWorkbook();
+    expect(typeof wb.addWorksheet).toBe('function');
+    expect(typeof wb.getBuffer).toBe('function');
+    expect(typeof wb.toJSON).toBe('function');
+    expect(wb.getWorksheetCount()).toBe(0);
+  });
+
+  it('addWorksheet registers the sheet and forwards its argument', () => {
+    const wb = NitroXlsx.createWorkbook();
+    const ws = wb.addWorksheet('Data');
+    expect(ws.getName()).toBe('Data');
+    expect(wb.getWorksheetCount()).toBe(1);
+    expect(wb.getWorksheet(0)).toBe(ws);
+    expect(jest.mocked(wb.addWorksheet).mock.calls[0]).toEqual(['Data']);
+  });
+
+  it('worksheet write/read methods round-trip cell values', () => {
+    const ws = NitroXlsx.createWorkbook().addWorksheet('Data');
+    ws.writeNumber(1, 2, 3.5);
+    expect(ws.getCellValue(1, 2)).toBe(3.5);
+    expect(ws.getCellType(1, 2)).toBe('number');
+    ws.writeString(0, 0, 'Hello');
+    expect(ws.getCellString(0, 0)).toBe('Hello');
+    ws.writeFormula(3, 3, 'A1+B1');
+    expect(ws.hasFormula(3, 3)).toBe(true);
+    expect(ws.formula(3, 3)).toBe('A1+B1');
+    expect(ws.getCellValue(9, 9)).toBeNull();
+  });
+
+  it('getBuffer resolves an ArrayBuffer', async () => {
+    const wb = NitroXlsx.createWorkbook();
+    await expect(wb.getBuffer()).resolves.toBeInstanceOf(ArrayBuffer);
+  });
+
+  it('toJSON returns rows keyed by sheet name', () => {
+    const wb = NitroXlsx.createWorkbook();
+    const ws = wb.addWorksheet('Data');
+    ws.writeString(0, 0, 'Hello');
+    ws.writeNumber(0, 1, 42);
+    expect(wb.toJSON()).toEqual({ Data: [{ '0': 'Hello', '1': 42 }] });
+  });
+
+  it('openWorkbook forwards the path and returns a workbook', () => {
+    const wb = NitroXlsx.openWorkbook('/tmp/report.xlsx');
+    expect(jest.mocked(NitroXlsx.openWorkbook).mock.calls[0]).toEqual(['/tmp/report.xlsx']);
+    expect(typeof wb.addWorksheet).toBe('function');
+    expect(wb.getWorksheetCount()).toBe(0);
   });
 
-  it('should have openWorkbook method', () => {
-    expect(NitroXlsx.openWorkbook).toBeDefined();
-    expect(typeof NitroXlsx.openWorkbook).toBe('function');
+  it('openWorkbookFromBuffer forwards the buffer', () => {
+    const buffer = new ArrayBuffer(16);
+    NitroXlsx.openWorkbookFromBuffer(buffer);
+    expect(jest.mocked(NitroXlsx.openWorkbookFromBuffer).mock.calls[0]?.[0]).toBe(buffer);
   });
 
-  it('should have openWorkbookFromBuffer method', () => {
-    expect(NitroXlsx.openWorkbookFromBuffer).toBeDefined();
-    expect(typeof NitroXlsx.openWorkbookFromBuffer).toBe('function');
+  it('fromJSON forwards the sheet rows and returns a workbook', () => {
+    const data = { Sheet1: [{ Name: 'Alice', Age: 30 }] };
+    const wb = NitroXlsx.fromJSON(data);
+    expect(jest.mocked(NitroXlsx.fromJSON).mock.calls[0]).toEqual([data]);
+    expect(typeof wb.addWorksheet).toBe('function');
   });
 
-  it('should have fromJSON method that accepts a Record of sheet rows', () => {
-    expect(NitroXlsx.fromJSON).toBeDefined();
-    expect(typeof NitroXlsx.fromJSON).toBe('function');
-    expect(() =>
-      NitroXlsx.fromJSON({ Sheet1: [{ Name: 'Alice', Age: 30 }] })
-    ).not.toThrow();
+  it('sheet lookup, rename, clone and delete follow the native contract', () => {
+    const wb = NitroXlsx.createWorkbook();
+    const ws = wb.addWorksheet('Data');
+    wb.updateSheetName('Data', 'Raw');
+    expect(ws.getName()).toBe('Raw');
+    const copy = wb.clone('Raw', 'Copy');
+    expect(copy.getName()).toBe('Copy');
+    expect(wb.getWorksheetCount()).toBe(2);
+    wb.deleteSheet('Copy');
+    expect(wb.getWorksheetCount()).toBe(1);
+  });
+
+  it('lookup misses throw native-style errors parseable by XlsxError.from', () => {
+    expect.assertions(2);
+    const wb = NitroXlsx.createWorkbook();
+    try {
+      wb.getWorksheetByName('missing');
+    } catch (e) {
+      const err = XlsxError.from(e);
+      expect(err.code).toBe('SHEET_NOT_FOUND');
+      expect(err.message).toContain('missing');
+    }
+  });
+
+  it('cell format setters update the read-back getters', () => {
+    const fmt = NitroXlsx.createWorkbook().addCellFormat();
+    fmt.setBold();
+    expect(fmt.getIsBold()).toBe(true);
+    fmt.setNumFormat('0.00%');
+    expect(fmt.getNumFormat()).toBe('0.00%');
+    fmt.setFontSize(14);
+    expect(fmt.getFontSize()).toBe(14);
+  });
+
+  it('conditional formats create rules and round-trip rule edits', () => {
+    const ws = NitroXlsx.createWorkbook().addWorksheet('Data');
+    const cfs = ws.getConditionalFormats();
+    const cf = cfs.create('A1:A5');
+    expect(cf.getSqref()).toBe('A1:A5');
+    expect(cfs.getCount()).toBe(1);
+    const rule = cf.createRule();
+    expect(rule).toBe(0);
+    cf.setRuleType(rule, 1);
+    cf.setRuleFormula(rule, 0, 'A1>5');
+    expect(cf.getRuleType(rule)).toBe(1);
+    expect(cf.getRuleFormula(rule, 0)).toBe('A1>5');
   });
 });
 
@@ -137,9 +229,18 @@ describe('Constants', () => {
       expect(NumFormat.NUMBER).toBe(1);
       expect(NumFormat.CURRENCY).toBe(5);
       expect(NumFormat.PERCENT).toBe(9);
-      expect(NumFormat.DATE_1).toBe(15);
+      expect(NumFormat.SCIENTIFIC).toBe(11);
+      expect(NumFormat.FRACTION_1).toBe(12);
+      expect(NumFormat.DATE_1).toBe(14);
+      expect(NumFormat.TIME_1).toBe(18);
+      expect(NumFormat.DATETIME).toBe(22);
       expect(NumFormat.TEXT).toBe(49);
     });
+
+    it('should not expose nonexistent built-in numFmtIds', () => {
+      expect('SCIENTIFIC_2' in NumFormat).toBe(false);
+      expect('DATE_5' in NumFormat).toBe(false);
+    });
   });
 
   describe('CfType', () => {
@@ -198,6 +299,13 @@ describe('XlsxError', () => {
     expect(err.message).toContain('Worksheet not found: Foo');
   });
 
+  it('should parse native INVALID_ARGUMENT errors', () => {
+    const native = new Error('writeNumber: INVALID_ARGUMENT: bad arg');
+    const err = XlsxError.from(native);
+    expect(err.code).toBe('INVALID_ARGUMENT');
+    expect(err.message).toContain('bad arg');
+  });
+
   it('should wrap unknown errors with INTERNAL_ERROR', () => {
     const err = XlsxError.from(new Error('something odd'));
     expect(err.code).toBe('INTERNAL_ERROR');

package/src/index.ts

@@ -265,7 +265,9 @@ export const Colors = {
   FUCHSIA: 0xFF00FF,
 } as const
 
-// Built-in number format indices
+// Built-in number format indices (ECMA-376 §18.8.30 numFmtId values).
+// Note: ids 5-8 are locale-dependent currency variants; 14-22 are locale-dependent
+// date/time formats. There is no second built-in scientific format (11 is the only one).
 export const NumFormat = {
   GENERAL: 0,
   NUMBER: 1,
@@ -279,18 +281,16 @@ export const NumFormat = {
   PERCENT: 9,
   PERCENT_2: 10,
   SCIENTIFIC: 11,
-  SCIENTIFIC_2: 12,
-  FRACTION_1: 13,
-  FRACTION_2: 14,
-  DATE_1: 15,
-  DATE_2: 16,
-  DATE_3: 17,
-  DATE_4: 18,
-  DATE_5: 19,
-  TIME_1: 20,
-  TIME_2: 21,
-  TIME_3: 22,
-  TIME_4: 23,
+  FRACTION_1: 12,
+  FRACTION_2: 13,
+  DATE_1: 14,
+  DATE_2: 15,
+  DATE_3: 16,
+  DATE_4: 17,
+  TIME_1: 18,
+  TIME_2: 19,
+  TIME_3: 20,
+  TIME_4: 21,
   DATETIME: 22,
   TEXT: 49,
 } as const

package/thirdparty/OpenXLSX/OpenXLSX/headers/OpenXLSX/IZipArchive.hpp

@@ -0,0 +1,361 @@
+/*
+
+   ____                               ____      ___ ____       ____  ____      ___
+  6MMMMb                              `MM(      )M' `MM'      6MMMMb\`MM(      )M'
+ 8P    Y8                              `MM.     d'   MM      6M'    ` `MM.     d'
+6M      Mb __ ____     ____  ___  __    `MM.   d'    MM      MM        `MM.   d'
+MM      MM `M6MMMMb   6MMMMb `MM 6MMb    `MM. d'     MM      YM.        `MM. d'
+MM      MM  MM'  `Mb 6M'  `Mb MMM9 `Mb    `MMd       MM       YMMMMb     `MMd
+MM      MM  MM    MM MM    MM MM'   MM     dMM.      MM           `Mb     dMM.
+MM      MM  MM    MM MMMMMMMM MM    MM    d'`MM.     MM            MM    d'`MM.
+YM      M9  MM    MM MM       MM    MM   d'  `MM.    MM            MM   d'  `MM.
+ 8b    d8   MM.  ,M9 YM    d9 MM    MM  d'    `MM.   MM    / L    ,M9  d'    `MM.
+  YMMMM9    MMYMMM9   YMMMM9 _MM_  _MM_M(_    _)MM_ _MMMMMMM MYMMMM9 _M(_    _)MM_
+            MM
+            MM
+           _MM_
+
+  Copyright (c) 2022, Kenneth Troldal Balslev
+
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  - Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  - Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  - Neither the name of the author nor the
+    names of any contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+#ifndef OPENXLSX_IZIPARCHIVE_HPP
+#define OPENXLSX_IZIPARCHIVE_HPP
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(push)
+#   pragma warning(disable : 4251)
+#   pragma warning(disable : 4275)
+#endif // _MSC_VER
+
+// ===== OpenXLSX Includes ===== //
+#include "OpenXLSX-Exports.hpp"
+
+#include <memory>
+#include <string>
+
+namespace OpenXLSX
+{
+    /**
+     * @brief This class functions as a wrapper around any class that provides the necessary functionality for
+     * a zip archive.
+     * @details This class works by applying 'type erasure'. This enables the use of objects of any class, the only
+     * requirement being that it provides the right interface. No inheritance from a base class is needed.
+     */
+    class OPENXLSX_EXPORT IZipArchive
+    {
+    public:
+        /**
+         * @brief Default constructor
+         */
+        IZipArchive() : m_zipArchive() {} // NOLINT
+
+        /**
+         * @brief Constructor, taking the target object as an argument.
+         * @tparam T The type of the target object (will be auto deducted)
+         * @param x The target object
+         * @note This method is deliberately not marked 'explicit', because as a templated constructor, it should be able
+         * to take any type as an argument. However, only objects that satisfy the required interface can be used.
+         */
+        template<typename T>
+        IZipArchive(const T& zipArchive) : m_zipArchive { std::make_unique<Model<T>>(zipArchive) } {} // NOLINT
+
+        /**
+         * @brief Copy constructor
+         * @param other
+         */
+        IZipArchive(const IZipArchive& other) : m_zipArchive(other.m_zipArchive ? other.m_zipArchive->clone() : nullptr) {}
+
+        /**
+         * @brief Move constructor
+         * @param other
+         */
+        IZipArchive(IZipArchive&& other) noexcept = default;
+
+        /**
+         * @brief Destructor
+         */
+        ~IZipArchive() = default;
+
+        /**
+         * @brief
+         * @tparam T
+         * @param x
+         * @return
+         */
+        template<typename T>
+        inline IZipArchive& operator=(const T& zipArchive)
+        {
+            m_zipArchive = std::make_unique<Model<T>>(zipArchive);
+            return *this;
+        }
+
+        /**
+         * @brief copy assignment shall be disabled until a use case is found
+         * @param other
+         * @return
+         */
+        inline IZipArchive& operator=(const IZipArchive& other) = delete;
+        // inline IZipArchive& operator=(const IZipArchive& other)
+        // {
+        //     IZipArchive copy(other);
+        //     *this = std::move(copy);
+        //     return *this;
+        // }
+
+        /**
+         * @brief
+         * @param other
+         * @return
+         */
+        inline IZipArchive& operator=(IZipArchive&& other) noexcept = default;
+
+        /**
+         * @brief
+         * @return
+         */
+        inline explicit operator bool() const
+        {
+            return isValid();
+        }
+
+        inline bool isValid() const {
+            return m_zipArchive->isValid();
+
+        }
+
+        inline bool isOpen() const {
+            return m_zipArchive->isOpen();
+        }
+
+        inline void open(const std::string& fileName) {
+            m_zipArchive->open(fileName);
+        }
+
+        inline void close() const {
+            m_zipArchive->close();
+        }
+
+        inline void save(const std::string& path) {
+            m_zipArchive->save(path);
+        }
+
+        inline void addEntry(const std::string& name, const std::string& data) {
+            m_zipArchive->addEntry(name, data);
+        }
+
+        inline void addEntryAndCommit(const std::string& name, const std::string& data) {
+            m_zipArchive->addEntryAndCommit(name, data);
+        }
+
+        inline void deleteEntry(const std::string& entryName) {
+            m_zipArchive->deleteEntry(entryName);
+        }
+
+        inline std::string getEntry(const std::string& name) {
+            return m_zipArchive->getEntry(name);
+        }
+
+        inline bool hasEntry(const std::string& entryName) const {
+            return m_zipArchive->hasEntry(entryName);
+        }
+
+    private:
+        /**
+         * @brief
+         */
+        struct Concept
+        {
+        public:
+            /**
+             * @brief
+             */
+            Concept() = default;
+
+            /**
+             * @brief
+             */
+            Concept(const Concept&) = default;
+
+            /**
+             * @brief
+             */
+            Concept(Concept&&) noexcept = default;
+
+            /**
+             * @brief
+             */
+            virtual ~Concept() = default;
+
+            /**
+             * @brief
+             * @return
+             */
+            inline Concept& operator=(const Concept&) = default;
+
+            /**
+             * @brief
+             * @return
+             */
+            inline Concept& operator=(Concept&&) noexcept = default;
+
+            /**
+             * @brief
+             * @return
+             */
+            inline virtual std::unique_ptr<Concept> clone() const = 0;
+
+            inline virtual bool isValid() const = 0;
+
+            inline virtual bool isOpen() const = 0;
+
+            inline virtual void open(const std::string& fileName) = 0;
+
+            inline virtual void close() = 0;
+
+            inline virtual void save (const std::string& path) = 0;
+
+            inline virtual void addEntry(const std::string& name, const std::string& data) = 0;
+
+            inline virtual void addEntryAndCommit(const std::string& name, const std::string& data) = 0;
+
+            inline virtual void deleteEntry(const std::string& entryName) = 0;
+
+            inline virtual std::string getEntry(const std::string& name) = 0;
+
+            inline virtual bool hasEntry(const std::string& entryName) const = 0;
+
+        };
+
+        /**
+         * @brief
+         * @tparam T
+         */
+        template<typename T>
+        struct Model : Concept
+        {
+        public:
+            /**
+             * @brief
+             * @param x
+             */
+            explicit Model(const T& x) : ZipType(x) {}
+
+            /**
+             * @brief
+             * @param other
+             */
+            Model(const Model& other) = default;
+
+            /**
+             * @brief
+             * @param other
+             */
+            Model(Model&& other) noexcept = default;
+
+            /**
+             * @brief
+             */
+            ~Model() override = default;
+
+            /**
+             * @brief
+             * @param other
+             * @return
+             */
+            inline Model& operator=(const Model& other) = default;
+
+            /**
+             * @brief
+             * @param other
+             * @return
+             */
+            inline Model& operator=(Model&& other) noexcept = default;
+
+            /**
+             * @brief
+             * @return
+             */
+            inline std::unique_ptr<Concept> clone() const override
+            {
+                return std::make_unique<Model<T>>(ZipType);
+            }
+
+            inline bool isValid() const override {
+                return ZipType.isValid();
+            }
+
+            inline bool isOpen() const override {
+                return ZipType.isOpen();
+            }
+
+            inline void open(const std::string& fileName) override {
+                ZipType.open(fileName);
+            }
+
+            inline void close() override {
+                ZipType.close();
+            }
+
+            inline void save(const std::string& path) override {
+                ZipType.save(path);
+            }
+
+            inline void addEntry(const std::string& name, const std::string& data) override {
+                ZipType.addEntry(name, data);
+            }
+
+            inline void addEntryAndCommit(const std::string& name, const std::string& data) override {
+                ZipType.addEntryAndCommit(name, data);
+            }
+
+            inline void deleteEntry(const std::string& entryName) override {
+                ZipType.deleteEntry(entryName);
+            }
+
+            inline std::string getEntry(const std::string& name) override {
+                return ZipType.getEntry(name);
+            }
+
+            inline bool hasEntry(const std::string& entryName) const override {
+                return ZipType.hasEntry(entryName);
+            }
+
+        private:
+            T ZipType;
+        };
+
+        std::unique_ptr<Concept> m_zipArchive;
+    };
+
+}    // namespace OpenXLSX
+
+#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
+#   pragma warning(pop)
+#endif // _MSC_VER
+
+#endif    // OPENXLSX_IZIPARCHIVE_HPP

package/thirdparty/OpenXLSX/OpenXLSX/headers/OpenXLSX/OpenXLSX-Exports.hpp

@@ -0,0 +1,12 @@
+#ifndef OPENXLSX_EXPORTS_HPP
+#define OPENXLSX_EXPORTS_HPP
+
+#ifndef OPENXLSX_EXPORT
+#define OPENXLSX_EXPORT
+#endif
+
+#ifndef OPENXLSX_HIDDEN
+#define OPENXLSX_HIDDEN
+#endif
+
+#endif